//External Functions
int gw3761_ResponseReset(p_gw3761 p)
{
int res = 0;
uint_t nFn;
nFn = p->rmsg.data->p[2];
switch (nFn) {
case 1: //F1
res += 1;
break;
case 2: //F2
data_Clear();
evt_Clear();
res += 1;
break;
case 4: //F3
case 8: //F4
icp_Clear();
data_Clear();
evt_Clear();
res += 1;
break;
default:
break;
}
if (res)
gw3761_TmsgConfirm(p);
else
gw3761_TmsgReject(p);
if (nFn == 1) {
os_thd_Sleep(10000);
sys_Reset();
}
return res;
}
/**
* Polls the serial communications (via coms_Poll) and takes
* the apropriate action in response.
*
* @param runData The runData state of the program. This is
* required so the record and livedata flags can be switched.
*/
void coms_Handle(RunData *runData)
{
ComsMsg msg = coms_Poll();
bool valid = true;
int i;
switch (msg.type)
{
case BAD:
case NONE:
//Ignore bad coms
break;
case OVERFLOW:
//ignore - stub for debug
break;
case VERIFY:
runData->record = false;
runData->liveData = false;
usart_Write(SERIAL, COMS_VERIFY_OUT);
usart_Write(SERIAL, COMS_VERIFY_MAJOR_VERSION);
usart_Write(SERIAL, COMS_VERIFY_MINOR_VERSION);
break;
case READ_FLASH:
;
uint32_t addr = ((uint32_t)msg.msg[0] << 16) + ((uint32_t)msg.msg[1] << 8) + msg.msg[2];
uint32_t size = ((uint32_t)msg.msg[3] << 16) + ((uint32_t)msg.msg[4] << 8) + msg.msg[5];
runData->record = false;
runData->liveData = false;
sst_Read_To_Coms((char*)&addr, size);
break;
case WRITE_TIME:
;
Time t;
runData->record = false;
runData->liveData = false;
t.seconds = msg.msg[0];
t.minutes = msg.msg[1];
t.hours = msg.msg[2];
t.dow = msg.msg[3];
t.date = msg.msg[4];
t.month = msg.msg[5];
t.year = msg.msg[6];
rtc_Set_Time(&t);
usart_Write(SERIAL, COMS_WRITE_TIME_OUT);
break;
case READ_CONFIG:
runData->record = false;
runData->liveData = false;
usart_Write(SERIAL, data_Read_EEPROM((msg.msg[0] << 8) + msg.msg[1]));
break;
case WRITE_CONFIG:
runData->record = false;
runData->liveData = false;
data_Write_EEPROM((msg.msg[0] << 8) + msg.msg[1], msg.msg[2]);
usart_Write(SERIAL, COMS_WRITE_CONFIG_OUT);
break;
case LIVE_DATA:
runData->record = false;
runData->liveData = true;
usart_Write(SERIAL, COMS_LIVE_DATA_OUT);
break;
case HEADER_REQ:
;
uint32_t header = data_Cur_Addr();
usart_Write(SERIAL, ((char*)(&header))[2]);
usart_Write(SERIAL, ((char*)(&header))[1]);
usart_Write(SERIAL, ((char*)(&header))[0]);
usart_Write(SERIAL, sizeof(DataPoint));
break;
case RESET_REQ:
for (i = 0; i < COMS_RESET_REQ_SIZE; i++)
{
if (msg.msg[i] != resetConfirmation[i])
{
valid = false;
}
}
if (valid)
{
wdt_enable(WDTO_120MS);
}
break;
case ERASE_REQ:
for (i = 0; i < COMS_RESET_REQ_SIZE; i++)
{
if (msg.msg[i] != resetConfirmation[i])
{
valid = false;
}
}
if (valid)
{
data_Clear();
}
usart_Write(SERIAL, COMS_ERASE_REQ_OUT);
break;
case START_REQ:
for (i = 0; i < COMS_RESET_REQ_SIZE; i++)
{
if (msg.msg[i] != resetConfirmation[i])
{
valid = false;
}
}
if (valid)
{
runData->record = true;
runData->liveData = false;
}
usart_Write(SERIAL, COMS_START_REQ_OUT);
break;
}
}
/**
* Handles all actions related to button presses during operation,
* including LED changes. Any change to runData to relayed through
* the given pointer, such as the recording state. Also handles the
* clear button implementation.
*
* @param runData Address of the runData structure.
*/
void user_Handle_Buttons(RunData *runData)
{
static unsigned int buttonTimer[3] = {0, 0, 0};
static unsigned int buttonLastTime[3] = {0, 0, 0};
int i;
if (user_Get_Button(BUTTON_CLEAR))
{
user_Set_LED(LED_CLEAR, ON);
runData->liveData = false;
if (timer_Job_Ready4(&buttonTimer[BUTTON_CLEAR - 1], 3000, &buttonLastTime[BUTTON_CLEAR - 1], false))
{
runData->record = false;
user_Set_LED(LED_STOP, ON);
user_Set_LED(LED_START, OFF);
data_Clear();
for (i = 0; i < 50; i++)
{
timer_Wait_MS(50);
user_Toggle_LED(LED_CLEAR);
}
}
}
else
{
if ((runData->record || runData->liveData) &&
(runData->recordTimer > runData->recordPeriod - 5))
{
user_Set_LED(BUTTON_CLEAR, ON);
}
else
{
user_Set_LED(BUTTON_CLEAR, OFF);
}
buttonTimer[BUTTON_CLEAR - 1] = 0;
}
if (user_Get_Button(BUTTON_START))
{
runData->record = true;
runData->liveData = false;
}
if (user_Get_Button(BUTTON_STOP))
{
runData->record = false;
runData->liveData = false;
}
if (runData->record || runData->liveData)
{
user_Set_LED(LED_START, ON);
user_Set_LED(LED_STOP, OFF);
}
else
{
user_Set_LED(LED_STOP, ON);
user_Set_LED(LED_START, OFF);
}
}
/**
* Main function of the program. Communications and buttons are continuously
* handled while data is collected according to settings and then stored at
* the prescribed intervals if recording is enabled.
*/
int main (void)
{
init();
// keep track of if batched data sent via GSM today
bool gsmSentData = false;
int i;
bool dataReady = false, recordReady = false;
RunData runData = {false, false, 0, 0, 0};
i = 0;
DataPoint data;
sensor_Reset(&data);
// set the global rate for our river monitoring application
runData.recordPeriod = (unsigned int) MODEM_DATA_GLOBAL_RATE_H << 8;
runData.recordPeriod += (unsigned int) MODEM_DATA_GLOBAL_RATE_L;
data_Clear(); // erase all old data initially
// don't read from settings from EEPROM for our application
// runData.recordPeriod = (unsigned int)data_Read_EEPROM(DATA_GLOBAL_RATE_ADDR_H) << 8;
// runData.recordPeriod += (unsigned int)data_Read_EEPROM(DATA_GLOBAL_RATE_ADDR_L);
if (runData.recordPeriod < MINIMUM_GLOBAL_INTERVAL)
{
runData.recordPeriod = MINIMUM_GLOBAL_INTERVAL;
}
while(1)
{
user_Handle_Buttons(&runData);
// The serial port is now connected to the GSM modem, not the FTDI chip...
// coms_Handle(&runData);
gsm_modem_Comms_Handle(&runData);
dataReady = sensor_Read(&data);
recordReady |= timer_Job_Ready4(&(runData.recordTimer), runData.recordPeriod, &(runData.recordLastTime), false);
if (dataReady && recordReady)
{
if (runData.record)
{
if (data_Write(&data) == ERROR)
{
// since this is an un-monitored system we need to keep trying...
//runData.record = false;
}
// at hours == 12 (noon) we power up the GSM modem and send all the data we have collected
// then we clear EEPROM
if (data.bitpack.data.hours == 12 && !gsmSentData)
{
gsm_modem_Comms_Transmit_Data(&data);
gsmSentData = true;
}
else if (data.bitpack.data.hours == 13)
{
// reset for next day
gsmSentData = false;
}
}
else if (runData.liveData)
{
for (i = 0; i < sizeof(DataPoint); i++) usart_Write(SERIAL, ((unsigned char*)(&data))[i]);
runData.liveData = false;
}
runData.recordTimer = 0;
recordReady = false;
sensor_Reset(&data);
}
timer_Sleep();
}
}
