Revision 13:eed9484a89bc, committed 2015-07-28

Comitter:

tpadovani

Date:

Tue Jul 28 17:56:11 2015 +0000

Parent:

12:0f549dfba86c

Child:

14:4963dc299580

Commit message:

Implementa??o de alarmes

Changed in this revision

--- a/GGSProtocol.lib	Mon Jul 27 22:51:13 2015 +0000
+++ b/GGSProtocol.lib	Tue Jul 28 17:56:11 2015 +0000
@@ -1,1 +1,1 @@
-http://developer.mbed.org/teams/Equipe-Firmware-V2COM/code/GGSProtocol/#4e01e5cee8e0
+http://developer.mbed.org/teams/Equipe-Firmware-V2COM/code/GGSProtocol/#d8e03350b1da

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/alarm.cpp	Tue Jul 28 17:56:11 2015 +0000
@@ -0,0 +1,24 @@
+#include "alarm.h"
+
+void Alarm::loadQueue(int size, int sector){
+    alarmQueue.init(size, sector);
+    printf("[Alarm] Alarm queue loaded (Max %d records)\r\n", size);
+}
+
+void Alarm::writeAlarm(int code, bool state, bool previousState){
+    if(state == previousState){
+        return;
+    }
+    AlarmEntry entry;
+    entry.time = time(NULL);
+    entry.code = code;
+    entry.state = state ? 1 : 0;
+    
+    alarmQueue.add((char*)&entry);
+    printf("[Alarm] New record stored: Time=%d, Code=%d, State=%d\r\n", entry.time, entry.code, entry.state);
+    setAlarmState(code, state);
+}
+
+char* Alarm::getAllAlarms(){
+    return alarmQueue.getAll();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/alarm.h	Tue Jul 28 17:56:11 2015 +0000
@@ -0,0 +1,25 @@
+#ifndef ALARMS_H
+#define ALARMS_H
+
+#include "mbed.h"
+#include "queue.h"
+#include "appParameters.h"
+
+typedef struct{
+    unsigned int time;
+    unsigned short int code;
+    unsigned short int state;
+} AlarmEntry;
+
+class Alarm {
+
+    PersistentCircularQueue alarmQueue;
+    
+  public:
+    void loadQueue(int size, int sector);
+    void writeAlarm(int code, bool state, bool previousState);
+    char* getAllAlarms();
+
+};
+
+#endif

--- a/appCommands.cpp	Mon Jul 27 22:51:13 2015 +0000
+++ b/appCommands.cpp	Tue Jul 28 17:56:11 2015 +0000
@@ -60,6 +60,9 @@
         case CMD_EXEC_CMD_BTM:
             cmdExecCmdBtm(dados, tamanho - TAMANHO_MINIMO_PACOTE);
             break;
+        case CMD_LER_ALARMES:
+            cmdLerALarmes(dados[0]);
+            break;
     }
 }
 

--- a/appCommands.h	Mon Jul 27 22:51:13 2015 +0000
+++ b/appCommands.h	Tue Jul 28 17:56:11 2015 +0000
@@ -45,6 +45,8 @@
 #define RESP_GRAVAR_PARAM_BLUETOOTH         0x30
 #define CMD_EXEC_CMD_BTM                    0x31
 #define RESP_EXEC_CMD_BTM                   0x32
+#define CMD_LER_ALARMES                     0x33
+#define RESP_LER_ALARMES                    0x34
 
 extern CommandExecutor exec;
 extern Parameters param;
@@ -75,6 +77,8 @@
 void cmdTensaoInstantanea(int lineOrLoad);
 void cmdMMTensao(int lineOrLoad, int block);
 
+void cmdLerAlarmes(int block);
+
 void atualizaEstadoRele(unsigned char estado);
 unsigned char lerEstadoRele();
 

--- a/appParameters.cpp	Mon Jul 27 22:51:13 2015 +0000
+++ b/appParameters.cpp	Tue Jul 28 17:56:11 2015 +0000
@@ -61,4 +61,59 @@
         APP_PARAMETERS.contadorCiclos = DEFAULT_CONTADOR_CICLOS;
     }
     
+    if(((char *)&APP_PARAMETERS.ENABLE_ALARMS)[0] == 0xff && ((char *)&APP_PARAMETERS.ENABLE_ALARMS)[1] == 0xff && ((char *)&APP_PARAMETERS.ENABLE_ALARMS)[2] == 0xff && ((char *)&APP_PARAMETERS.ENABLE_ALARMS)[3] == 0xff){
+        APP_PARAMETERS.ENABLE_ALARMS = DEFAULT_ENABLE_ALARMS;
+    }
+    
+    if(((char *)&APP_PARAMETERS.ALARMS_STATES)[0] == 0xff && ((char *)&APP_PARAMETERS.ALARMS_STATES)[1] == 0xff && ((char *)&APP_PARAMETERS.ALARMS_STATES)[2] == 0xff && ((char *)&APP_PARAMETERS.ALARMS_STATES)[3] == 0xff){
+        APP_PARAMETERS.ALARMS_STATES = DEFAULT_ALARMS_STATES;
+    }
+    
+    if(((char *)&APP_PARAMETERS.ALARMS_QUEUE_SIZE)[0] == 0xff && ((char *)&APP_PARAMETERS.ALARMS_QUEUE_SIZE)[1] == 0xff && ((char *)&APP_PARAMETERS.ALARMS_QUEUE_SIZE)[2] == 0xff && ((char *)&APP_PARAMETERS.ALARMS_QUEUE_SIZE)[3] == 0xff){
+        APP_PARAMETERS.ALARMS_QUEUE_SIZE = DEFAULT_ALARMS_QUEUE_SIZE;
+    }
+    
+    if(((char *)&APP_PARAMETERS.LIMITE_TENSAO_ZERO_LINHA_V)[0] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_ZERO_LINHA_V)[1] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_ZERO_LINHA_V)[2] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_ZERO_LINHA_V)[3] == 0xff){
+        APP_PARAMETERS.LIMITE_TENSAO_ZERO_LINHA_V = DEFAULT_LIMITE_TENSAO_ZERO_LINHA_V;
+    }
+    
+    if(((char *)&APP_PARAMETERS.LIMITE_TENSAO_MINIMA_LINHA_V)[0] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MINIMA_LINHA_V)[1] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MINIMA_LINHA_V)[2] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MINIMA_LINHA_V)[3] == 0xff){
+        APP_PARAMETERS.LIMITE_TENSAO_MINIMA_LINHA_V = DEFAULT_LIMITE_TENSAO_MINIMA_LINHA_V;
+    }
+    
+    if(((char *)&APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_LINHA_V)[0] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_LINHA_V)[1] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_LINHA_V)[2] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_LINHA_V)[3] == 0xff){
+        APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_LINHA_V = DEFAULT_LIMITE_TENSAO_MAXIMA_LINHA_V;
+    }
+    
+    if(((char *)&APP_PARAMETERS.LIMITE_TENSAO_ZERO_CARGA_V)[0] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_ZERO_CARGA_V)[1] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_ZERO_CARGA_V)[2] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_ZERO_CARGA_V)[3] == 0xff){
+        APP_PARAMETERS.LIMITE_TENSAO_ZERO_CARGA_V = DEFAULT_LIMITE_TENSAO_ZERO_CARGA_V;
+    }
+    
+    if(((char *)&APP_PARAMETERS.LIMITE_TENSAO_MINIMA_CARGA_V)[0] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MINIMA_CARGA_V)[1] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MINIMA_CARGA_V)[2] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MINIMA_CARGA_V)[3] == 0xff){
+        APP_PARAMETERS.LIMITE_TENSAO_MINIMA_CARGA_V = DEFAULT_LIMITE_TENSAO_MINIMA_CARGA_V;
+    }
+    
+    if(((char *)&APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_CARGA_V)[0] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_CARGA_V)[1] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_CARGA_V)[2] == 0xff && ((char *)&APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_CARGA_V)[3] == 0xff){
+        APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_CARGA_V = DEFAULT_LIMITE_TENSAO_MAXIMA_CARGA_V;
+    }
+
 }
+
+bool isAlarmEnabled(int alarm){
+    return (APP_PARAMETERS.ENABLE_ALARMS & (1 << alarm)) > 0;
+}
+
+bool getAlarmState(int alarm){
+    return (APP_PARAMETERS.ALARMS_STATES & (1 << alarm)) > 0;
+}
+
+void setAlarmState(int alarm, bool state){
+    if(state){
+        APP_PARAMETERS.ALARMS_STATES |= (1 << alarm);
+    } else{
+        APP_PARAMETERS.ALARMS_STATES &= ~(1 << alarm);
+    }
+    if(!param.saveParameters()){
+        printf("[Param] Erro gravando estado do alarme %d\r\n", alarm);
+    }
+}

--- a/appParameters.h	Mon Jul 27 22:51:13 2015 +0000
+++ b/appParameters.h	Tue Jul 28 17:56:11 2015 +0000
@@ -3,6 +3,21 @@
 
 #include "mbed.h"
 #include "settings.h"
+#include "parameters.h"
+
+#define ALARME_LINHA_TENSAO_ZERO        0
+#define ALARME_LINHA_TENSAO_MINIMA      1
+#define ALARME_LINHA_TENSAO_MAXIMA      2
+#define ALARME_LINHA_CORRENTE_ZERO      3
+#define ALARME_LINHA_CORRENTE_MINIMA    4
+#define ALARME_LINHA_CORRENTE_MAXIMA    5
+#define ALARME_CARGA_TENSAO_ZERO        6
+#define ALARME_CARGA_TENSAO_MINIMA      7
+#define ALARME_CARGA_TENSAO_MAXIMA      8
+#define ALARME_CARGA_CORRENTE_ZERO      9
+#define ALARME_CARGA_CORRENTE_MINIMA    10
+#define ALARME_CARGA_CORRENTE_MAXIMA    11
+#define ALARME_RETORNO_POTENCIAL        12
 
 typedef struct {
     unsigned int estadoRele;
@@ -26,10 +41,21 @@
     unsigned int INTERVALO_MM_S;              // Intervalo de leitura de Memoria de Massa em segundos
     unsigned int MM_SIZE;                     // Numero maximo de registros da memoria de massa
     unsigned int contadorCiclos;              // Totalizador de numero de operacoes de corte/religa
-    char reserved[4];                         // Apenas para completar numero de bytes para ficar multiplo de 8
+    unsigned int ENABLE_ALARMS;               // Bitmask para habilitacao dos alarmes
+    unsigned int ALARMS_STATES;               // Estados dos alarmes
+    unsigned int ALARMS_QUEUE_SIZE;           // Tamanho maximo da fila de alarmes
+    unsigned int LIMITE_TENSAO_ZERO_LINHA_V;
+    unsigned int LIMITE_TENSAO_MINIMA_LINHA_V;
+    unsigned int LIMITE_TENSAO_MAXIMA_LINHA_V;
+    unsigned int LIMITE_TENSAO_ZERO_CARGA_V;
+    unsigned int LIMITE_TENSAO_MINIMA_CARGA_V;
+    unsigned int LIMITE_TENSAO_MAXIMA_CARGA_V;
 } ParametersBlock;
 
 void validateAppParameters();
+bool isAlarmEnabled(int alarm);
+bool getAlarmState(int alarm);
+void setAlarmState(int alarm, bool state);
 
 extern ParametersBlock APP_PARAMETERS;
 

--- a/btm.cpp	Mon Jul 27 22:51:13 2015 +0000
+++ b/btm.cpp	Tue Jul 28 17:56:11 2015 +0000
@@ -13,7 +13,7 @@
 
 void closeAtMode(){
     sendAtCommand("ATO\r", 4, buffer, MAX_BUFFER_BTM);
-    wait_ms(1000);
+    wait_ms(500);
     exec.iniciaExecutorComandos();
 }
 
@@ -22,7 +22,7 @@
     int cursor = -1;
     int state = 0;
     
-    printf("[BTM] Dropping: ");
+//    printf("[BTM] Dropping: ");
     while(ggsStream.readable()){    // Clean buffer
         printf("%02x", ggsStream.getc());
     }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cmd/lerAlarmes.cpp	Tue Jul 28 17:56:11 2015 +0000
@@ -0,0 +1,41 @@
+#include "appCommands.h"
+#include "alarm.h"
+
+#define ALARMES_FALHA     1
+#define ALARMES_FIM       2
+
+extern Alarm alarm;
+char* respAlarm;
+
+void cmdLerAlarmes(int block){
+    if(block == 0){
+        free(respAlarm);
+        respAlarm = alarm.getAllAlarms();
+    }
+
+    if(respAlarm == NULL){
+        exec.enviaResposta(RESP_LER_ALARMES, ALARMES_FALHA);
+    } else{
+        int alarmSize = APP_PARAMETERS.ALARMS_QUEUE_SIZE;
+        if(alarmSize < 0 || alarmSize > 127){
+            alarmSize = 100;   // Use default
+        }
+        int blocks = ceil(alarmSize / 25.0);
+        if(blocks < 0 || blocks > 6){
+            blocks = 4; // Use default of 100 entries
+        }
+        if(block >= blocks){
+            exec.enviaResposta(RESP_LER_ALARMES, ALARMES_FIM);
+            free(respAlarm);
+        } else{
+            int size = 8*25;
+            if(block == blocks-1){
+                size = 8*(APP_PARAMETERS.ALARMS_QUEUE_SIZE % 25);
+                if(size == 0){
+                    size = 8*25;
+                }
+            }
+            exec.enviaResposta(RESP_LER_ALARMES, respAlarm+block*8*25, size);
+        }
+    }
+}

--- a/main.cpp	Mon Jul 27 22:51:13 2015 +0000
+++ b/main.cpp	Tue Jul 28 17:56:11 2015 +0000
@@ -6,6 +6,7 @@
 Parameters param ((char *)&APP_PARAMETERS, sizeof(APP_PARAMETERS));
 CommandExecutor exec;
 MemoriaMassa mm;
+Alarm alarm;
 
 int main()
 {
@@ -17,7 +18,8 @@
     param.loadParameters();
     printParameters();
     
-    mm.iniciaLeituras(APP_PARAMETERS.INTERVALO_MM_S, APP_PARAMETERS.MM_SIZE);
+    alarm.loadQueue(APP_PARAMETERS.ALARMS_QUEUE_SIZE, 3);
+    mm.iniciaLeituras(APP_PARAMETERS.INTERVALO_MM_S, APP_PARAMETERS.MM_SIZE, 4, 5);
     
     ggsStream.baud(19200);
     exec.carregaEndereco(sn.get());

--- a/main.h	Mon Jul 27 22:51:13 2015 +0000
+++ b/main.h	Tue Jul 28 17:56:11 2015 +0000
@@ -12,6 +12,7 @@
 #include "ggs.h"
 #include "sensor.h"
 #include "memoriaMassa.h"
+#include "alarm.h"
 
 ParametersBlock APP_PARAMETERS;
 

--- a/memoriaMassa.cpp	Mon Jul 27 22:51:13 2015 +0000
+++ b/memoriaMassa.cpp	Tue Jul 28 17:56:11 2015 +0000
@@ -1,9 +1,9 @@
 #include "memoriaMassa.h"
 
-void MemoriaMassa::iniciaLeituras(int periodoSec, int size){
+void MemoriaMassa::iniciaLeituras(int periodoSec, int size, int sector1, int sector2){
     mmPeriodoSec = periodoSec;
-    queue[0].init(size, 3);
-    queue[1].init(size, 4);
+    queue[0].init(size, sector1);
+    queue[1].init(size, sector2);
     leituraPeriodica.attach(this, &MemoriaMassa::disparaLeitura, mmPeriodoSec);
     printf("[MM] Periodic Reading started (%d seconds)\r\n", mmPeriodoSec);
 }
@@ -17,17 +17,21 @@
         return;
     }
     
+    float f1 = getTensaoInstantanea(0);
+    float f2 = getTensaoInstantanea(1);
+    
     LeituraMM leitura;
-    leitura.value.floatValue = getTensaoInstantanea(0);
+    leitura.value.floatValue = f1;
     leitura.time = time(NULL);
     queue[0].add((char*)&leitura);
-    
-    printf("[MM] New record stored: Time=%d, Ch0=%f\r\n", leitura.time, leitura.value.floatValue);
-    
-    leitura.value.floatValue = getTensaoInstantanea(1);
+
+    leitura.value.floatValue = f2;
     queue[1].add((char*)&leitura);
     
-    printf("[MM] New record stored: Time=%d, Ch1=%f\r\n", leitura.time, leitura.value.floatValue);
+    printf("[MM] New record stored: Time=%d, Ch0=%f\r\n", leitura.time, f1);
+    printf("[MM] New record stored: Time=%d, Ch1=%f\r\n", leitura.time, f2);
+    
+    checkAlarms(f1, f2);
 
     lerAgora = false;
 }
@@ -39,3 +43,51 @@
     }
     return queue[channel].getAll();
 }
+
+void MemoriaMassa::checkAlarms(float ch1, float ch2){
+    bool tensaoZero, tensaoMinima, tensaoMaxima;
+    int linha, carga;
+    if(APP_PARAMETERS.LOAD_CHANNEL == 0){
+        linha = (int)ch2;
+        carga = (int)ch1;
+    } else{
+        linha = (int)ch1;
+        carga = (int)ch2;
+    }
+    tensaoZero = linha < APP_PARAMETERS.LIMITE_TENSAO_ZERO_LINHA_V;
+    tensaoMinima = linha < APP_PARAMETERS.LIMITE_TENSAO_MINIMA_LINHA_V;
+    tensaoMaxima = linha < APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_LINHA_V;
+    
+    printf("[MM] Linha TensaoZero = %d\r\n", tensaoZero);
+    printf("[MM] Linha TensaoMinima = %d\r\n", tensaoMinima);
+    printf("[MM] Linha TensaoMaxima = %d\r\n", tensaoMaxima);
+    
+    if(isAlarmEnabled(ALARME_LINHA_TENSAO_ZERO)){
+        alarm.writeAlarm(ALARME_LINHA_TENSAO_ZERO, tensaoZero, getAlarmState(ALARME_LINHA_TENSAO_ZERO));
+    }
+    if(isAlarmEnabled(ALARME_LINHA_TENSAO_MINIMA)){
+        alarm.writeAlarm(ALARME_LINHA_TENSAO_MINIMA, tensaoMinima, getAlarmState(ALARME_LINHA_TENSAO_MINIMA));
+    }
+    if(isAlarmEnabled(ALARME_LINHA_TENSAO_MAXIMA)){
+        alarm.writeAlarm(ALARME_LINHA_TENSAO_MAXIMA, tensaoMaxima, getAlarmState(ALARME_LINHA_TENSAO_MAXIMA));
+    }
+    
+    tensaoZero = carga < APP_PARAMETERS.LIMITE_TENSAO_ZERO_CARGA_V;
+    tensaoMinima = carga < APP_PARAMETERS.LIMITE_TENSAO_MINIMA_CARGA_V;
+    tensaoMaxima = carga < APP_PARAMETERS.LIMITE_TENSAO_MAXIMA_CARGA_V;
+    
+    printf("[MM] Carga TensaoZero = %d\r\n", tensaoZero);
+    printf("[MM] Carga TensaoMinima = %d\r\n", tensaoMinima);
+    printf("[MM] Carga TensaoMaxima = %d\r\n", tensaoMaxima);
+    
+    if(isAlarmEnabled(ALARME_CARGA_TENSAO_ZERO)){
+        alarm.writeAlarm(ALARME_CARGA_TENSAO_ZERO, tensaoZero, getAlarmState(ALARME_CARGA_TENSAO_ZERO));
+    }
+    if(isAlarmEnabled(ALARME_CARGA_TENSAO_MINIMA)){
+        alarm.writeAlarm(ALARME_CARGA_TENSAO_MINIMA, tensaoMinima, getAlarmState(ALARME_CARGA_TENSAO_MINIMA));
+    }
+    if(isAlarmEnabled(ALARME_CARGA_TENSAO_MAXIMA)){
+        alarm.writeAlarm(ALARME_CARGA_TENSAO_MAXIMA, tensaoMaxima, getAlarmState(ALARME_CARGA_TENSAO_MAXIMA));
+    }
+
+}

--- a/memoriaMassa.h	Mon Jul 27 22:51:13 2015 +0000
+++ b/memoriaMassa.h	Tue Jul 28 17:56:11 2015 +0000
@@ -4,6 +4,8 @@
 #include "mbed.h"
 #include "queue.h"
 #include "sensor.h"
+#include "alarm.h"
+#include "appParameters.h"
 
 typedef struct{
     unsigned int time;
@@ -13,6 +15,8 @@
     } value;
 } LeituraMM;
 
+extern Alarm alarm;
+
 class MemoriaMassa {
 
     Ticker leituraPeriodica;
@@ -22,10 +26,11 @@
     PersistentCircularQueue queue[2];
     
   public:
-    void iniciaLeituras(int periodoSec, int size);
+    void iniciaLeituras(int periodoSec, int size, int sector1, int sector2);
     void disparaLeitura();
     void executaLeitura();
     char* getMM(int channel);
+    void checkAlarms(float ch1, float ch2);
 
 };
 

--- a/settings.h	Mon Jul 27 22:51:13 2015 +0000
+++ b/settings.h	Tue Jul 28 17:56:11 2015 +0000
@@ -15,7 +15,7 @@
 #define DEFAULT_CORTAR_LARGURA_PULSO_MS 150
 #define DEFAULT_DELAY_SENSOR_MS 500
 #define DEFAULT_INTERVALO_SILENCIO_S 2
-#define DEFAULT_INTERVALO_WD_NETWORK_S 1800
+#define DEFAULT_INTERVALO_WD_NETWORK_S 0    // 0 desabilita o watchdog de rede
 #define DEFAULT_LIMITE_TENSAO_SENSOR_V 40
 #define DEFAULT_SAMPLES 500
 #define DEFAULT_SAMPLES_DELAY_US 2000
@@ -25,5 +25,14 @@
 #define DEFAULT_INTERVALO_MM_S 60
 #define DEFAULT_MM_SIZE 100
 #define DEFAULT_CONTADOR_CICLOS 0
+#define DEFAULT_ENABLE_ALARMS 8191
+#define DEFAULT_ALARMS_STATES 0
+#define DEFAULT_ALARMS_QUEUE_SIZE 100
+#define DEFAULT_LIMITE_TENSAO_ZERO_LINHA_V 5
+#define DEFAULT_LIMITE_TENSAO_MINIMA_LINHA_V 80
+#define DEFAULT_LIMITE_TENSAO_MAXIMA_LINHA_V 140
+#define DEFAULT_LIMITE_TENSAO_ZERO_CARGA_V 5
+#define DEFAULT_LIMITE_TENSAO_MINIMA_CARGA_V 80
+#define DEFAULT_LIMITE_TENSAO_MAXIMA_CARGA_V 140
 
 #endif

--- a/version.h	Mon Jul 27 22:51:13 2015 +0000
+++ b/version.h	Tue Jul 28 17:56:11 2015 +0000
@@ -4,9 +4,9 @@
 #include "settings.h"
 
 #ifdef TEST_MODE
-    static const char version[] = "SmartRamal v0.8 TST";
+    static const char version[] = "SmartRamal v0.9 TST";
 #else
-    static const char version[] = "SmartRamal v0.8";
+    static const char version[] = "SmartRamal v0.9";
 #endif
 
 #endif