smartbreaker.cpp

00001 #include "smartbreaker.h"
00002 
00003 #if ( defined( BREAKER ) || defined( RAMAL ) )
00004 
00005 //////////////////////////////////////////////////////////////
00006 // Variables
00007 
00008 #ifdef CONFIGURE_PINO_STACK
00009     static volatile bool initOK;
00010 #endif
00011 
00012 //////////////////////////////////////////////////////////////
00013 // Function Prototypes
00014 
00015 static void initSmartBreaker();
00016 
00017 
00018 //////////////////////////////////////////////////////////////
00019 // Private Functions
00020 
00021 static void initSmartBreaker() {
00022     #ifdef LED_TESTE
00023         TestLeds();
00024     #else
00025         blinkLeds();
00026     #endif
00027 
00028     Alarm::init( APP_PARAMETERS.ENABLE_ALARMS, APP_PARAMETERS.ALARMS_STATES );
00029     Alarm::queue.init( APP_PARAMETERS.ALARMS_QUEUE_SIZE, ALARM_PAGE );
00030     #ifdef  RESET_ALARMS_ON_BOOT
00031         Alarm::queue.dropQueue();
00032     #endif
00033     Alarm::onUpdate( &updateAlarms );
00034 
00035     #ifdef ED02R3
00036         sensors.reset();
00037         sensors.init();
00038         sensors.setBitValue( ADE7978::VAR_CURRENT, DEFAULT_BIT_INCREMENT_C );
00039         sensors.setBitValue( ADE7978::VAR_VOLTAGE, DEFAULT_BIT_INCREMENT_V1 );
00040         sensors.setBitValue( ADE7978::VAR_VOLTAGE2P, DEFAULT_BIT_INCREMENT_V2 );
00041         for ( int p = 0; p < ADE7978::NUM_PHASES; p++ ) {
00042             for ( int v = 0; v < ADE7978::NUM_VARS; v++ ) {
00043                 sensors.setGainRegister( static_cast< ADE7978::Phase >( p ), static_cast< ADE7978::Variable >( v ), APP_PARAMETERS.ADE_ANG_COEF[p][v] );
00044                 sensors.setOffsetRegister( static_cast< ADE7978::Phase >( p ), static_cast< ADE7978::Variable >( v ), APP_PARAMETERS.ADE_LIN_COEF[p][v] );
00045             }
00046         }
00047 
00048     #else
00049         rmsChannel[ IDX_RMS_VOLTAGE_CH0 ].setSumParams( APP_PARAMETERS.SAMPLES, APP_PARAMETERS.SAMPLES_DELAY_US );
00050         rmsChannel[ IDX_RMS_VOLTAGE_CH0 ].setCoeficients( APP_PARAMETERS.SAMPLES_VOLTAGE_ANG_COEF.floatValue, APP_PARAMETERS.SAMPLES_VOLTAGE_LIN_COEF.floatValue );
00051         rmsChannel[ IDX_RMS_VOLTAGE_CH0 ].attach( &adChannel[ 0 ], &AnalogIn::read );
00052         rmsChannel[ IDX_RMS_VOLTAGE_CH1 ].setSumParams( APP_PARAMETERS.SAMPLES, APP_PARAMETERS.SAMPLES_DELAY_US );
00053         rmsChannel[ IDX_RMS_VOLTAGE_CH1 ].setCoeficients( APP_PARAMETERS.SAMPLES_VOLTAGE_ANG_COEF.floatValue, APP_PARAMETERS.SAMPLES_VOLTAGE_LIN_COEF.floatValue );
00054         rmsChannel[ IDX_RMS_VOLTAGE_CH1 ].attach( &adChannel[ 1 ], &AnalogIn::read );
00055         rmsChannel[ IDX_RMS_CURRENT ].setSumParams( APP_PARAMETERS.SAMPLES, APP_PARAMETERS.SAMPLES_DELAY_US );
00056         rmsChannel[ IDX_RMS_CURRENT ].setCoeficients( APP_PARAMETERS.SAMPLES_CURRENT_ANG_COEF.floatValue, APP_PARAMETERS.SAMPLES_CURRENT_LIN_COEF.floatValue );
00057         rmsChannel[ IDX_RMS_CURRENT ].setLimits( APP_PARAMETERS.LIMITE_CORRENTE_ZERO_A.floatValue );
00058         rmsChannel[ IDX_RMS_CURRENT ].attach( &adChannel[ 2 ], &AnalogIn::read );
00059 
00060         if ( APP_PARAMETERS.LOAD_CHANNEL == IDX_RMS_VOLTAGE_CH0 ) {
00061             powerSensor.attach( &rmsChannel[ IDX_RMS_VOLTAGE_CH1 ], &RMS::sampleData , PowerSensor::LineIrq );
00062             powerSensor.attach( &rmsChannel[ IDX_RMS_VOLTAGE_CH0 ], &RMS::sampleData , PowerSensor::LoadIrq );
00063         }
00064         else {
00065             powerSensor.attach( &rmsChannel[ IDX_RMS_VOLTAGE_CH0 ], &RMS::sampleData , PowerSensor::LineIrq );
00066             powerSensor.attach( &rmsChannel[ IDX_RMS_VOLTAGE_CH1 ], &RMS::sampleData , PowerSensor::LoadIrq );
00067         }
00068         powerSensor.setThreshold( APP_PARAMETERS.LIMITE_TENSAO_SENSOR_V );
00069     #endif
00070 
00071     #ifdef BREAKER
00072         isopowerDisable = 0;    // Habilita regulador (PIMA + Alarme Caixa)
00073         boxAlarm.init();
00074         pima.setExpirationTimeout( APP_PARAMETERS.PIMA_VALIDADE_MEDIDOR_S, 
00075                                    APP_PARAMETERS.PIMA_VALIDADE_ENERGIA_ATIVA_S, 
00076                                    APP_PARAMETERS.PIMA_VALIDADE_ENERGIA_REATIVA_INDUTIVA_S, 
00077                                    APP_PARAMETERS.PIMA_VALIDADE_ENERGIA_REATIVA_CAPACITIVA_S );
00078         pima.attachTout( &softReset );
00079         if( APP_PARAMETERS.PROTOCOLO_MEDIDOR == PROTOCOLO_PIMINHA ) {
00080             pima.iniciaLeituraPiminha( APP_PARAMETERS.PIMA_AUTOBAUD_ENABLE, 
00081                                        APP_PARAMETERS.PIMA_AUTOBAUD_TIMEOUT_S, 
00082                                        APP_PARAMETERS.INTERVALO_WD_METER_S, 
00083                                        APP_PARAMETERS.PIMA_TIMEOUT_PACOTE_S );
00084         } 
00085         else
00086             pima.iniciaLeituraPima( APP_PARAMETERS.PIMA_AUTOBAUD_ENABLE, 
00087                                     APP_PARAMETERS.PIMA_AUTOBAUD_TIMEOUT_S, 
00088                                     APP_PARAMETERS.INTERVALO_WD_METER_S);
00089     #endif
00090 
00091 /*
00092     const LimitsMM lmm = {
00093         .loadChannel = APP_PARAMETERS.LOAD_CHANNEL,
00094         .limiteTensaoZeroCh0 = APP_PARAMETERS.LIMITE_TENSAO_ZERO_CH0_V,
00095         .limiteTensaoZeroCh1 = APP_PARAMETERS.LIMITE_TENSAO_ZERO_CH1_V,
00096         .limiteTensaoSensorV = APP_PARAMETERS.LIMITE_TENSAO_SENSOR_V,
00097         .limiteTensaoMinimaLinhaV = APP_PARAMETERS.LIMITE_TENSAO_MINIMA_LINHA_V,
00098         .limiteTensaoMaximaLinhaV = APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_LINHA_V,
00099         .limiteTensaoMinimaCargaV = APP_PARAMETERS.LIMITE_TENSAO_MINIMA_CARGA_V,
00100         .limiteTensaoMaximaCargaV = APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_CARGA_V,
00101         .limiteCorrenteZeroA = APP_PARAMETERS.LIMITE_CORRENTE_ZERO_A.floatValue,
00102         .limiteCorrenteMinimaA = APP_PARAMETERS.LIMITE_CORRENTE_MINIMA_A.floatValue,
00103         .limiteCorrenteMaximaA = APP_PARAMETERS.LIMITE_CORRENTE_MAXIMA_A.floatValue
00104     };
00105     MemoriaMassa::setLimits( lmm );
00106     for ( int i = 0; i < NUMBER_OF_MM_AREAS; i++ ) {
00107         mm[i].setLoadProfile( APP_PARAMETERS.ENABLE_LOAD_PROFILE );
00108         mm[i].iniciaLeituras( APP_PARAMETERS.INTERVALO_MM_S, 
00109                               APP_PARAMETERS.MM_SIZE, 
00110                               MM_FIRST_PAGE + i, 
00111                               i );
00112         #ifdef RESET_MM_ON_BOOT
00113             mm[i].dropQueue();
00114         #endif
00115     }
00116 */
00117     // initializes serial
00118     #ifdef USE_PINO
00119         ggsStream.baud( APP_PARAMETERS.RADIO_BAUDRATE_BPS );
00120         #ifdef  UART_8N2
00121             ggsStream.format( 8, Serial::None, 2 );
00122         #endif
00123     #else
00124         ggsStream.baud( APP_PARAMETERS.RADIO_BAUDRATE_BPS );
00125         #ifdef  UART_8N2
00126             ggsStream.format( 8, Serial::None, 2 );
00127         #endif
00128     #endif
00129 
00130     #ifdef WAIT_TO_ANSWER
00131         wait_ms( 1000 );
00132         linkLayer.setDelayToSend( 100 );
00133     #endif
00134 
00135     #ifdef USE_PINO
00136         linkLayer.bind( &ggsStream, LinkLayer::Pino );
00137     #else
00138         linkLayer.bind( &ggsStream, LinkLayer::Raw );
00139     #endif
00140     exec.bind( &linkLayer );
00141     exec.carregaEndereco( sn );
00142     exec.attach( &softReset );
00143     exec.iniciaExecutorComandos( APP_PARAMETERS.INTERVALO_WD_NETWORK_S, 
00144                                  APP_PARAMETERS.INTERVALO_SILENCIO_S,
00145                                  &executaComando );
00146 
00147     announce.setDelayCoefs( APP_PARAMETERS.DISCOVERY_DELAY_ANG_COEF_MS, 
00148                             APP_PARAMETERS.DISCOVERY_DELAY_LIN_COEF_MS );
00149     announce.setIntervals( APP_PARAMETERS.ANNOUNCE_INTERVAL_S, 
00150                            APP_PARAMETERS.INTERVALO_SILENCIO_S );
00151         
00152     #ifdef USE_PINO
00153         sn.setDefaultNodeAddress( DEFAULT_NODE_ADDRESS );
00154         // configures Pino stack
00155         ggsStream.init( APP_PARAMETERS.SRC_ENDPOINT, 
00156                         APP_PARAMETERS.DEST_NODE, 
00157                         APP_PARAMETERS.DEST_ENDPOINT, 
00158                         APP_PARAMETERS.DYNAMIC_DEST );
00159 
00160         #ifdef CONFIGURE_PINO_STACK
00161             initOK = false;
00162 
00163             PinoCfgStr pinoCfg = {
00164                 .nodeAddress = sn.getNodeAddress(),
00165                 .networkAddress =  APP_PARAMETERS.NETWORK_ADDRESS,
00166                 .networkChannel  = static_cast< uint8_t >( APP_PARAMETERS.NETWORK_CHANNEL ),
00167                 .nodeRole = static_cast< uint8_t >( APP_PARAMETERS.NODE_ROLE )
00168             };
00169             initOK = ggsStream.checkCfg( pinoCfg, DEFAULT_PINO_CFG_ATTEMPTS );
00170 
00171             #ifdef CONFIGURE_ACCESS_CYCLE
00172                 // configures access cycle
00173                 uint16_t newCycle = static_cast< uint16_t >( APP_PARAMETERS.ACCESS_CYCLE );
00174                 ggsStream.checkCycle( newCycle, newCycle, DEFAULT_PINO_CFG_ATTEMPTS );
00175             #endif
00176 
00177             // waits for the stack to start
00178             ggsStream.checkStop( DEFAULT_PINO_START_ATTEMPTS, APP_PARAMETERS.APP_CONFIG_DATA );
00179         #endif
00180         ggsStream.setRequestAttempts( DEFAULT_PINO_TRIES );
00181         ggsStream.setRequestTimeout( DEFAULT_PINO_TOUT );
00182         ggsStream.setPerPoll( DEFAULT_PINO_PER_POLL );
00183         ggsStream.setIRQPin( &pinoInterrupt );
00184     #endif
00185 
00186     #ifdef BREAKER
00187         //Alarmes dos sensores de temperatura ( 
00188         //      1 - temperatura normal, 
00189         //      2 - temperatura em excesso )
00190 
00191 /*        
00192         TempAlarm::init( PTB3, PTB2 );
00193         if ( APP_PARAMETERS.TEMPERATURE_ALARM_CUT ) {
00194             TempAlarm::attach( &corta, TempAlarm::CutIrq );
00195             TempAlarm::attach( &religa, TempAlarm::RearmIrq );
00196         }
00197 
00198         tempAlarm[ IDX_TEMP_ALARM_LINE ].setParams( LM75B::ADDRESS_0, 
00199                                 PTC6, 
00200                                 APP_PARAMETERS.LINE_TEMPERATURE_ALARM.floatValue, 
00201                                 APP_PARAMETERS.LINE_TEMPERATURE_HYST.floatValue,
00202                                 Alarm::ALARME_TEMP_LINE, false );
00203 
00204         tempAlarm[ IDX_TEMP_ALARM_LOAD ].setParams( LM75B::ADDRESS_1, 
00205                                 PTD0, 
00206                                 APP_PARAMETERS.LOAD_TEMPERATURE_ALARM.floatValue,
00207                                 APP_PARAMETERS.LOAD_TEMPERATURE_HYST.floatValue,
00208                                 Alarm::ALARME_TEMP_LOAD, false );
00209 
00210         tempAlarm[ IDX_TEMP_ALARM_CPU ].setParams( LM75B::ADDRESS_2, 
00211                                 PTC7, 
00212                                 APP_PARAMETERS.CPU_TEMPERATURE_ALARM.floatValue, 
00213                                 APP_PARAMETERS.CPU_TEMPERATURE_HYST.floatValue,
00214                                 Alarm::ALARME_TEMP_CPU, false );
00215 */
00216 
00217     #elif defined( RAMAL )
00218         announce.startAnnounceTimer();
00219     #endif
00220 
00221     // Flash
00222     AT25SF041 extFlash( PTD6, PTD7, PTD5, PTD4 );
00223 }
00224 
00225 //////////////////////////////////////////////////////////////
00226 // Public Functions
00227 
00228 void resetSmartBreaker() {
00229     #ifdef WATCHDOG_ENABLED
00230         wdgFeeder.stopService();
00231     #else
00232         // Set the VTOR to the application vector table address.
00233         __disable_irq();
00234         SCB->VTOR = 0;
00235         NVIC_SystemReset();
00236     #endif
00237 }
00238 
00239 void mainSmartBreaker() {
00240     initSmartBreaker();
00241     for(;;) {
00242         #ifdef  USE_PINO
00243             ggsStream.handleFrames();
00244             ggsStream.handleStream();
00245         #endif
00246         exec.trataPacoteGGS();
00247 /*
00248         for ( int i = 0; i < NUMBER_OF_MM_AREAS; i++ )
00249             mm[ i ].executaLeitura();
00250         for ( int i = 0; i < NUMBER_OF_TEMP_ALARMS; i++ )
00251             tempAlarm[ i ].check();
00252         if ( Alarm::check() ) {
00253             exec.enviaNaoSolicitado( CMD_AVISO_ALARME, false );
00254             Alarm::clrNewAlarm();    // debug 
00255         }
00256 */
00257         #ifdef BREAKER
00258             if ( boxAlarm.checkState() )
00259                 ledBox = LED_ON;
00260             else
00261                 ledBox = LED_OFF;
00262 
00263             pima.trataPacotePiminha();
00264             if ( pima.hasMeter() )
00265                 ledMeter = LED_ON;
00266             else
00267                 ledMeter = LED_OFF;
00268             if ( pima.hasMeterChanged() ){
00269                 pima.clrMeterChanged();
00270                 announce.startAnnounceTimer();
00271             }
00272         #endif        
00273         announce.handleAnnounceSending();
00274     }
00275 }
00276 
00277 #endif  // ( defined( BREAKER ) || defined( RAMAL ) )