File content as of revision 27:f33cf47d671a:

#include "mbed.h"   //API mBed com diversos drivers para os periféricos LPC1768
#include "stdio.h"
#include "cmsis_os.h"   //Nucleo do Real Time Operational System
#include "main.h"   //Inicializações de maquina e demais ajustes de hardware
#include "funcoesSDCard.h"  //Funções para manipulação do SDCard que incluem rotinas de inicialização, setar pastas e arquivos e demais usos
#include "RTC.h"    //API de uso das interrupções do Real Time Clock
#include "serialPC.h"   //Funções de comunicação entre RAD e PC via usb
#include "modbusMaster1.h"
//#include "lpc17xx_nvic.h"


//Definições de Hardware acessíveis em qualquer modulo
/*LEDs de informação visual*/
DigitalOut ledLigado(P1_0);
DigitalOut ledEmComunicacao(P1_1);
DigitalOut ledConectadoInternet(P1_4);
DigitalOut ledUsoGeral(P1_8);
/*LEDs de informação visual*/

/*Pinos de controle do modulo WiFi*/
DigitalOut ESP_CH_PD(P0_6);
DigitalOut ESP_RESET(P0_0);
DigitalOut ESP_ESPGPIO_2(P0_1);
/*Pinos de controle do modulo WiFi*/

/*Interrupções externas para contagem de pulsos rapidos*/
InterruptIn eInt1(P2_11);
InterruptIn eInt2(P2_12);
InterruptIn eInt3(P2_13);
/*Interrupções externas para contagem de pulsos rapidos*/

/*Leituras analógicas*/
/*AnalogIn   ain1(p17);
AnalogIn   ain2(p18);
AnalogIn   ain3(p19);
AnalogIn   ain4(p20);*/
/*Leituras analógicas*/

//Função para reset do ARM
extern "C" void mbed_reset();

//Devices
    device ** dispositivos = NULL;
    uint8_t devices=0;
    uint8_t alarmes=0;
    uint8_t leituras=0;
    uint8_t qtdSchedules=0;
    uint8_t qtdScheduleExceptions=0;
//Devices

//Variáveis para envio de arquivo em qualquer lugar do código
extern arquivoSD *arquivoEnvioPointer = NULL;

uint32_t act;
bool boolExecAct;
bool inicializaModemBool;
char debug = false;
bool hardwareReset = false;


MediaMovel FiltroAI4(5);
MediaMovel FiltroAI3(5);
MediaMovel FiltroAI2(5);
MediaMovel FiltroAI1(5);

uint16_t aiFiltrada[4];
bool entradasDigitais[9];

CircularBuffer bufModem(maxBufInModem) __attribute__ ((section("AHBSRAM0")));    
CircularBuffer bufPC(128);
CircularBuffer sdCardBuf(1024);

uint8_t enviaDadosPorAlarme = 255;
//bool reportaMudancaAoServer;
bool executaComandoServer;

//typeConfig flashConfig;  

//Instancia das portas Seriais do ARM
Serial pc(USBTX, USBRX); //Instancia de recurso Serial uart pc
Serial modem(P0_10,P0_11); //Instancia de recurso Serial uart Modem 
DigitalOut max_de(P2_7); //Pino de habilitação max485 para porta Energy Metering ModBus
Serial modBusMaster1Serial(P2_0,P2_1);  //Recurso serial para porta Energy Metering ModBus

/*
//Interrupções externas e botões
InterruptIn int_wh(P2_11);
InterruptIn int_varh(P2_12);

void whCount(void){
    whled=1;
    wait(0.2);
    whled=0;
}

void varhCount(void){
    varhled=1;
    wait(0.2);
    varhled=0;
}*/
//Definições de Hardware acessíveis em qualquer modulo

/*
void loadStandardConfig(){ 
 strcpy(flashConfig.apnList[0],"claro.com.br");
 strcpy(flashConfig.apnList[1],"zap.vivo.com.br");
 strcpy(flashConfig.apnList[2],"tim.br");
 strcpy(flashConfig.apnList[3],"generica.oi.com.br"); 

 strcpy(flashConfig.login[0],"claro");
 strcpy(flashConfig.login[1],"vivo");
 strcpy(flashConfig.login[2],"tim");
 strcpy(flashConfig.login[3],"oi"); 

 strcpy(flashConfig.senha[0],"claro");
 strcpy(flashConfig.senha[1],"vivo");
 strcpy(flashConfig.senha[2],"tim");
 strcpy(flashConfig.senha[3],"oi"); 

 strcpy(flashConfig.serverAddress,serverAddress); 
 
 strcpy(flashConfig.serverPort,"80"); 
 
 flashConfig.periodoDeEnvioDeDadosMinutos=15;  //Padrão 15 minutos
 flashConfig.ultimoEstadoLigadoDesligado=0;    //Padrão de fábrica desligado
}
*/

void leiturasDigitais(){    
    entradasDigitais[0] = ED1;
    entradasDigitais[1] = ED2;
    entradasDigitais[2] = ED3;
    entradasDigitais[3] = ED4;
    entradasDigitais[4] = ED5;
    entradasDigitais[5] = ED6;
    entradasDigitais[6] = ED7;
    entradasDigitais[7] = ED8;
    entradasDigitais[8] = ED9;    
}

HighSpeedAnalogIn ain(p17, p18, p19, p20);

void leiturasAnalogicas(){
    static uint8_t leituraAtual;
    switch(leituraAtual){
        case 0:                
                aiFiltrada[0] = FiltroAI1.get(ain.read_u16(p17));
            break;
        case 1:
                aiFiltrada[1] = FiltroAI2.get(ain.read_u16(p18));
            break;
        case 2:
                aiFiltrada[2] = FiltroAI3.get(ain.read_u16(p19));
            break;
        case 3:
                aiFiltrada[3] = FiltroAI4.get(ain.read_u16(p20));
            break;        
    }
    if(leituraAtual<3){leituraAtual++;}
    else{leituraAtual=0;}
} 

void verificaSaidasDigitais(){
    SD_OE_R = 1;
    /*if(SD_FAULT){
        pc.printf("Fault\r\n");
    }else{
        pc.printf("No Fault\r\n");
     }*/
}

//Thread timers é utilizada para dar start nos timers de dentro das ISRs de comunicação serial porque não é permitido inicializar osTimers de dentro de ISRs.
osThreadId idThreadTimers;
void threadTimers(void const *args){
    while(true){
        osSignalWait(0x1,1000); //Executo compulsoriamente mesmo que não haja sinal num periodo de 1 segundo
        if(serialPC::startTimer_pacote){
          serialPC::startTimer_pacote = false;
          osTimerStart(serialPC::timer_pacote,2000);            
        }
        if(serialModem::startTimer_pacote){
          serialModem::startTimer_pacote = false;
          osTimerStart(serialModem::timer_pacote,modemCom::timeOutModem);            
        }        
        if(modBusMaster1::startThreadModBusMaster){
          modBusMaster1::startThreadModBusMaster = false;
          osTimerStart(modBusMaster1::timer_pacote,4);            
        }                
    }        
}
osThreadDef(threadTimers, osPriorityNormal, 128);
//osThreadDef(threadTimers, osPriorityNormal, DEFAULT_STACK_SIZE/10);

osThreadId idThreadProcessaPacote;
void threadProcessaPacote(void const *args){
    while(true){
        osSignalWait(0x1,1000); //Executo compulsoriamente mesmo que não haja sinal num periodo de 1 segundo
        if(serialModem::processarPacote){
            serialModem::processarPacote = false;
            modemCom::processaPacote(NULL);
        }        
    }    
}
osThreadDef(threadProcessaPacote, osPriorityNormal, DEFAULT_STACK_SIZE);



//Thread que gerencia as comunicacoes (DROME - SERVER)
osThreadId idThreadComunicacoes;
void threadComunicacoes(void const *args){
    //Esta thread faz todo o tratamento de comunicação.    
    
    //char aux[30];                   
    while(true){                
        osSignalWait(0x1,500); //Executo compulsoriamente mesmo que não haja sinal num periodo de meio segundo        
        if(!eventosRTC::rotina10Segundos){        //Para não concorrer com verifySchedule
            if(inicializaModemBool){
                inicializaModemBool = false;
                modemCom::conectaWiFi();    
            }
            
            if(hardwareReset){
                //Resetando
                diversos::wdt.kick(0.1);
                while(true);
            }  
            
            if(eventosRTC::rotinaEnvioDeDados){
                //Faço aqui o que for devido.
                pc.printf("Enviando dados de hora completa ao server.\n");            
                modemCom::status.emComunicacao = true;            
                //diversos::wdt.kick(300.0);
                //Aproveitando ACT            
                if(!modemCom::status.recebendoArquivoDoServer){
                    eventosRTC::rotinaEnvioDeDados--;
                    modemCom::status.periodo = 900;
                    if(modemCom::verificaConexao()){
                        //Estou conectado
                        if(modemCom::enviaDados()){
                            eventosRTC::rotinaEnvioDeDados=0;
                            modemCom::status.periodo = modemCom::status.periodoConfiguracao; //Restaurando o período configurado no sistema
                        }
                    }
                    //diversos::wdt.kick(90.0);
                }else{
                    modemCom::status.recebendoArquivoDoServer--;
                 }
                modemCom::status.emComunicacao = false;            
            }        
            
            if(arquivoEnvioPointer!=NULL){            
                pc.printf("Enviando o arquivo <%s> ao server.\n",arquivoEnvioPointer->nome);
                if(modemCom::postFileCommandMode(modemCom::status.serverIP,modemCom::status.host,"/drome/parser/index.php",arquivoEnvioPointer)){
                //if(modemCom::postFileCommandMode(modemCom::status.serverIP,modemCom::status.host,"/sistema/Parser/index.php",arquivoEnvioPointer)){
                    pc.printf("Enviado o arquivo <%s>.\n",arquivoEnvioPointer->nome);
                    arquivoEnvioPointer = NULL;        
                }else{
                    pc.printf("Erro enviando o arquivo <%s>.\n",arquivoEnvioPointer->nome);
                 }            
            }
            
            if(modemCom::status.SRINGsockEntrante){
                modemCom::status.SRINGsockEntrante=false;
                modemCom::atendeSRING(modemCom::status.connIDServerCommand);     
            }
                    
            modemCom::timeOutModem = 30;    
        }
    }    
}
osThreadDef(threadComunicacoes, osPriorityNormal, 3072); 
//osThreadDef(threadComunicacoes, osPriorityNormal, (DEFAULT_STACK_SIZE*2)); 

void RTC_POR_SEGUNDO(void){
    time_t seconds;
    seconds = time(NULL);        
    osSignalSet(idThreadComunicacoes, 0x1);
    eventosRTC::rotina1segundo=true;
    
    if(((seconds+5)%10)==0){     
     eventosRTC::rotina10Segundos = true;                
    }
    
    if((seconds%60)==0){     
     eventosRTC::minutos = true;   
    }

    if(((seconds-5)%modemCom::status.periodo)==0){
    //if((seconds%300)==0){
        eventosRTC::rotinaEnvioDeDados = maxTentativasEnvioDados;
    }
    
    if((seconds%3600)==0){ //Atuando a cada 3 minutos
        //Entro aqui a cada hora
        eventosRTC::rotina1hora = true;        
    }
}

//Timeout timeOutModem;
void chamaProcessaPacotePeloTimeOut(){
  modemCom::processaPacote(NULL);  
}

void loadDevices(){    
    if(sdCard::abreArquivo(&sdCard::devices,"r")){
        criaDevices(sdCard::devices.fp);
        if(devices){
            configuraDevices(sdCard::devices.fp);
            printf("Dispositivos configurados.\n");            
        }
        sdCard::fechaArquivo(&sdCard::devices); 
        if(devices){testaTudoDevices();}
    }    
}

void inicializaMaquina(){
    pwmPeriod = 100000;
    SD1.period_us(pwmPeriod);
    modemCom::atendendoWebServer = false;
    serialPC::serialPC_init();
    pc.printf("Versao 29/04/2018.\r\n");
    modemCom::timeOutModem = 30;
    serialModem::serial_init();
    numeroDeBytesPorEnvio = 768;
    modBusMaster1::modBusMaster(&modBusMaster1Serial,19200,&max_de);
    inicializaSensoresTemperatura();
    
    if(sdCard::init()){
     pc.printf("SD Card inicializado com sucesso.\n");
     //Carregando a lista de dispositivos
     loadDevices();
    }else{
        pc.printf("Nao foi possivel inicializar o SD Card.\n");   
     }   

          
    //Tick Timer por segundo
    RTC::attach(&RTC_POR_SEGUNDO, RTC::Second);                  
    
    /*Chamada de threads*/
    
    //Thread timers
    idThreadTimers = osThreadCreate(osThread(threadTimers), NULL);    
    //Thread comunicacoes
    idThreadComunicacoes = osThreadCreate(osThread(threadComunicacoes), NULL);
    //Thread processaPacote
    idThreadProcessaPacote = osThreadCreate(osThread(threadProcessaPacote), NULL);
    
    /*Chamada de threads*/        
    serialModem::configBaud();    
}

//Inicio do programa;
int main() {
    debug = false;
    eInt1.rise(&diversos::processaPulsosEDs);
    eInt2.rise(&diversos::processaPulsosEDs);
    eInt3.rise(&diversos::processaPulsosEDs);
    
    diversos::wdt.kick(90.0);
    
    modem.baud(76800);
    ESP_CH_PD = 1;          
    ESP_ESPGPIO_2 = 1;
    ESP_RESET = 1;    
    
    wait(2);    
    inicializaMaquina();       
    modemCom::inicializaModem();
    if(!modemCom::verificaConexao()){
        modemCom::conectaWiFi();
    }
    eventosRTC::rotinaEnvioDeDados=maxTentativasEnvioDados;
    sdCard::deleteSentFiles=false;
        
    while(true){            
        //osDelay(100);        
        if(callBootLoader){
            diversos::wdt.kick(360.0);
            SysTick->CTRL &= ~0x00000002;           // disable SysTick interrupt
            NVIC_DeInit();     
            //__disable_irq();
            bootloader_fillUpFlash(&sdCard::newFirmware);
            while( ((LPC_UART0->LSR >> 6) &0x1) == 0 );            
            //__enable_irq();
            bootLoader();    
        }
        
        //pc.printf("Thread: MAIN.\r\n");
        if((!modemCom::status.recebendoArquivoDoServer)&&(!modemCom::status.emComunicacao)){            
            diversos::wdt.kick();            
            if(eventosRTC::minutos){
                //Executo abaixo a rotina de 1 minuto
                writeReadingsToSD();
                //if(!modemCom::status.emComunicacao){modemCom::verificaConexao();}
                eventosRTC::minutos = false;
            }
            
            if(eventosRTC::rotina1segundo){
                eventosRTC::rotina1segundo = false;    
                
                refreshSensoresTemperatura();            
                
                if(enviaDadosPorAlarme!=255){
                    enviaDadosPorAlarme--;
                    if(enviaDadosPorAlarme==0){
                        eventosRTC::rotinaEnvioDeDados=maxTentativasEnvioDados;
                        enviaDadosPorAlarme=255;
                    }
                }                                
                leiturasAnalogicas();                
                verificaSaidasDigitais();
                leiturasDigitais();                
                if(debug){
                    pc.printf("\nMemoria RAM disponivel = %lu\n",diversos::memAvailable());
                    pc.printf("\nEntrada 4 = %lu.\nEntrada 3 = %lu.\nEntrada 2 = %lu.\nEntrada 1 = %lu.\r\n",aiFiltrada[3],aiFiltrada[2],aiFiltrada[1],aiFiltrada[0]);            
                    pc.printf("Pulsos <%lu><%lu><%lu>.\r\n",pulsosEDs[0],pulsosEDs[1],pulsosEDs[2]);
                    for(debug=0;debug<9;debug++){
                        pc.printf("EntradaDigital[%u]=%u.\r\n",debug,(entradasDigitais[debug]>1));    
                    }
                    
                }
                time_t seconds = time(NULL);
                printf("%s\n", ctime(&seconds));            
                
            }                
            
            if(eventosRTC::rotina10Segundos){                                    
                //Executo abaixo a rotina de 10 segundos
                eventosRTC::rotina10Segundos = false;
                verifySchedules();
                verifyAlarms();                
            }
            
            if(sdCard::deleteSentFiles){                
                pc.printf("Recebido comando para deletar arquivos enviados.\n");
                sdCard::deleteBanks(sdCard::currentBankSending);
                if(sdCard::modificaCurrentBank(sdCard::currentBank,!sdCard::currentBankSending)){
                    sdCard::deleteSentFiles=false;
                }
            }
        }
        
        if(executaComandoServer){
            executaComandoServer = false;
            commands::exec(modemCom::status.connIDServerCommand);            
            if(!modemCom::status.recebendoArquivoDoServer){
                pc.printf("Fechando socket chave 4.\r\n");
                modemCom::closeConnection(modemCom::status.connIDServerCommand);
            }
        }        
    
        if(modemCom::atendendoWebServer){                
                modemCom::atendendoWebServer = false;
                pc.printf("Atendendo webServer na conexao %u.\r\n",modemCom::status.connIDWebServer);
                modemCom::status.emComunicacao=true;
                modemCom::webServer(modemCom::status.connIDWebServer);                
                modemCom::status.emComunicacao=false;
        }
        
        if(boolExecAct){
            dispositivos[0]->execAct(act);
            boolExecAct = false;    
        }        
    }
}