src/elp.c

   1 // vim: set et sw=4 sts=4 :
   2
   3 #include "debug.h"
   4 #include "elp.h"
   5 #include "reg51.h"
   6 #include "leds.h"
   7 #include "netdev.h"
   8 #include "udp.h"
   9
  10 struct elp_command_t elp_command;
  11
  12 byte elp_read_process_command()
  13 {
  14     byte i;
  15     byte len = ELP_HEADER_SIZE;
  16     netdev_read_start(ELP_HEADER_SIZE);
  17     // Escribimos el bitfield a lo guapo como un byte.
  18     *((byte*) &elp_command) = udp_read_byte();
  19     netdev_read_end();
  20
  21     // Si es un SET lo proceso
  22     switch (elp_command.var)
  23     {
  24         case ELP_VAR_OFF:
  25             // Si es GET, sólo calculamos tamaño de respuesta
  26             if (!elp_command.set)
  27                 return 0; // En este caso no tiene sentido un GET
  28             // Si es SET procesamos (apagamos las luces y nos vamos a dormir)
  29             leds_write(0x0000); // Apago leds
  30             EA = 0; // Ignoramos interrupciones (por si el micro no soporta PD)
  31             PCON = 0x02; // Bit PD (Power Down) prendido
  32             while (1); // Nos negamos a seguir trabajando ( " )
  33             // FIXME: No es del todo elegante esto, porque nunca vamos a
  34             // responder el paquete
  35
  36         case ELP_VAR_MATRIX:
  37             // Si es GET, sólo calculamos tamaño de respuesta
  38             if (!elp_command.set)
  39                 // Vamos a devolver la matriz (2 bytes por columna) y su tamaño
  40                 return len + sizeof(leds_matrix_len) + leds_matrix_len * 2;
  41             // Si es SET procesamos
  42             netdev_read_start(sizeof(leds_matrix_len)); // tamaño
  43             i = udp_read_byte();
  44             netdev_read_end();
  45             // Verifico cantidad de columnas
  46             if ((i < LEDS_MIN_COLS) || (i > LEDS_MAX_COLS))
  47                 return 0;
  48             leds_matrix_len = i;
  49             netdev_read_start(leds_matrix_len * 2); // matriz
  50             for (i = 0; i < leds_matrix_len; ++i)
  51             {
  52                 byte low = udp_read_byte();
  53                 leds_matrix[i] = WORD(udp_read_byte(), low);
  54             }
  55             netdev_read_end();
  56             leds_delay_update(); // Seteamos un delay bueno
  57             return len;
  58
  59         case ELP_VAR_PAUSE:
  60             // Si es GET, sólo calculamos tamaño de respuesta
  61             if (!elp_command.set)
  62                 return len + 1 /* booleano de 1 byte */;
  63             // Si es SET procesamos
  64             netdev_read_start(1); // booleano de 1 byte
  65             if (udp_read_byte() == 0x00) // si viene 0 reanuda
  66                 ET2 = 1;
  67             else
  68             {
  69                 ET2 = 0;
  70                 leds_write(0x0000); // Si pausa apaga leds
  71             }
  72             netdev_read_end();
  73             return len;
  74
  75         case ELP_VAR_DELAY:
  76             // Si es GET, sólo calculamos tamaño de respuesta
  77             if (!elp_command.set)
  78                 return len + sizeof(leds_delay);
  79             // Si es SET procesamos
  80             netdev_read_start(sizeof(leds_delay));
  81             leds_delay = udp_read_byte();
  82             netdev_read_end();
  83             return len;
  84
  85         default:
  86             // Desconocido
  87             return 0;
  88     }
  89 }
  90
  91 void elp_write_response()
  92 {
  93     byte i;
  94     // Escribimos cabecera
  95     netdev_write_start(ELP_HEADER_SIZE);
  96     // Escribimos el bitfield a lo guapo como un byte.
  97     udp_write_byte(*((byte*) &elp_command));
  98     netdev_write_end();
  99     // Si era un SET acá termino nuestro trabajo, nunca tiene datos
 100     if (elp_command.set)
 101         return;
 102     // Si era un GET escribimos lo que nos pidieron
 103     switch (elp_command.var)
 104     {
 105         case ELP_VAR_MATRIX:
 106             // Transferimos tamaño (1 byte) + matriz (2 bytes por columna)
 107             netdev_write_start(sizeof(leds_matrix_len) + leds_matrix_len * 2);
 108             udp_write_byte(leds_matrix_len);
 109             for (i = 0; i < leds_matrix_len; ++i)
 110             {
 111                 udp_write_byte(LOW(leds_matrix[i]));
 112                 udp_write_byte(HIGH(leds_matrix[i]));
 113             }
 114             netdev_write_end();
 115             break;
 116
 117         case ELP_VAR_PAUSE:
 118             netdev_write_start(1 /* booleano de 1 byte */);
 119             udp_write_byte(!ET2);
 120             netdev_write_end();
 121             break;
 122
 123         case ELP_VAR_DELAY:
 124             netdev_write_start(sizeof(leds_delay));
 125             udp_write_byte(leds_delay);
 126             netdev_write_end();
 127             break;
 128     }
 129 }
 130