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