Es exactamente lo que que puse, lo que cambiaría es que eliminas la parte que hace parpadear el LED y dentro de la condición que se pregunta por stringComplet ahí procesas los comandos.
Aunque yo lo que haría es hacer un separación de los componentes del sistema para que te sea más fácil desarrollar. Por lo general siempre sigo una estrategia similar a la siguiente, aunque cada aplicación es su propio mundo, por lo que a veces no es posible generalizar.
Defino una estructura donde coloco la información de cada comando, incluso lo que debe de ejecutar.
Código PHP:
typedef struct {
char *cmdName;
uint8_t cmdLen;
void (*query)(Message_t *msg);
void (*setCmd)(char *params, Message_t *msg);
void (*execCmd)(Message_t *msg);
} Cmd_t;
Le puedes agregar lo que se te ocurra, incluso un timeout, para indicarle cuanto tiempo debe de esperar para recibir respuesta del sistema principal.
Después se crear un arreglo donde se colocan los comandos de la siguiente forma.
Código PHP:
Cmd_t cmd_table[CMD_N] = {
{NULL,0,NULL,NULL,cmdNull},
{"+PLAY",5,cmdDanceQuery,cmdDanceSet,NULL},
{"+BTONE",6,NULL,cmdBendToneSet,NULL},
{"+SHAKEL",7,NULL,cmdMoveShakeLegs,NULL},
{"+WALK",5,NULL,cmdMoveWalk,NULL},
{"+TURN",5,NULL,cmdMoveTurn,NULL},
{"+UPDOWN",7,NULL,cmdMoveUpdown,NULL},
{"+SWING",6,NULL,cmdMoveSwing,NULL},
{"+TTSWING",8,NULL,cmdMoveTiptoeSwing,NULL},
{"+JITTER",7,NULL,cmdMoveJitter,NULL},
{"+ASCTURN",8,NULL,cmdMoveAscendingTurn,NULL},
{"+MOONWLK",8,NULL,cmdMoveMoonWalker,NULL},
{"+CRUSAITO",9,NULL,cmdMoveCrusaito,NULL},
{"+FLAPPING",9,NULL,cmdMoveFlapping,NULL},
{"+HOME",5,NULL,NULL,cmdMoveHome},
{"+JUMP",5,NULL,cmdMoveJump,NULL},
{"+BEND",5,NULL,cmdMoveBend,NULL},
{"+STOP",5,NULL,cmdStop,NULL},
{"+GDST",5,NULL,NULL,cmdGetDistance},
};
Y se definen las funciones para manejar esos comandos, como por ejemplo los siguientes
Código PHP:
Cmd_Status_t cmdProcess(Cli_t *me, int8_t cmd_idx, char *pRcvData, Message_t *msg);
int8_t cmdLen(char *pCmd);
int8_t cmdSearch(Cli_t *me, uint8_t len, char *pCmd);
int8_t p_parse(char *p, Params_t *params);
Por ejemplo cmdSearch busca en el arreglo el índice del comando, si es que existe, en caso de existir regresa el índice, de lo contrario un -1.
Con esa información cmdProcess se encargar de ejecutar el comando y decidir si el formato es de un query, un set o una ejecución
Así es mucho más sencillo añadir comandos y que lleves un buen control.
En tu ejemplo, tienes un Luz_ON, Luz_OFF, pero si quieres añadir más, o incluso preguntar el estado, le vas a tener que agregar más y más IFs, en cambio si lo planteas de esta forma, con un sólo comando podrías manejar todas las opciones
{"+LUZ",4,getState,setState,NULL},
Entonces puedes definir un formato de comando, por ejemplo
AT+LUZ <- Te regresa el estado de todas las luces que tengas definidas
AT+LUZ?1 <- Te regresa el estado de la Luz 1
AT+LUZ==1,0 <- Pone la Luz 1 en estado bajo
AT+LUZ==2,1 <- Pone la Luz 2 en estado alto
De la misma forma, podrías aplicar el mismo concepto a la lectura de los sensores, y en lugar de actuar directamente sobre el sistema, este le enviaría un comando, por ejemplo:
Código PHP:
typedef struct sensor{
char *name_;
uint32_t period_us;
uint16_t th;
void (*init)();
Status_t (*execute)(struct sensor *me,uint32_t c_time, char *message);
char *cmd;
} sensor_t;
period_us contendrá cada cuando queremos acceder observar el estado del sensor y en el caso de niveles lógicos el valor de th no tendría mucho sentido de colocarlo, pero, para un valor de un ADC o que pueda variar dentro de un rango, este valor tiene sentido, por ejemplo
Código PHP:
sensor_t sensor_table[n_sensors] = {
{"Eyes",200000,10,&init_us_sensor,&us_sensor,"OT+STOP:0\r\n"},
{"Mic",50000,1,&init_mic_sensor,&mic_sensor,"OT+STOP:1\r\n"},
{"Touch Head",200000,1,&init_touch_sensor_head,&touch_sensor_head,"OT+DANCE=3,3\r\n"},
};
Código PHP:
Status_t us_sensor(struct sensor *me, uint32_t c_time,char *message)
{
static uint32_t t_time = 0;
int32_t duration;
if(c_time - t_time >= me->period_us)
{
digitalWrite(TRIG_PIN,LOW);
delayMicroseconds(2);
digitalWrite(TRIG_PIN,HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN,LOW);
duration = pulseIn(ECHO_PIN, HIGH);
otto.distance = duration*0.034/2;
t_time = c_time;
if(otto.distance < me->th)
{
sprintf(message, "%s", me->cmd);
return OK;
}
}
return NOP;
}
Entonces, si la distancia del sensor es menor a valor que tenemos en th, va a guardar en message el comando que definimos en cmd. Después este mensaje se pasa al sistema principal a través de una función que se encarga de manejar los comandos de sistema. Por lo tanto, si observas, en este momento, los comandos pueden venir del puerto serial o de los sensores, y como separaste el sistema de los estímulos que se le pueden aplicar al sistema, es fácil agregar más sensores sin tener que alterar el sistema principal.
Por ejemplo, ahorita sólo tienes un sólo LED y el comando AT+LUZ==1,1 te arrojaría un error, pero si decides agregarle una segunda luz, podrías ejecutar el comando AT+LUZ==1,1 modificando una sola parte del sistema sin importar que venga de un comando que se introduzca por el puerto serie o que provenga como respuesta a un estímulo de una entrada, de lo contrario vas a tener que modificar el código en, por lo menos dos partes:
1.- La sección que interpreta los comandos que entran por el puerto serie.
2.- En el código de cada uno de los sensores cuyo efecto se debe de notar en el estado de la salida en particular.