void Statemachine::controlchange_statemachine()
{
debugln("Control");
if (new_state)
{
controlchange_state = controlchange_state_controller;
new_state = false;
}
switch (controlchange_state)
{
case controlchange_state_controller:
debugln("controller");
controlchange_controller = midiByte;
controlchange_state = controlchange_state_value;
break;
case controlchange_state_value:
{
debugln("value");
controlchange_value = midiByte;
if (cc_callback)
{
cc_callback(controlchange_controller, controlchange_value);
}
controlchange_state = controlchange_state_controller;
}
break;
default:
debugln("Unknown control state!");
}
}
void Statemachine::pitchwheel_statemachine()
{
debugln("Pitchwheel");
if (new_state)
{
pitchwheel_state = pitchwheel_state_lo;
new_state = false;
}
switch (pitchwheel_state)
{
case pitchwheel_state_lo:
debugln("low byte");
pitch_bend = midiByte;
pitchwheel_state = pitchwheel_state_hi;
break;
case pitchwheel_state_hi:
{
debugln("high byte");
pitch_bend |= midiByte<<7;
pitchwheel_state = pitchwheel_state_lo;
}
break;
default:
debugln("Unknown note on state!");
}
}
void BroadcastNetwork::dumpRoutes() {
for(byte i = 0; i < ROUTE_MEMORY; i++) {
DistanceVector& v = routes[i];
debugln(String(" Route for ") + v.destination + " via " + v.nextHop + " over " + v.getHops() + " hops with time: " + v.getTime());
}
}
/**
* \brief GSM fecha conexão http
* \param
* \return 0=erro, 1=ok
*/
boolean sATCIPCLOSEMulitple(uint8_t mux_id)
{
#ifdef GSM_CSTT
char *data=reqHTTP;
//eATCIPSTATUS();
PGM_PRINTLN("CLO");
//debugln(mux_id);
esp8266Flush();
#if USE_MUX == 1
SSwifi.print("AT+CIPCLOSE=");
SSwifi.print(mux_id);
SSwifi.print("\r\n");
#else
SSwifi.print("AT+CIPCLOSE\r\n");
#endif
//bitSet(ccStatus,CC_DEBUG);
#if ESP8266_VERSION_14 == 1
recvString(data,"OK","xx","CLOSE", 10000,true);
#else
recvString(data,"OK","ERR","UNL", 10000,true);
#endif
debugln(data);
if (data[0]=='O' || data[0]=='U') {
return true;
}
return false;
#else
return true;
#endif
}
void Statemachine::note_off_statemachine()
{
debugln("Note off");
if (new_state)
{
note_off_state = note_off_state_key;
new_state = false;
}
switch (note_off_state)
{
case note_off_state_key:
debugln("note off key");
note_off_key = midiByte;
note_off_state = note_off_state_velocity;
break;
case note_off_state_velocity:
{
debugln("note off velocity");
note_off_velocity = midiByte;
note_off_state = note_off_state_key;
notesActive--;
// only set volume if the current playing midi should be turned off
if (active_key == note_off_key) // TODO??
{
// non-legato? -> always release.. otherwise in legato -> only release when this is the last note
if (!legatoMode || (notesActive == 0))
{
stopped = true;
}
}
else if (legatoMode && (notesActive == 0))
{
stopped = true;
}
}
break;
default:
debugln("Unknown note on state!");
}
}
int main() {
led_on();
usart_init();
debugln("\nUSART initialized");
spi_init_master();
debugln("SPI master");
for(int i=0; i<5; i++) {
debugx(spi_tx(42)); debugln(" spi_tx");
}
for (;;){}
return 1;
}
void setup() {
initDebug();
setupChangeModePin();
if (isCycleVoltageModeActive()) {
cycleVoltageMode = true;
sk720Mode = SK720Mode_off;
debugln("Cycle mode activated");debug("Switching states every ");debugNum(CYCLE_MODE_DELAY_MS);debugln("ms.");
} else {
debugln("Normal mode activated");
setupLEDPins();
setuptInitialLedStates();
setupWatchdogTimer();
setupPinChangeInterrupts();
}
setupFastPWM();
power_adc_disable();
power_usi_disable();
}
void parse_corrente(void)
{
double Irms;
uint16_t amostras=gParam.rede.nro_amostras_corrente;
uint8_t bit_fase;
uint8_t fases=gParam.rede.fases;
#if TESTAR_SENSORES == 1
testarSensores();
#endif
#if DEBUG > 0
long tempoCorrente=millis();
//SSdebug.write('#');
#endif
uint8_t tensao;
tensao=bitRead(fases,B_TENSAO)?TENSAO_220:TENSAO_127;
//Irms=0;
#if HAS_BLUETOOTH >= 2
SSdebug.print("fases=");
SSdebug.println(fases,BIN);
#endif
memset(correnteFase,0,3);
for (bit_fase=0; bit_fase<MAX_CORRENTE_FASES ; bit_fase++) {
// emon.current(CORRENTE_PIN[bit_fase], gParam.rede.calibragemFase1); // Current: input pin, calibration.
// emon.current(A0, gParam.rede.calibragemFase1); // Current: input pin, calibration.
if (bitRead(fases,bit_fase) && !bitRead(fases,B_PORTA_A0+bit_fase)) {
#if HAS_EMONLIB == 1
//cli();
// Irms = emon.calcIrms(amostras); // Calculate Irms only
Irms = emon[bit_fase].calcIrms(amostras); // Calculate Irms only
//sei();
#else
Irms = readCalcIrms(CORRENTE_PIN[bit_fase], amostras);
#endif
correnteFase[bit_fase] = (uint16_t)(Irms * tensao);
//correnteFase1 = constrain(correnteFase1,0,9999);
#if DEBUG > 0
debugvar(Irms);
debugln(correnteFase[bit_fase]);
#endif
#if HAS_OLED == 1
oled.setField(bit_fase+1,correnteFase[bit_fase]);
#endif
}
}
#if DEBUG >0
tempoCorrente= millis()-tempoCorrente;
debugvarln(tempoCorrente);
#if HAS_EMONLIB == 1
//int vcc=emon1.readVcc();
//debugvar(vcc);
#endif
//debugvar(Irms);
#endif
//debugln(correnteFase[0]);
}
int
main(int argc, char *argv[])
{
int ret;
RATDriver rat;
ret = rat_driver_init();
if (ret < 0) {
debugln("Failed to initialize driver.");
return 1;
}
ret = RATDriver_init(&rat, PRODUCT_ID, VENDOR_ID);
if (ret != 0) {
debugln("Failed to initialize driver instance.");
return 1;
}
#if DEBUG
print_dpi_modes(&rat);
#endif
#if ! DEBUG
daemonize();
#endif
RATDriver_set_profile(&rat, RAT_PROFILE_1, handle_profile1);
RATDriver_set_profile(&rat, RAT_PROFILE_2, handle_profile2);
RATDriver_set_profile(&rat, RAT_PROFILE_3, handle_profile3);
ret = 0;
while (ret >= 0 && !rat.killme)
ret = RATDriver_read_data(&rat);
ret = RATDriver_fini(&rat);
rat_driver_fini();
return ret;
}
void Statemachine::programchange_statemachine()
{
debugln("Program");
if (new_state)
{
new_state = false;
}
program = midiByte;
}
void loop() {
if (cycleVoltageMode == true) {
outputSystemMode(sk720Mode);
#ifdef DEBUG
debug("current state: ");
printSystemMode(sk720Mode);
#endif
sk720Mode = getNextSystemState(sk720Mode);
delay(CYCLE_MODE_DELAY_MS);
} else {
if (wakeup == true) {
wakeup = false;
const unsigned long now = micros();
if (pinChanged == true) {
pinChanged = false;
readLedStates(&systemLedState, now);
}
sk720ModeBuffer[currentSk720Mode] = inferSystemMode(&systemLedState,
now);
#ifdef DEBUG
SK720Mode oldState = sk720Mode;
#endif
sk720Mode = getFilteredSk720Mode(sk720ModeBuffer, sk720Mode,
sk720ModeBuffer[currentSk720Mode]);
#ifdef DEBUG
if (sk720Mode != oldState) {
debug("time ");
debuglnNum(now);
debug("redLed ");
printSingleLedMode(systemLedState.red.mode);
debug("greenLed ");
printSingleLedMode(systemLedState.green.mode);
debug("newState ");
printSystemMode(sk720ModeBuffer[currentSk720Mode]);
debug("filteredState ");
printSystemState(sk720Mode);
debug("filterIndex ");
debuglnNum(currentSk720Mode);
printLedState(&systemLedState.red);
printLedState(&systemLedState.green);
debugln("---");
}
#endif
if (currentSk720Mode == STATE_BUFFER_SIZE - 1) {
currentSk720Mode = 0;
} else {
currentSk720Mode++;
}
outputSystemMode(sk720Mode);
}
enterSleepMode();
}
}
bool Cube_LoadTiles(Cube *cube, const char *tiles, const char *key)
{
if (strlen(tiles) != FACES_PER_CUBE * TILES_PER_FACE) {
#ifndef NDEBUG
if (strlen(tiles) > FACES_PER_CUBE * TILES_PER_FACE) {
debugln("tile string too long");
} else {
debugln("tile string too short");
}
#endif
return false;
}
for (int face = 0; face < FACES_PER_CUBE; face++) {
for (int tile = 0; tile < TILES_PER_FACE; tile++) {
char *loc = strchr(key, tiles[face * TILES_PER_FACE + tile]);
if (loc == NULL) return false;
int color = loc - key;
assert(color >= 0 && color < 6);
cube->face[face].tile[tile] = color;
}
}
return Cube_ValidateTiles(cube);
}
int sHTTPREAD(void) {
int nbytes;
gprs.httpRead();
nbytes = gprs.httpIsRead();
if (gprs.httpState == HTTP_ERROR) {
PGM_PRINTLN("Read error");
nbytes = -1;
}
debugvar(nbytes);
debugln(gprs.buffer);
return nbytes;
}
HapiliMessage* HapiliMessageSerializer::Deserialize(Stream& stream) {
size_t nbytes = stream.available();
if (nbytes < sizeof(HapiliMessage::Header)) {
debug("Unexpected packet size ");
debug(nbytes);
debugln();
return NULL;
}
HapiliMessage::Header header;
nbytes = stream.readBytes((byte*)&header, (size_t)sizeof(HapiliMessage::Header));
if (nbytes < sizeof(HapiliMessage::Header)) {
debug("Unexpected packet size ");
debug(nbytes);
debugln();
return NULL;
}
if (header.version != 1) {
debug("Unexpected HapiliMessage version ");
debug(header.version);
debugln();
}
HapiliMessage *msg;
switch (header.type) {
case HapiliMessage::Set:
debugln("SetMessage");
msg = new SetMessage(header);
break;
case HapiliMessage::Configure:
debugln("ConfigureMessage");
msg = new ConfigureMessage(header);
break;
case HapiliMessage::Query:
default:
debugln("QueryMessage");
msg = new QueryMessage(header);
break;
}
msg->Deserialize(stream, true);
return msg;
}
// read all MIDI bytes..
void Statemachine::run()
{
// low-level.. get bytes
uart.decode_runs();
// read decoded bytes
while(1)
{
short word_ = uart.read_byte();
if (word_ < 0)
{
//debugln(word_);
return;
}
debug("MIDI State = ");
debughexln(state);
debug("word_ = ");
debughexln(word_);
debug("cmd = ");
debughexln(word_ & 0xF8);
if (((uint8_t) word_ & (uint8_t) 0xF8) == 0xF8)
{
debugln("Change state!");
if (word_ >= 0xF8)
{
// for (int i=0; i<maxCcObservers; i++)
// {
// if (ccObservers[i])
// {
// ccObservers[i]->handle_beat(word_);
// }
// }
}
return;
}
else if ((unsigned char) word_ & 0x80)
{
// printf("%02X\r\n", word_);
state = (state_t) (word_ & 0xF0);
rcvd_chan = (unsigned char) word_ & 0x0F;
new_state = true;
return;
}
// and else.. it's just the usual data byte..
midiByte = word_;
if (rcvd_chan != chan)
{
debugln("Not our midi channel!");
return;
}
switch (state)
{
case state_idle:
break;
case state_note_on:
note_on_statemachine();
break;
case state_note_off:
note_off_statemachine();
break;
case state_pitchwheel_change:
pitchwheel_statemachine();
break;
case state_controlchange:
controlchange_statemachine();
break;
case state_programchange:
programchange_statemachine();
break;
case state_channel_pressure:
break;
default:
debug("Unhandled MIDI state 0x");
debughexln(state);
}
}
}
/**
* \brief envia pacote de dados
* \param mux_id > 0 envia o AT+HTTPDATA e os dados
* \param mux_id == 0 somente dados
* \param mux_id == -1 aguarda retorno de dados
* \return 0=erro, 1=OK
*/
boolean sATCIPSENDMultiple(int mux_id, uint8_t tipo_buffer, uint8_t *buffer, boolean flag_flush)
{
int len;
if (mux_id==-1) {
return gprs.sendCommand(0);
}
//debugvar(freeMemory());
if (tipo_buffer == POINTER_CHAR_RAM)
len=strlen((char*)buffer);
else
len=strlen_P((char*)buffer);
if (!len) return true;
/// rx_empty();
//if (bitRead(ccStatus,CC_DEBUG)) debugvar(freeMemory());
#if DEBUG >= 1 || HAS_BLUETOOTH >= 1
debugvar(len);
uint8_t *b=buffer;
for (uint16_t i = 0; i < len; i++) {
if (tipo_buffer==POINTER_CHAR_PROGMEM) {
SSdebug.write(pgm_read_byte(b++));
} else {
SSdebug.write(*b++);
}
} // for
SSdebug.write('\n');
#endif
#ifdef GSM_CSTT
// esp8266Flush();
SSwifi.print("AT+CIPSEND=");
#if USE_MUX == 1
SSwifi.print(mux_id);
SSwifi.print(",");
#endif
SSwifi.print(len);
SSwifi.print("\r\n");
SSwifi.flush();
if (recvFind(">",6000)) {
PGM_PRINT("+");
//esp8266Flush();
#if 0
if (tipo_buffer==POINTER_CHAR_PROGMEM) {
#if 0
char *u;
if (len < SERIAL_TX_BUFFER_SIZE-1 && (u=(char*)malloc(SERIAL_TX_BUFFER_SIZE))) {
strcpy_P(u,(char*)buffer);
SSwifi.print(u);
SSwifi.flush();
free(u);
} else
#endif
for (uint16_t i = 0; i < len; i++) {
// SSdebug.write(pgm_read_byte(buffer));
SSwifi.write(pgm_read_byte(buffer++));
}
}else {
SSwifi.print((char*)buffer);
}
#else
for (uint16_t i = 0; i < len; i++) {
if (tipo_buffer==POINTER_CHAR_PROGMEM) {
// SSdebug.write(pgm_read_byte(buffer));
SSwifi.write(pgm_read_byte(buffer++));
}else {
// SSdebug.write(*buffer);
SSwifi.write(*buffer++);
}
}
#endif
// ret=recvFind("SEND OK", 5000);
PGM_PRINT("* ");
SSwifi.write(0x1a);
recvString(str_ret, "SEND OK", "busy","link is", 10000,flag_flush);
#if DEBUG > 0
//if (bitRead(ccStatus,CC_DEBUG))
debugln(str_ret);
#endif
if (!strncmp(str_ret,"SEND OK",7)) {
// PGM_PRINTLN("SOK");
//delay(100);
//SSwifi.flush();
//eATCIPSTATUS();
return true;
}
if (!strncmp(str_ret,"link",4)) {
sATCIPCLOSEMulitple(mux_id);
}
}
return false;
#else
if (mux_id>0) {
sprintf_P(gprs.buffer,PSTR("AT+HTTPDATA=%d,5000"),mux_id);
gprs.sendCommand(gprs.buffer,5000,"DOWNLOAD");
}
for (uint16_t i = 0; i < len; i++) {
if (tipo_buffer==POINTER_CHAR_PROGMEM) {
SSwifi.write(pgm_read_byte(buffer++));
} else {
SSwifi.write(*buffer++);
}
}
delay(150);
return 1;
#endif
}
void Statemachine::note_on_statemachine()
{
debugln("Note on");
if (new_state)
{
note_on_state = note_on_state_key;
new_state = false;
}
switch (note_on_state)
{
case note_on_state_key:
debugln("note on key");
note_on_key = midiByte;
note_on_state = note_on_state_velocity;
break;
case note_on_state_velocity:
{
debugln("note on velocity");
uint8_t velocity = midiByte;
note_on_state = note_on_state_key;
if (velocity == 0)
{
notesActive--;
}
else
{
notesActive++;
}
if (velocity == 0 && active_key == note_on_key)
{
// active note is deactivated.
debugln("note stopped");
// non-legato? -> always release.. otherwise in legato -> only release when this is the last note
if (!legatoMode || (notesActive == 0))
{
stopped = true;
}
}
else if (velocity)
{
// old note is deactivated or new note is activated, we should only handle the latter case!
debugln("note triggered");
// non-legato? -> always trigger.. otherwise in legato -> only trigger when this is the first note
if (!legatoMode || (notesActive == 1))
{
triggered = true;
}
active_velocity = velocity;
// remember currently playing key
active_key = note_on_key;
}
// else nothing changes
}
break;
default:
debugln("Unknown note on state!");
}
}
/**
* \brief Inicializa modulo GSM, detecta operadora e conecta no GPRS
* \param max numero maximo de tentativas
*/
void setup_gsm(uint8_t max)
{
byte ret;
char apn[50];
//gprs.buffer=reqHTTP;
PGM_PRINTLN("Resetting...");
ret=gprs.init();
if (!ret) {
led2_status=LED_PISCA_FLASH;
return;
}
ret=gprs.sim_detect();
PGM_PRINT("SIM="); debugln(ret);
if (0 && !ret) {
led2_status=LED_PISCA_FLASH;
return;
}
ret = gprs.setup(max);
if (ret) {
led2_status=LED_PISCA_FLASH;
return;
}
gprs.getCIMI((char*)NULL);
strcpy(apn,APN_string(gprs.buffer));
/*
if (gprs.getOperatorName()) {
PGM_PRINT("Operator:");
strupr(gprs.buffer);
debugln(gprs.buffer);
}
*/
gParam.web.ip[1][0]='\0';
ret=apn[0];
if (!ret) {
led2_status=LED_PISCA_FLASH;
return;
}
ret = gprs.join(apn,NULL,NULL, gParam.web.ip[1]);
if (ret) {
PGM_PRINT("Error code:");
debugln(ret);
debugln(gprs.buffer);
return;
}
// TESTE DE PEGOU IP DA REDE
if (gParam.web.ip[1][0] && gParam.web.ip[1][0]!='0') {
bitSet(ccStatus,CC_CWJAP);
ccStatus |= CC_WIFI_BITS_CWJAP_OK;
} else {
bitClear(ccStatus,CC_CWJAP);
}
#if DEBUG > 0
ret = gprs.getSignalQuality();
if (ret) {
PGM_PRINT("Signal:");
debug(ret);
PGM_PRINTLN("dB");
}
#endif
#if USE_LOCATION == 1
ret=gprs.getLocation(&loc);
#endif
PGM_PRINTLN("Gsm: connecting...");
#ifndef GSM_CSTT
ret=0;
for (;;ret++) {
if (gprs.httpInit()) break;
debugvarln(gprs.buffer);
gprs.httpUninit();
if (!(ret%5)) gprs.gsm_reset();
delay(1000);
}
delay(3000);
#endif
debugvarln(gParam.web.ip[1]);
#if HAS_WEBSERVER_FULL == 1 || HAS_WEBSERVER_TINY == 1
server.begin();
#endif
}
//////////////////////////////////
// PARSE
//////////////////////////////////
uint8_t parse_nrf24(void)
{
uint8_t ret=0;
uint8_t st;
unsigned long time;
char Taddr[6]="EILCT";
char Raddr[6]="EILCT";
struct TPackage recPack;
boolean flag_send_data=false;
uint8_t node_livre=0xff;
uint8_t node;
uint16_t addr_base=MAX_TSENSOR_CLIENT*(gParam.radio.serv_addr-SERV_ADDR_BASE);
if(!Mirf.isSending() && Mirf.dataReady()){
// if(Mirf.dataReady()){
#if HAS_DISPLAY == 1
lcd.setCursor(6,0);
lcd.write('1');
#endif
#if DEBUG > 0
uint8_t PIPE;
Mirf.readRegister( STATUS, &PIPE, sizeof(PIPE) );
PGM_PRINT("1.ST="); debugbinln(PIPE);
#endif
Mirf.getData((uint8_t*)&recPack);
// if (Mirf.dataReady()) {
// uint8_t rx_data;
// Mirf.readRegister(RX_PW_P1,&rx_data,1);
// debugvarln(rx_data);
// }
#if DEBUG > 10
Mirf.readRegister( STATUS, &PIPE, sizeof(PIPE) );
PGM_PRINT("2.ST="); debugbinln(PIPE);
#endif
//debugvarln(recPack.addr);
debugvar(recPack.seq);
debugvar(recPack.serie);
//debugvarln(recPack.cmd);
gPack=recPack;
// if (Raddr[4]=='E') {
if (recPack.addr=='X') {
uint16_t recurso=recPack.data[0] <<8 | recPack.data[1];
uint16_t serie=recPack.serie;
uint16_t check;
uint16_t check_in=recPack.data[2] <<8 | recPack.data[3];
check=recurso ^ serie;
// procura cliente/addr livre para alocar
gPack.cmd=PKG_CMD_ERR_FULL_CLIENT;
if (check != check_in) {
gPack.cmd=PKG_CMD_ERR_UNKNOW_CLIENT;
debugvar(recurso);
debugvar(serie);
debugvarln(check);
} else {
for (node=0;node<MAX_TSENSOR_CLIENT;node++) {
if (!bitRead(gParam.radio.client,node)) {
if (node_livre==0xff) node_livre=node;
} else
if (gParam.radio.serieClient[node]==serie) {
node_livre=0xff;
break;
}
}
debugvar(node); debugvarln(node_livre);
if (node == MAX_TSENSOR_CLIENT && node_livre < MAX_TSENSOR_CLIENT) {
node=node_livre;
}
if (node < MAX_TSENSOR_CLIENT) {
gParam.radio.serieClient[node]=serie;
gParam.radio.seqClient[node]=0;
gParam.radio.recursoClient[node]=recurso;
gParam.radio.timeClient[node]=millis()/1000;
//debugvarln(gParam.radio.recursoClient[node]);
gPack.cmd=PKG_CMD_SET_NODE;
gPack.addr=Raddr[0]=node+'0'+addr_base;
gPack.data[0]=Raddr[0];
// gPack.data[0]=TSENSOR_SERIE << 8;
// gPack.data[1]=TSENSOR_SERIE & 0xff;
if (node_livre!=0xff) {
bitSet(gParam.status,P_STATUS_GRAVA_EEPROM);
ret++;
#if DEBUG>0
SSdebug.write('+');
#endif
}
bitSet(gParam.radio.client,node);
PGM_PRINT("new=");debugln(Raddr[0]);
// ativa NFR24L01 para receber o msg
flag_send_data=true;
#if HAS_DISPLAY == 1
lcd.setCursor(6,0);
lcd.write(Raddr[0]);
#endif
}
} // check != check_in
} else { //x
uint8_t client=(recPack.addr-'0') % addr_base; // TCLIn
debugvarln(client);
Taddr[0]=recPack.addr;
#if HAS_DISPLAY == 1
lcd.setCursor(8+client,0);
lcd.write(Taddr[0]);
#endif
gPack.cmd=PKG_CMD_ERR_COMMAND_CLIENT;
// retorno de execução de comanto
if (recPack.cmd==PKG_CMD_SEND_DATA_CMD_STATUS) {
PGM_PRINT("% ");
uint8_t status=recPack.data[0];
debugvarln(status);
if (!status)
bitSet(gParam.radio.hasCmdOK,client);
else
bitSet(gParam.radio.hasCmdERR,client);
gPack.cmd=PKG_CMD_RECEIVE_DATA;
timerWeb=0; // forca envio para o site
}
// recebendo dados
if (recPack.cmd==PKG_CMD_SEND_DATA) { //3
// testa se cliente existe
if (!bitRead(gParam.radio.client,client) || gParam.radio.serieClient[client]!=recPack.serie) { //2
gPack.cmd=PKG_CMD_ERR_UNKNOW_CLIENT;
gPack.data[0]=gParam.radio.serv_addr;
PGM_PRINTLN("inv client");
flag_send_data=true;
} else {
int t,t2=-1000;
int _min=gParam.lim.min[client];
int _max=gParam.lim.max[client];
gParam.radio.timeClient[client]=now();
gParam.radio.vccClient[client]=recPack.data[0] <<8 | recPack.data[1];
// Temperatura
t=gParam.radio.dataClient[client][0]=(int)(recPack.data[2] <<8 | recPack.data[3]);
PGM_PRINT("tmp ="); debugln(t);
// sensores extras
if (gParam.radio.recursoClient[client] & REC_SENSORES) {
gParam.radio.sensor9_10[client]=recPack.data[4];
}
if (gParam.radio.recursoClient[client] & & (REC_DS18B20_EXTRA | bit(REC_HUMIDADE))) {
t2=gParam.radio.dataClient[client][1]=(int)(recPack.data[5] <<8 | recPack.data[6]);
PGM_PRINT("tmp2="); debugln(t2);
}
#if HAS_DISPLAY == 1
// col,lin
lcd.setCursor(client*4,1);
lcd.print(t/10);
lcd.print(" ");
#endif
bitSet(gParam.radio.hasData,client);
// testa limites
if (!_min || !_max) {
if (t<_min || t>_max) {
if (!bitRead(gParam.radio.lim_flag,client)) {
bitSet(gParam.radio.lim_flag,client);
timerWeb=0; // força envio
}
} else
if (bitRead(gParam.radio.lim_flag,client)) {
bitClear(gParam.radio.lim_flag,client);
timerWeb=0; // força envio
}
}
if (recPack.seq == gParam.radio.seqClient[client])
gPack.cmd=PKG_CMD_ERR_SEQ_DUPLO;
else
if (recPack.seq == gParam.radio.seqClient[client]+1) { // 1
// pacote válido, testa se tem comando para enviar
if (bitRead(gParam.radio.hasCmd,client)) {
debugvarln(rf24_cmd);
gPack.cmd=PKG_CMD_RECEIVE_DATA_WITH_CMD;
gPack.data[0]=rf24_cmd;
gPack.data[1]=rf24_par1>>8;
gPack.data[2]=rf24_par1;
gPack.data[3]=rf24_par2>>8;
gPack.data[4]=rf24_par2;
gPack.data[5]=rf24_par3>>8;
gPack.data[6]=rf24_par3;
bitClear(gParam.radio.hasCmd,client);
flag_send_data=true;
}
else
gPack.cmd=PKG_CMD_RECEIVE_DATA;
} else {
gPack.cmd=PKG_CMD_ERR_SEQ;
} // 1
gParam.radio.seqClient[client]=recPack.seq;
} //2
