main.cpp

00001 /* Codigo de ejemplo para probar los PWMs, Tickers, Timer...
00002 * La idea es prender los leds en forma "random" y que los leds cambien su intensidad
00003 * cambiando el duty del PWM que se les manda, simulando "estrellas".
00004 * El comportamiento random lo sacamos del valor de un timer al momento de la lectura. Probamos usar el ADC,
00005 * no logramos que varie.
00006 * El codigo tiene muchos valores "magicos" que salen de probar cosas para que el efecto "quede lindo".
00007 * Copiright Joaquin de Andres, Lucas Chiesa under the GNU GPL Version 2 or later.
00008 */
00009 
00010 #include "mbed.h"
00011 
00012 // Cramos un tipo para guardar el estado actual de cada led.
00013 // NOTA: APAGADO ahora no apaga los leds, sino que les baja el brillo mucho mas rapido porque sino quedaba feo.
00014 typedef enum {SUBIENDO, BAJANDO, APAGADO} led_status;
00015 
00016 // Creamos los PWMs que vamos a usar para alimentar los LEDs.
00017 PwmOut led1(LED1);
00018 PwmOut led2(LED2);
00019 PwmOut led3(LED3);
00020 PwmOut led4(LED4);
00021 
00022 // Creamos un timer.
00023 Timer t;
00024 
00025 // Creamos 4 tickers, cada uno puede tener 1 solo callback.
00026 Ticker tick1;
00027 Ticker tick2;
00028 Ticker tick3;
00029 Ticker tick4;
00030 
00031 led_status led1_status = SUBIENDO;
00032 led_status led2_status = BAJANDO;
00033 led_status led3_status = SUBIENDO;
00034 led_status led4_status = BAJANDO;
00035 
00036 // Handlers para cambiar el PWM de cada led. Como se les pueden pasar argumentos, creamos una para cada uno.
00037 // Supongo que se podria ver alguna forma de reutilizar el codigo.
00038 void led1_tick() {
00039     switch (led1_status) {
00040         case SUBIENDO:
00041             led1 = (led1 < 1)? (led1 + 0.001) : led1;
00042             break;
00043         case BAJANDO:
00044             led1 = (led1 > 0.003)? (led1 - 0.003) : led1;
00045             break;
00046         case APAGADO:
00047             led1 = (led1 >= 0.01)? (led1 - 0.01) : led1;
00048     }
00049 }
00050 
00051 void led2_tick() {
00052     switch (led2_status) {
00053         case SUBIENDO:
00054             led2 = (led2 < 1)? (led2 + 0.002) : led2;
00055             break;
00056         case BAJANDO:
00057             led2 = (led2 > 0.001)? (led2 - 0.001) : led2;
00058             break;
00059         case APAGADO:
00060             led2 = (led2 >= 0.01)? (led2 - 0.01) : led2;
00061     }
00062 }
00063 
00064 void led3_tick() {
00065     switch (led3_status) {
00066         case SUBIENDO:
00067             led3 = (led3 < 1)? (led3 + 0.003) : led3;
00068             break;
00069         case BAJANDO:
00070             led3 = (led3 > 0.004)? (led3 - 0.004) : led3;
00071             break;
00072         case APAGADO:
00073             led3 = (led3 >= 0.01)? (led3 - 0.01) : led3;
00074     }
00075 }
00076 
00077 void led4_tick() {
00078     switch (led4_status) {
00079         case SUBIENDO:
00080             led4 = (led4 < 1)? (led4 + 0.001) : led4;
00081             break;
00082         case BAJANDO:
00083             led4 = (led4 > 0.001)? (led4 - 0.001) : led4;
00084             break;
00085         case APAGADO:
00086             led4 = (led4 >= 0.01)? (led4 - 0.01) : led4;
00087     }
00088 }
00089 
00090 // Esta funcion devuelve un estado segun la variable aux que se le pasa.
00091 led_status set_status (int aux) {
00092     if (aux == 0 ) {
00093         return SUBIENDO;
00094     } else if (aux == 1) {
00095         return BAJANDO;
00096     } else {
00097         return APAGADO;
00098     }
00099 }
00100 
00101 int main() {
00102 // Condiciones iniciales distintas para cada led.
00103     led1 = 0;
00104     led2 = 0.5;
00105     led3 = 0.6;
00106     led4 = 1;
00107 
00108     int aux;
00109 
00110 // Hacemos que cada led cambie a distinta frecuencia, y sin que sean multiplos.
00111     tick1.attach(&led1_tick, 0.002);
00112     tick2.attach(&led2_tick, 0.005);
00113     tick3.attach(&led3_tick, 0.003);
00114     tick4.attach(&led4_tick, 0.001);
00115 
00116 // No hay que olvidarse de iniciar el timer para que esto ande!!
00117     t.start();
00118     wait(0.2);
00119 
00120     while (1) {
00121 // Para cada led, leemos el valor del timer (en distintas unidades),
00122 // le hacemos modulo 3, y eso lo usamos como valor "random" para cambiar el estado de los leds.
00123 
00124         aux = t.read_us();
00125         aux = aux % 3;
00126         led1_status = set_status(aux);
00127         wait(0.001);
00128 
00129         aux = t.read_us();
00130         aux = aux % 3;
00131         led2_status = set_status(aux);
00132         wait(0.002);
00133 
00134         aux = t.read_us();
00135         aux = aux % 3;
00136         led3_status = set_status(aux);
00137         wait(0.005);
00138 
00139         aux = t.read_us()-0.5;
00140         aux = aux % 3;
00141         led4_status = set_status(aux);
00142 
00143         wait(1);
00144     }
00145 }