File content as of revision 0:1c0a769988ee:

#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"

DigitalOut ESP_CH_PD(P0_6);
DigitalOut ESP_RESET(P0_0);
DigitalOut ESP_ESPGPIO_2(P0_1);

uint32_t pwmPeriod;

extern "C" void mbed_reset();

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

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

//Definições de Hardware acessíveis em qualquer modulo
DigitalOut led1(P1_0);
DigitalOut led2(P1_1);
DigitalOut led3(P1_4);
DigitalOut led4(P1_8);
bool hardwareReset = false;

/*
AnalogIn ai4(p20);
AnalogIn ai3(p19);
AnalogIn ai2(p18);
AnalogIn ai1(p17);


AnalogIn ai4(P1_31);
AnalogIn ai3(P1_30);
AnalogIn ai2(P0_26);
AnalogIn ai1(P0_25);
*/

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

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

CircularBuffer bufModem(maxBufInModem);    
CircularBuffer bufPC(128);
CircularBuffer sdCardBuf(2048);

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

Serial pc(USBTX, USBRX); //Instancia de recurso Serial uart pc

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,"www.vitaesolucoes.com.br"); 
 
 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;    
}


/*
AnalogIn ai4(p20);
AnalogIn ai3(p19);
AnalogIn ai2(p18);
AnalogIn ai1(p17);


AnalogIn ai4(P1_31);
AnalogIn ai3(P1_30);
AnalogIn ai2(P0_26);
AnalogIn ai1(P0_25);
*/
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,250);            
        }
        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, DEFAULT_STACK_SIZE/10);

osThreadId idThreadProcessaPacote;
void threadProcessaPacote(void const *args){
    while(true){
        osSignalWait(0x1,osWaitForever); //Executo apenas ao receber o sinal        
        modemCom::processaPacote(NULL);        
    }        
}
osThreadDef(threadProcessaPacote, osPriorityNormal, DEFAULT_STACK_SIZE);


//Thread que gerencia as comunicacoes (RAD - SERVER)
osThreadId idThreadComunicacoes;
void threadComunicacoes(void const *args){
    //Esta thread faz todo o tratamento de comunicação.    
    
    char aux[30];                   
    while(true){
        osSignalWait(0x1,1000); //Executo compulsoriamente mesmo que não haja sinal num periodo de 1 segundo            
        
        if(hardwareReset){
            //Resetando
            diversos::wdt.kick(0.1);
            while(true);
        }      
        
        
        //if((modemCom::status.SRING)&&(!modemCom::status.serverConnected)){
        if(modemCom::status.SRINGsockEntrante){
            modemCom::status.SRINGsockEntrante=false;
            modemCom::atendeSRING(connID);     
        }
        
        if(eventosRTC::rotina10Segundos){        
            //Verifica se IP mudou e se estou conectado!;
            
            //Verifica se esta conectado;            
            /*
            if(!modemCom::sendToModem("at#sgact?\r",1,&modemCom::status.associated,500,2)){
                //Não conectado reportar ao server uma vez que uma nova conexão irá mudar o IP
                reportaMudancaAoServer = true;
            }                        
            */
            eventosRTC::rotina10Segundos = false;
        }
        
        if(eventosRTC::rotina1hora){            
            //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);
            modemCom::enviaDados(dadosArmazenados);
            diversos::wdt.kick(90.0);
            modemCom::status.emComunicacao = false;
            eventosRTC::rotina1hora = false;
        }        
        
        if(sdCard::deleteSentFiles){
            sdCard::deleteSentFiles = false;
            sdCard::finalizaEnvio();    
        }
        
        if(arquivoEnvioPointer!=NULL){            
            pc.printf("Enviando o arquivo <%s> ao server.\n",arquivoEnvioPointer->nome);
            if(modemCom::postFileCommandMode("www.vitaesolucoes.com.br","/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);
             }            
        }
        led4=!led4;
        modemCom::timeOutModem = 30;
        
        //Reseto o watchdogTimer;
        diversos::wdt.kick();
    }    
}
osThreadDef(threadComunicacoes, osPriorityNormal, (DEFAULT_STACK_SIZE * 2)); 

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

    //if((seconds%900)==0){
    if((seconds%900)==0){
        eventosRTC::rotina15Minutos = true;        
    }
    
    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");
            testaTudoDevices();
        }
        sdCard::fechaArquivo(&sdCard::devices);
    }    
}

void inicializaMaquina(){
    pwmPeriod = 100000;    
    SD1.period_us(pwmPeriod);
    modemCom::atendendoWebServer = false;
    serialPC::serialPC_init();    
    pc.printf("Versao 07/02/2016.\r\n");
    modemCom::timeOutModem = 30;
    serialModem::serial_init();        
    numeroDeBytesPorEnvio = 768;        
    //loadStandardConfig(); //Carregando standardConfig //DEBUG  DEBUG  DEBUG  DEBUG  DEBUG  DEBUG  DEBUG      
    modBusMaster1::modBusMaster(&modBusMaster1Serial,19200,&max_de);    
    
    /*
    //Interrupções externas e botões
    int_wh.mode(PullNone);    
    int_varh.mode(PullNone);
    
    int_wh.fall(&whCount);    
    int_varh.fall(&varhCount);*/
    
    //DEBUG
    pc.printf("Inicializando DROME.\n");    
    
    //Debug debug debug debug debug debug debug debug debug debug debug debug
    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");   
     }      
    
    
    
    
    
    //Timers por minuto
    RTC::attach(&RTC_POR_SEGUNDO, RTC::Second);                  
    //Chamada de threads 
    //Thread dos timers!
    idThreadTimers = osThreadCreate(osThread(threadTimers), NULL);    
    //Thread das comunicacoes
    idThreadComunicacoes = osThreadCreate(osThread(threadComunicacoes), NULL);
    //Thread da funcao processaPacote
    idThreadProcessaPacote = osThreadCreate(osThread(threadProcessaPacote), NULL);
    //Chamada de threads        
    serialModem::configBaud();    
}

void verificaSaidasDigitais(){
    SD_OE_R = 1;
}

Serial modem(P0_10,P0_11); //Instancia de recurso Serial uart Modem 
//Inicio do programa;
int main() {
    //Inicializando maquina        

    /*uint16_t leInicioESP=150000;
    while(leInicioESP){
        if(modem.readable()){
            char r = modem.getc();
            pc.putc(r);            
        }
        wait(0.0001);
        leInicioESP--;
    }*/

    diversos::wdt.kick(90.0);    
    
    modem.baud(76800);
    ESP_CH_PD = 1;          
    ESP_ESPGPIO_2 = 1;
    ESP_RESET = 1;    
    
    
    reportaMudancaAoServer = true;
    modemCom::status.emComunicacao=false;       
    
    wait(5);    
    inicializaMaquina();       
    modemCom::inicializaModem();
    modemCom::conectaWiFi();
    wait(2);
    modemCom::enviaDados(dadosStatus);
    
    while(true){            
        if(eventosRTC::rotina1segundo){
            eventosRTC::rotina1segundo = false;    
            
            if(enviaDadosPorAlarme!=255){
                enviaDadosPorAlarme--;
                if(enviaDadosPorAlarme==0){
                    eventosRTC::rotina1hora=true;
                    enviaDadosPorAlarme=255;
                }
            }
            //pc.printf("Passo 1.\r\n");                       
            leiturasAnalogicas();
            //pc.printf("Passo 2.\r\n");
            leiturasDigitais();
            //pc.printf("Passo 3.\r\n");            
            verifyAlarms();           
            //pc.printf("Passo 4.\r\n");
            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]);
            
            //Debug teste de saidas digitais.
            /*
                DigitalIn SD_FAULT(P1_9);
                DigitalOut SD_OE_R(P1_10);
                
                DigitalOut SD1(P1_18);
                DigitalOut SD2(P1_20);
            */
            
            /*if(SD_FAULT){
                printf("Estado de SD_FAULT = 1.\r\n");
            }else{printf("Estado de SD_FAULT = 0.\r\n");}
            SD_OE_R = 1;
            
            SD1.period(0.001);
            SD2.period(0.0001);
            
            SD1.write(1);
            for(int cont = 0; cont<11; cont++){
                SD2.write((float)cont/10);
                wait(0.5);
                printf("Intensidade = %f.\r\n",(float)(cont/10));    
            }*/
        }
        
        if(eventosRTC::rotina10Segundos){                                    
            //Executo abaixo a rotina de 10 segundos                          
            verifySchedules();
            eventosRTC::rotina10Segundos = false;
        }   
                   
        if(eventosRTC::minutos){
            //Executo abaixo a rotina de 1 minuto
            writeReadingsToSD();
            eventosRTC::minutos = false;
        }        
        
        if(executaComandoServer){
            executaComandoServer = false;
            commands::exec(connID);   
        }  
        
        if(modemCom::atendendoWebServer){                
                modemCom::atendendoWebServer = false;
                pc.printf("Atendendo webServer.\r\n");
                modemCom::webServer();                
        }
        /*
        if(enviaSendData){
            enviaSendData = false;
            modemCom::sendBufferCommandMode(connID,"sendData\r\n",10);    
        }
        */      
        /*if(eventosRTC::rotina1hora){                        
            osDelay(1000); //Para dar tempo de a threadComunicações ver que tinha uma rotina de 1 hora agendada.
            eventosRTC::rotina1hora = false;
            //Executo abaixo a rotina de 1 hora            
        }*/
    }
}