File content as of revision 18:1eefda1f7736:

#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*/

//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;

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 analogInObject(P1_31,P1_30,P0_26,P0_25);

void leiturasAnalogicas(){
    float ai1_filtrado=0.0;
    float ai2_filtrado=0.0;
    float ai3_filtrado=0.0;
    float ai4_filtrado=0.0;
    
    uint8_t i;
    
    //LPC_SC->PCONP |= (1 << 12); //Set the PDADC bit residing in the 12th bit of the PCONP register
    
    for(i=0;i<5;i++){
        ai1_filtrado += analogInObject.read_u16(P0_25);
        ai2_filtrado += analogInObject.read_u16(P0_26);
        ai3_filtrado += analogInObject.read_u16(P1_30);
        ai4_filtrado += analogInObject.read_u16(P1_31);        
    }
    
    ai1_filtrado = ai1_filtrado/5;
    ai2_filtrado = ai2_filtrado/5;
    ai3_filtrado = ai3_filtrado/5;
    ai4_filtrado = ai4_filtrado/5;
     
    
    aiFiltrada[3] = ai4_filtrado;
    aiFiltrada[2] = ai3_filtrado;
    aiFiltrada[1] = ai2_filtrado;
    aiFiltrada[0] = ai1_filtrado;
    
    
    /*aiFiltrada[3] = FiltroAI4.get((uint16_t)floor(ai4_double));
    aiFiltrada[2] = FiltroAI3.get((uint16_t)floor(ai3_double));
    aiFiltrada[1] = FiltroAI2.get((uint16_t)floor(ai2_double));
    aiFiltrada[0] = FiltroAI1.get((uint16_t)floor(ai1_double));*/
    
} 



//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);
        }
        //diversos::processaPulsosEDs();        
    }    
}
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,osWaitForever); //Executo compulsoriamente mesmo que não haja sinal num periodo de meio segundo        
        //pc.printf("Thread: COM.\r\n");
        //if((modemCom::status.SRING)&&(!modemCom::status.serverConnected)){        
        
        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)){
                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);        
    
    eventosRTC::rotina1segundo=true;
    
    if(((seconds+5)%10)==0){     
     eventosRTC::rotina10Segundos = true;
     osSignalSet(idThreadComunicacoes, 0x1);           
    }
    
    if((seconds%60)==0){     
     eventosRTC::minutos = true;   
    }

    if((seconds%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 18/01/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();    
}

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




//Inicio do programa;
int main() {
    
    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();
    modemCom::conectaWiFi();
    eventosRTC::rotinaEnvioDeDados=maxTentativasEnvioDados;
    sdCard::deleteSentFiles=false;
    
    
    
    while(true){            
        osDelay(10);
        
        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();            
                leiturasDigitais();            
                verifyAlarms();
                verificaSaidasDigitais();                  
                pc.printf("\nMemoria RAM disponivel = %lu\n",diversos::memAvailable());
                time_t seconds = time(NULL);
                printf("%s\n", ctime(&seconds));            
                //pc.printf("\nEntrada 3 = %lu.\nEntrada 2 = %lu.\nEntrada 1 = %lu.\n\n",aiFiltrada[2],aiFiltrada[1],aiFiltrada[0]);            
                //pc.printf("Pulsos <%lu><%lu><%lu>.\r\n",pulsosEDs[0],pulsosEDs[1],pulsosEDs[2]);
            }                
            
            if(eventosRTC::rotina10Segundos){                                    
                //Executo abaixo a rotina de 10 segundos                                      
                eventosRTC::rotina10Segundos = false;
                verifySchedules();                
            }
            
            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);
            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;    
        }        
    }
}