void showTimeAlarm( uint8_t *bUidPresent, uint8_t *nCardDetected, uint8_t *nCardPrevious)
{
char msg[100];
statoDisplay=6;
Chip_RTC_GetFullTime(&FullTime);
if (statoDisplayP!=6) {
GUI_Clear();
}
int ii=0;
int k=0,c=0,rimanenti=0,soglia=0,dose=0;
for (k=0; k<maxR; k++) {
uint8_t tempTag[4];
for (c=0;c<4;c++){
tempTag[c] = l_tabellaMedicine[k][c];
}
if (confronta_tag(ptrMedic->tag,tempTag)==1) {
rimanenti = l_tabellaMedicine[k][62];
soglia = l_tabellaMedicine[k][64];
dose = l_tabellaMedicine[k][55];
}
}
sprintf( msg, "Assumere: %s", ptrMedic->nome);
GUI_DispStringAt( msg, 0, 20);
sprintf( msg, "Dose: %d pastiglie", dose/4);
GUI_DispStringAt( msg, 0, 40+20*ii);
ii++;
if (ptrMedic->giorniAllaScadenza<30) {
GUI_SetColor(GUI_YELLOW);
sprintf( msg, "Scade entro un mese!");
GUI_DispStringAt( msg, 0, 40+20*ii);
GUI_SetColor(GUI_GREEN);
ii++;
}
if (ptrMedic->avvisare) {
GUI_SetColor(GUI_ORANGE);
sprintf( msg, "Stai per esaurire il medicinale");
GUI_DispStringAt( msg, 0, 40+20*ii);
GUI_SetColor(GUI_GREEN);
ii++;
}
GUI_SetColor(GUI_GREEN);
sprintf( msg, "Rimangono %d pastiglie", rimanenti);
GUI_DispStringAt( msg, 0, 40+20*ii);
ii++;
sprintf( msg, "Soglia di avviso impostata: %d", soglia);
GUI_DispStringAt( msg, 0, 40+20*ii);
showTime();
statoDisplayP=statoDisplay;
empty = 1;
}
void Board_RTC_getTime(uint32_t* hr,uint32_t* min, uint32_t* sec, uint32_t* day, uint32_t* mon, uint32_t* yr,uint32_t* dayOfWeek)
{
RTC_TIME_T rtc;
Chip_RTC_GetFullTime(LPC_RTC, &rtc);
*sec = rtc.time[RTC_TIMETYPE_SECOND];
*min = rtc.time[RTC_TIMETYPE_MINUTE];
*hr = rtc.time[RTC_TIMETYPE_HOUR];
*day = rtc.time[RTC_TIMETYPE_DAYOFMONTH];
*mon = rtc.time[RTC_TIMETYPE_MONTH];
*yr = rtc.time[RTC_TIMETYPE_YEAR];
*dayOfWeek = rtc.time[RTC_TIMETYPE_DAYOFWEEK];
}
/*
* @Brief: Get time from RTC peripheral.
* @param RTC_t rtc: RTC structure
* @return bool_t true (1) if config it is ok
*/
bool_t rtcRead( RTC_t * rtc ){
bool_t ret_val = 1;
RTC_TIME_T rtcTime;
Chip_RTC_GetFullTime(LPC_RTC, &rtcTime);
rtc->sec = rtcTime.time[RTC_TIMETYPE_SECOND];
rtc->min = rtcTime.time[RTC_TIMETYPE_MINUTE];
rtc->hour = rtcTime.time[RTC_TIMETYPE_HOUR];
rtc->wday = rtcTime.time[RTC_TIMETYPE_DAYOFWEEK];
rtc->mday = rtcTime.time[RTC_TIMETYPE_DAYOFMONTH];
rtc->month = rtcTime.time[RTC_TIMETYPE_MONTH];
rtc->year = rtcTime.time[RTC_TIMETYPE_YEAR];
return ret_val;
}
void showTime( /*char *cardType, uint8_t *bUidPresent, uint8_t *nCardDetected, uint8_t *nCardPrevious*/)
{
char msg[100];
Chip_RTC_GetFullTime(&FullTime);
sprintf( msg, "%.2d:%.2d:%.2d %.2d/%.2d/%.4d\r\n", FullTime.time[2],
FullTime.time[1],
FullTime.time[0],
FullTime.time[3],
FullTime.time[6],
FullTime.time[7]);
GUI_SetColor(GUI_WHITE);
GUI_FillRect( 0, 214, 317, 214 );
GUI_SetFont(&GUI_Font24B_ASCII);
GUI_DispStringAt( msg, 60, 215);
GUI_SetColor(GUI_GREEN);
}
/**
* @brief main routine for example_lwip_tcpecho_freertos_18xx43xx
* @return Function should not exit
*/
int main(void)
{
prvSetupHardware();
Chip_RTC_Init();
/*Set current time for RTC 8:59:20PM, 2016-04-11 MONDAY 102*/
FullTime.time[RTC_TIMETYPE_SECOND] = 40;
FullTime.time[RTC_TIMETYPE_MINUTE] = 59;
FullTime.time[RTC_TIMETYPE_HOUR] = 8;
FullTime.time[RTC_TIMETYPE_DAYOFMONTH] = 11;
FullTime.time[RTC_TIMETYPE_DAYOFWEEK] = 1;
FullTime.time[RTC_TIMETYPE_DAYOFYEAR] = 102;
FullTime.time[RTC_TIMETYPE_MONTH] = 04;
FullTime.time[RTC_TIMETYPE_YEAR] = 2016;
Chip_RTC_SetFullTime(&FullTime);
/* Set the RTC to generate an interrupt on each second */
Chip_RTC_CntIncrIntConfig(RTC_AMR_CIIR_IMSEC, ENABLE);
/* Enable matching for alarm for second, minute, hour fields only */
Chip_RTC_AlarmIntConfig(RTC_AMR_CIIR_IMSEC | RTC_AMR_CIIR_IMMIN | RTC_AMR_CIIR_IMHOUR, ENABLE);
/* Enable RTC interrupt in NVIC */
NVIC_EnableIRQ((IRQn_Type) RTC_IRQn);
/* Enable RTC (starts increase the tick counter and second counter register) */
Chip_RTC_Enable(ENABLE);
//DIFFERENZA TRA GIORNI
IP_RTC_TIME_T data1 = FullTime, data2, diffDate;
uint32_t nGiorniDifferenza;
data2.time[RTC_TIMETYPE_SECOND] = 40;
data2.time[RTC_TIMETYPE_MINUTE] = 59;
data2.time[RTC_TIMETYPE_HOUR] = 7;//23;//8;
data2.time[RTC_TIMETYPE_DAYOFMONTH] = 12;
data2.time[RTC_TIMETYPE_DAYOFWEEK] = 2;
data2.time[RTC_TIMETYPE_DAYOFYEAR] = 103;
data2.time[RTC_TIMETYPE_MONTH] = 04;
data2.time[RTC_TIMETYPE_YEAR] = 2016;//2017;
diffDate = differenzaDate(data2, data1);
nGiorniDifferenza = differenzaGiorni(data2, data1);
uint8_t counter = 0;
ptrMedic = inizializzaListaMed();
for(counter = 0; counter < maxR; counter++){
if (l_tabellaMedicine[counter][65]==0) { //se più volte al giorno == 0
if (l_tabellaMedicine[counter][59]==0) {
ptrMedic = inserisciInTestaListaMed(ptrMedic, l_tabellaMedicine[counter]);
} else {
if (l_tabellaMedicine[counter][58] == 0) { //DA ASSUMERE
ptrMedic = inserisciInTestaListaMed(ptrMedic, l_tabellaMedicine[counter]);
l_tabellaMedicine[counter][58] ++;
} else {
l_tabellaMedicine[counter][58] ++;
if (l_tabellaMedicine[counter][58] = l_tabellaMedicine[counter][59]) {
l_tabellaMedicine[counter][58] = 0;
}
}
}
} else {
//conta quante volte prendere la medicina
if (l_tabellaMedicine[counter][65]==1) {
//controlla la ripetizione
Chip_RTC_GetFullTime(&FullTime);
IP_RTC_TIME_T dataIn;
dataIn.time[RTC_TIMETYPE_DAYOFMONTH] = l_tabellaMedicine[counter][43];
dataIn.time[RTC_TIMETYPE_MONTH] = l_tabellaMedicine[counter][44];
dataIn.time[RTC_TIMETYPE_YEAR] = (l_tabellaMedicine[counter][45]<<8) | l_tabellaMedicine[counter][46];
int oraInizio = l_tabellaMedicine[counter][51];
int intervalloOre = l_tabellaMedicine[counter][57];
if (FullTime.time[RTC_TIMETYPE_DAYOFMONTH]==dataIn.time[RTC_TIMETYPE_DAYOFMONTH] && FullTime.time[RTC_TIMETYPE_MONTH]==dataIn.time[RTC_TIMETYPE_MONTH] && FullTime.time[RTC_TIMETYPE_YEAR]==dataIn.time[RTC_TIMETYPE_YEAR]) {
//E' il giorno di inizio e lascio l'ora iniziale invariata
oraInizio = oraInizio;
} else {
int go = 1;
while (go){
if ((oraInizio-intervalloOre)>=0) {
oraInizio = oraInizio-intervalloOre;
} else {
go = 0;
}
}
}
int temp = oraInizio;
int contatore = 1;
while ((temp+intervalloOre) < 24) {
temp = temp+intervalloOre;
contatore++;
}
int c = 0;
IP_RTC_TIME_T oraMed;
oraMed.time[RTC_TIMETYPE_HOUR] = oraInizio;
oraMed.time[RTC_TIMETYPE_MINUTE] = l_tabellaMedicine[counter][52];
oraMed.time[RTC_TIMETYPE_SECOND] = l_tabellaMedicine[counter][53];
for (c=0; c<contatore; c++) {
ptrMedic = inserisciInTestaListaMedOra(ptrMedic, l_tabellaMedicine[counter], oraMed);
oraMed.time[RTC_TIMETYPE_HOUR] += intervalloOre;
}
} else {
//orari custom
int n = l_tabellaMedicine[counter][65];
int c = 0;
IP_RTC_TIME_T oraMed;
oraMed.time[RTC_TIMETYPE_HOUR] = l_tabellaMedicine[counter][51];
oraMed.time[RTC_TIMETYPE_MINUTE] = l_tabellaMedicine[counter][52];
oraMed.time[RTC_TIMETYPE_SECOND] = l_tabellaMedicine[counter][53];
ptrMedic = inserisciInTestaListaMedOra(ptrMedic, l_tabellaMedicine[counter], oraMed);
for (c=0; c<n-1; c++) {
oraMed.time[RTC_TIMETYPE_HOUR] = l_tabellaMedicine[counter][66+3*c];
oraMed.time[RTC_TIMETYPE_MINUTE] = l_tabellaMedicine[counter][67+3*c];
oraMed.time[RTC_TIMETYPE_SECOND] = l_tabellaMedicine[counter][68+3*c];
ptrMedic = inserisciInTestaListaMedOra(ptrMedic, l_tabellaMedicine[counter], oraMed);
}
}
}
}
ptrMedic = ordinamento_lista_med(ptrMedic);
//Inizio dall'orario attuale e non considero tutti i medicinali precedenti in giornata
IP_RTC_TIME_T oraAllarme;
oraAllarme.time[RTC_TIMETYPE_HOUR] = ptrMedic->oraA;
oraAllarme.time[RTC_TIMETYPE_MINUTE] = ptrMedic->minA;
oraAllarme.time[RTC_TIMETYPE_SECOND] = ptrMedic->secA;
while (orarioDopoOrario(FullTime, oraAllarme)) {
ptrMedic = ptrMedic->next;
oraAllarme.time[RTC_TIMETYPE_HOUR] = ptrMedic->oraA;
oraAllarme.time[RTC_TIMETYPE_MINUTE] = ptrMedic->minA;
oraAllarme.time[RTC_TIMETYPE_SECOND] = ptrMedic->secA;
}
FullTime.time[RTC_TIMETYPE_HOUR] = oraAllarme.time[RTC_TIMETYPE_HOUR];//ptrMedic->oraA;
FullTime.time[RTC_TIMETYPE_MINUTE] = oraAllarme.time[RTC_TIMETYPE_MINUTE];//ptrMedic->minA;
FullTime.time[RTC_TIMETYPE_SECOND] = oraAllarme.time[RTC_TIMETYPE_SECOND];//ptrMedic->secA;
Chip_RTC_SetFullAlarmTime(&FullTime);
// CICLO FOR PER LEGGERE TUTTI I BIT DI UN BYTE
// unsigned bit=0, n_bits = 4u, *bits = (unsigned*)malloc(sizeof(unsigned) * n_bits);
// for (bit = 0; bit < n_bits; ++bit, input >>1)
// bits[bit] = input & 1;
uint8_t i;
for (i=0;i<35;i++){
//char t = (char)m1[4+i];
//nomeMed[i]=t;
arrNomiMed[i]=l_tabellaMedicine[0][4+i];
}
nomeMed=&arrNomiMed;
vSemaphoreCreateBinary( xSemaDataAvail );
vSemaphoreCreateBinary( xSemaGUIend );
/* xTaskCreate(vTSCTask, (signed char *) "vTSCTask",
configMINIMAL_STACK_SIZE, NULL, TASK_PRIO_TOUCHSCREEN,
(xTaskHandle *) NULL); */
/* BASIC ONE
xTaskCreate(vLcdTask, (signed char *) "vLCDTask",
configMINIMAL_STACK_SIZE * 4, NULL, TASK_PRIO_LCD,
(xTaskHandle *) NULL); */
xTaskCreate(vLcdTaskNew, (signed char *) "vLCDTaskNew",
configMINIMAL_STACK_SIZE * 4, NULL, TASK_PRIO_LCD,
(xTaskHandle *) NULL);
/* Add another thread for initializing physical interface. This
is delayed from the main LWIP initialization. */
/* xTaskCreate(vSetupIFTask, (signed char *) "SetupIFx",
configMINIMAL_STACK_SIZE, NULL, (tskIDLE_PRIORITY + 1UL),
(xTaskHandle *) NULL); */
xTaskCreate(vSetupPollTask, (signed char *) "SetupPoll",
configMINIMAL_STACK_SIZE*4, NULL, (tskIDLE_PRIORITY + 1UL),
(xTaskHandle *) NULL);
/*
xTaskCreate(vRTCTask, (signed char *) "RTCTask",
configMINIMAL_STACK_SIZE*4, NULL, (tskIDLE_PRIORITY + 2UL),
(xTaskHandle *) NULL);
*/
/* Start the scheduler */
vTaskStartScheduler();
/* Should never arrive here */
return 1;
}
/**
* @brief Main entry point
* @return Nothing
*/
int main(void)
{
RTC_TIME_T FullTime;
SystemCoreClockUpdate();
Board_Init();
fIntervalReached = 0;
fAlarmTimeMatched = 0;
On0 = On1 = false;
Board_LED_Set(2, false);
DEBUGSTR("The RTC operates on a 1 Hz clock.\r\n" \
"Register writes can take up to 2 cycles.\r\n" \
"It will take a few seconds to fully\r\n" \
"initialize it and start it running.\r\n\r\n");
DEBUGSTR("We'll print a timestamp every 5 seconds.\r\n" \
"...and another when the alarm occurs.\r\n");
Chip_RTC_Init(LPC_RTC);
/* Set current time for RTC 2:00:00PM, 2012-10-05 */
FullTime.time[RTC_TIMETYPE_SECOND] = 0;
FullTime.time[RTC_TIMETYPE_MINUTE] = 0;
FullTime.time[RTC_TIMETYPE_HOUR] = 14;
FullTime.time[RTC_TIMETYPE_DAYOFMONTH] = 5;
FullTime.time[RTC_TIMETYPE_DAYOFWEEK] = 5;
FullTime.time[RTC_TIMETYPE_DAYOFYEAR] = 279;
FullTime.time[RTC_TIMETYPE_MONTH] = 10;
FullTime.time[RTC_TIMETYPE_YEAR] = 2012;
Chip_RTC_SetFullTime(LPC_RTC, &FullTime);
/* Set ALARM time for 17 seconds from time */
FullTime.time[RTC_TIMETYPE_SECOND] = 17;
Chip_RTC_SetFullAlarmTime(LPC_RTC, &FullTime);
/* Set the RTC to generate an interrupt on each second */
Chip_RTC_CntIncrIntConfig(LPC_RTC, RTC_AMR_CIIR_IMSEC, ENABLE);
/* Enable matching for alarm for second, minute, hour fields only */
Chip_RTC_AlarmIntConfig(LPC_RTC, RTC_AMR_CIIR_IMSEC | RTC_AMR_CIIR_IMMIN | RTC_AMR_CIIR_IMHOUR, ENABLE);
/* Clear interrupt pending */
Chip_RTC_ClearIntPending(LPC_RTC, RTC_INT_COUNTER_INCREASE | RTC_INT_ALARM);
/* Enable RTC interrupt in NVIC */
NVIC_EnableIRQ((IRQn_Type) RTC_IRQn);
/* Enable RTC (starts increase the tick counter and second counter register) */
Chip_RTC_Enable(LPC_RTC, ENABLE);
/* Loop forever */
while (1) {
if (fIntervalReached) { /* Every 5s */
fIntervalReached = 0;
On1 = (bool) !On1;
Board_LED_Set(1, On1);
/* read and display time */
Chip_RTC_GetFullTime(LPC_RTC, &FullTime);
showTime(&FullTime);
}
if (fAlarmTimeMatched) {
fAlarmTimeMatched = false;
/* announce event */
DEBUGSTR("ALARM triggered!\r\n");
Board_LED_Set(2, true);
/* read and display time */
Chip_RTC_GetFullTime(LPC_RTC, &FullTime);
showTime(&FullTime);
}
}
}
void skynetbase_gps_received_data(char gpsout[], uint8_t gpsoutpos) {
gpsout[gpsoutpos] = 0;
//DBG("%s\n", gpsout);
char delim[] = ",";
// parse message ID
char *str = strtok(gpsout, delim);
if (str == NULL) return; // answer was too short
if (strcmp(str, "$PUBX")) return; // wrong answer type
// parse propietary message identifier
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
if (strcmp(str, "00")) return; // wrong answer type
// parse time
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
if (strlen(str) < 6) return; // wrong time format
memcpy(current_data.time, str, 6);
current_data.time[6] = 0;
// parse latitude
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
current_data.lat = atof(str);
// parse latitude direction
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
current_data.lat_dir = str[0];
// parse longitude
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
current_data.lon = atof(str);
// parse longitude direction
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
current_data.lon_dir = str[0];
// parse altitude direction
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
current_data.alt = atof(str);
// parse navigation status
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
current_data.status = '0';
if (!(strcmp(str, "G3"))) current_data.status = 'G';
else if (!(strcmp(str, "NF"))) current_data.status = 'N';
// parse horizontal accuracy
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
current_data.accuracy_horizontal = atof(str);
// parse vertical accuracy
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
current_data.accuracy_vertical = atof(str);
/*
// ignore some data
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
// ignore some data
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
// ignore some data
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
// ignore some data
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
// ignore some data
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
// ignore some data
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
// ignore some data
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
// parse number of gps satellites // just works if no empty fields
str = strtok(NULL, delim);
if (str == NULL) return; // answer was too short
current_data.satellites = atoi(str);
*/
current_data.satellites = 0;
events_enqueue(EVENT_GPS_DATA_AVAILABLE, NULL);
// update RTC
Chip_RTC_GetFullTime(LPC_RTC, &FullTime);
sscanf(current_data.time, "%02d%02d%02d", &(FullTime.time[RTC_TIMETYPE_HOUR]),
&(FullTime.time[RTC_TIMETYPE_MINUTE]), &(FullTime.time[RTC_TIMETYPE_SECOND]));
Chip_RTC_SetFullTime(LPC_RTC, &FullTime);
//DBG("Lat: %f (%c)\n", current_data.lat, current_data.lat_dir);
//DBG("Lon: %f (%c)\n", current_data.lon, current_data.lon_dir);
}
