/*
* Application entry point.
*/
int main(void) {
msg_t status = RDY_TIMEOUT;
halInit();
chSysInit();
chBSemInit(&alarm_sem, TRUE);
rtcGetTime(&RTCD1, ×pec);
alarmspec.tv_sec = timespec.tv_sec + RTC_ALARMPERIOD;
rtcSetAlarm(&RTCD1, 0, &alarmspec);
rtcSetCallback(&RTCD1, rtc_cb);
while (TRUE) {
/* Wait until alarm callback signaled semaphore.*/
status = chBSemWaitTimeout(&alarm_sem, S2ST(RTC_ALARMPERIOD + 10));
if (status == RDY_TIMEOUT) {
chSysHalt();
}
else {
rtcGetTime(&RTCD1, ×pec);
alarmspec.tv_sec = timespec.tv_sec + RTC_ALARMPERIOD;
rtcSetAlarm(&RTCD1, 0, &alarmspec);
}
}
return 0;
}
//---------------------------------------------------------------------------------
void VblankHandler(void) {
//---------------------------------------------------------------------------------
u32 i;
uint8 ct[sizeof(IPC->time.curtime)];
//sound code :)
TransferSound *snd = IPC->soundData;
IPC->soundData = 0;
rtcGetTime((uint8 *)ct);
BCDToInteger((uint8 *)&(ct[1]), 7);
for(i=0; i<sizeof(ct); i++) {
IPC->time.curtime[i] = ct[i];
}
if (0 != snd) {
for (i=0; i<snd->count; i++) {
s32 chan = getFreeSoundChannel();
if (chan >= 0) {
startSound(snd->data[i].rate, snd->data[i].data, snd->data[i].len, chan, snd->data[i].vol, snd->data[i].pan, snd->data[i].format);
}
}
}
Wifi_Update(); // update wireless in vblank
}
/**
* @brief Gets raw time from RTC and converts it to canonicalized format.
*
* @param[in] rtcp pointer to RTC driver structure
* @param[out] timp pointer to a @p tm structure as defined in time.h
*
* @api
*/
void rtcGetTimeTm(RTCDriver *rtcp, struct tm *timp) {
RTCTime timespec = {0,0};
rtcGetTime(rtcp, ×pec);
if (timp != NULL) /* this comparison needed to avoid compiler warning */
timp = localtime((time_t *)&(timespec.tv_sec));
}
static THD_FUNCTION(ThreadTIME, arg)
{
(void)arg;
chRegSetThreadName("Time");
struct tm timp;
char str_date[100];
while (true) {
if(updateSettingTime) {
setLabelTime(ghlblDateTime, true);
}
rtcGetTime(RTC_DRIVER, ×pec);
rtcConvertDateTimeToStructTm(×pec, &timp,0);
//https://www.iar.com/support/resources/articles/using-c-standard-library-time-and-clock-functions/
//http://www.cplusplus.com/forum/general/57329/
int timeElap = difftime(mktime(&timp),mktime(&startTime));
uint8_t hour = timeElap/3600;
uint16_t second = timeElap % 3600;
uint8_t minute = second/60;
second %= 60;
//timp.tm_sec = second;
//timp.tm_min = minute;
//timp.tm_hour = hour;
//strftime(str_date, sizeof(str_date), "%X", &timp); //%x for date http://www.tutorialspoint.com/c_standard_library/c_function_strftime.htm
snprintf(str_date, 9, "%02d:%02d:%02d", hour, minute, second);
gwinSetText(ghlblElapsed, str_date, TRUE);
chThdSleepMilliseconds(1000);
}
}
NumbersStationView::NumbersStationView(
NavigationView& nav,
TransmitterModel& transmitter_model
) : transmitter_model(transmitter_model)
{
uint8_t m, d, dayofweek;
uint16_t y;
add_children({ {
&text_title,
&button_exit
} });
rtc::RTC datetime;
rtcGetTime(&RTCD1, &datetime);
// Thanks, Sakamoto-sama !
y = datetime.year();
m = datetime.month();
d = datetime.day();
y -= m < 3;
dayofweek = (y + y/4 - y/100 + y/400 + month_table[m-1] + d) % 7;
text_title.set(day_of_week[dayofweek]);
button_exit.on_select = [&nav](Button&){
nav.pop();
};
}
cell pawn_rtc( AMX * amx, const cell * params )
{
(void)amx;
(void)params;
RTCTime rtc;
rtcGetTime( &RTCD1, &rtc );
return rtc.tv_sec * 1000 + rtc.tv_msec;
}
static time_t rtc_get_time_unix(uint32_t *tv_msec) {
RTCDateTime timespec;
struct tm tim;
rtcGetTime(&RTCD1, ×pec);
rtcConvertDateTimeToStructTm(×pec, &tim, tv_msec);
return mktime(&tim);
}
/**
* @brief Gets raw time from RTC and converts it to canonicalized format.
*
* @param[in] rtcp pointer to RTC driver structure
* @param[out] timp pointer to a @p tm structure as defined in time.h
*
* @api
*/
void rtcGetTimeTm(RTCDriver *rtcp, struct tm *timp) {
#if STM32_RTC_HAS_SUBSECONDS
RTCTime timespec = {0,0,FALSE,0};
#else
RTCTime timespec = {0,0,FALSE};
#endif
rtcGetTime(rtcp, ×pec);
stm32_rtc_bcd2tm(timp, ×pec);
}
int _gettimeofday(struct timeval *tv)
{
RTCDateTime timespec;
rtcGetTime(&RTCD1, ×pec);
uint64_t t = (uint64_t)timespec.millisecond * 1000000;/*__your_system_time_function_here__();*/ // get uptime in nanoseconds
tv->tv_sec = t / 1000000000; // convert to seconds
tv->tv_usec = ( t % 1000000000 ) / 1000; // get remaining microseconds
chprintf((BaseSequentialStream *)&itm_port, "timespec: time %d usec. %d sec. %d\n", t, tv->tv_usec, tv->tv_sec);
return 0; // return non-zero for error
} // end _gettimeofday()
/**
* @brief Gets raw time from RTC and converts it to unix format.
*
* @param[in] rtcp pointer to RTC driver structure
* @return Unix time value in microseconds.
*
* @api
*/
uint64_t rtcGetTimeUnixUsec(RTCDriver *rtcp) {
#if STM32_RTC_HAS_SUBSECONDS
uint64_t result = 0;
RTCTime timespec = {0,0};
rtcGetTime(rtcp, ×pec);
result = (uint64_t)timespec.tv_sec * 1000000;
return result + timespec.tv_msec * 1000;
#else
return (uint64_t)rtcGetTimeUnixSec(rtcp) * 1000000;
#endif
}
/**
* Reads the time from the STM32 internal RTC
* @return Date in Julian calendar format
*/
void getTime(ptime_t *date) {
RTCDateTime timespec;
rtcGetTime(&RTCD1, ×pec);
date->year = timespec.year + 2000;
date->month = timespec.month;
date->day = timespec.day;
date->hour = timespec.millisecond / 3600000;
date->minute = (timespec.millisecond%3600000) / 60000;
date->second = (timespec.millisecond / 1000) % 60;
date->millisecond = timespec.millisecond % 1000;
}
/**
* @brief Gets raw time from RTC and converts it to unix format.
*
* @param[in] rtcp pointer to RTC driver structure
* @return Unix time value in seconds.
*
* @api
*/
time_t rtcGetTimeUnixSec(RTCDriver *rtcp) {
#if STM32_RTC_HAS_SUBSECONDS
RTCTime timespec = {0,0,FALSE,0};
#else
RTCTime timespec = {0,0,FALSE};
#endif
struct tm timp;
rtcGetTime(rtcp, ×pec);
stm32_rtc_bcd2tm(&timp, ×pec);
return mktime(&timp);
}
/**
* @brief Gets raw time from RTC and converts it to unix format.
*
* @param[in] rtcp pointer to RTC driver structure
* @return Unix time value in microseconds.
*
* @api
*/
uint64_t rtcGetTimeUnixUsec(RTCDriver *rtcp) {
#if STM32_RTC_HAS_SUBSECONDS
uint64_t result = 0;
RTCTime timespec = {0,0,FALSE,0};
struct tm timp;
rtcGetTime(rtcp, ×pec);
stm32_rtc_bcd2tm(&timp, ×pec);
result = (uint64_t)mktime(&timp) * 1000000;
return result + timespec.tv_msec * 1000;
#else
return (uint64_t)rtcGetTimeUnixSec(rtcp) * 1000000;
#endif
}
static bool_t stm32_get_datetime(TDateTime *dt)
{
if(dt){
rtcGetTime(&RTCD1,&rt);
datetime_convert(rt.tv_sec,dt);
#if 0
dt->sec = mytime.tm_sec;
dt->min = mytime.tm_min;
dt->hour = mytime.tm_hour;
dt->day = mytime.tm_mday;
dt->mon = mytime.tm_mon;
dt->year = mytime.tm_year;
#endif
return TRUE;
}
return FALSE;
}
int main(void) {
halInit();
chSysInit();
chThdCreateStatic(blinkWA, sizeof(blinkWA), NORMALPRIO, blink_thd, NULL);
/* set alarm in near future */
rtcGetTime(&RTCD1, ×pec);
alarmspec.tv_sec = timespec.tv_sec + 30;
rtcSetAlarm(&RTCD1, 0, &alarmspec);
while (TRUE){
chThdSleepSeconds(10);
chSysLock();
/* going to anabiosis*/
PWR->CR |= (PWR_CR_PDDS | PWR_CR_LPDS | PWR_CR_CSBF | PWR_CR_CWUF);
SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
__WFI();
}
return 0;
}
/**
* Reset the time to now
*
* @param utc a pointer to the time structure
* @param present a pointer to a present field. when non-NULL then the UTCDATE
* and UTCTIME flags are set in it.
*/
void nmea_time_now(nmeaTIME *utc, uint32_t * present) {
struct tm tt;
RTCDateTime timespec;
uint32_t tv_msec;
NMEA_ASSERT(utc);
rtcGetTime(&RTCD1, ×pec);
rtcConvertDateTimeToStructTm(×pec, &tt, &tv_msec);
utc->year = tt.tm_year;
utc->mon = tt.tm_mon;
utc->day = tt.tm_mday;
utc->hour = tt.tm_hour;
utc->min = tt.tm_min;
utc->sec = tt.tm_sec;
utc->hsec = (tv_msec / 10);
if (present) {
nmea_INFO_set_present(present, UTCDATE | UTCTIME);
}
}
void setLabelTime(GHandle gh, bool timeDate)
{
struct tm timp;
char str_date[100];
rtcGetTime(RTC_DRIVER, ×pec);
rtcConvertDateTimeToStructTm(×pec, &timp,0);
if (timeDate) {
if(use12HR)
strftime(str_date, sizeof(str_date), "%x-%r", &timp);
else
strftime(str_date, sizeof(str_date), "%x-%X", &timp); //%x for date http://www.tutorialspoint.com/c_standard_library/c_function_strftime.htm
//chprintf((BaseSequentialStream*)USB_SERIAL_DRIVER, "%s\r\n", str_date);
gwinSetText(gh, str_date, TRUE);
} else {
if(use12HR)
strftime(str_date, sizeof(str_date), "%r", &timp);
else
strftime(str_date, sizeof(str_date), "%X", &timp);
gwinSetText(gh, str_date, TRUE);
}
}
void sp5K_readFunction(void)
{
u08 devId, address, regValue, pin, channel, pcbChannel, adcChannel;
u08 length = 10;
s08 retS;
u08 mcp_address;
RtcTimeType rtcDateTime;
u08 i;
u16 adcRetValue;
char eeRdBuffer[EERDBUFLENGHT];
u16 eeAddress;
u08 pos;
frameDataType rdFrame;
u16 recCount;
double I,M,D;
u08 bdGetStatus;
u16 rcdIndex;
u08 b[9];
memset( cmd_printfBuff, NULL, CHAR128);
makeargv();
// RTC
// Lee la hora del RTC.
if (!strcmp_P( strupr(argv[1]), PSTR("RTC\0"))) {
retS = rtcGetTime(&rtcDateTime);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("%02d/%02d/%04d "),rtcDateTime.day,rtcDateTime.month, rtcDateTime.year );
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("%02d:%02d:%02d\r\n\0"),rtcDateTime.hour,rtcDateTime.min, rtcDateTime.sec );
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DCD
if (!strcmp_P( strupr(argv[1]), PSTR("DCD\0"))) {
retS = MCP_queryDcd(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DCD ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DCD OFF\r\n\0")); }
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// RI
if (!strcmp_P( strupr(argv[1]), PSTR("RI\0"))) {
retS = MCP_queryRi(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("RI ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("RI OFF\r\n\0")); }
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DIN0
if (!strcmp_P( strupr(argv[1]), PSTR("DIN0\0"))) {
retS = MCP_queryDin0(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DIN0 %d\r\n\0"), pin);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DIN1
if (!strcmp_P( strupr(argv[1]), PSTR("DIN1\0"))) {
retS = MCP_queryDin1(&pin);
if (retS ) {
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DIN1 %d\r\n\0"), pin);
} else {
snprintf_P( cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(cmd_printfBuff);
return;
}
// TERMSW
if (!strcmp_P( strupr(argv[1]), PSTR("TERMSW\0"))) {
retS = MCP_queryTermPwrSw(&pin);
if (retS ) {
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("TERMSW ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("TERMSW OFF\r\n\0")); }
} else {
snprintf_P( cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// MCP
// read mcp 0|1|2 addr
if (!strcmp_P( strupr(argv[1]), PSTR("MCP\0"))) {
devId = atoi(argv[2]);
address = atoi(argv[3]);
if ( devId == 0 ) { mcp_address = MCP_ADDR0; }
if ( devId == 1 ) { mcp_address = MCP_ADDR1; }
if ( devId == 2 ) { mcp_address = MCP_ADDR2; }
retS = MCP_read( address, mcp_address, 1, ®Value);
if (retS ) {
// Convierto el resultado a binario.
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
strcpy(b,byte_to_binary(regValue));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("mcp %d: reg=[%d] data=[0X%03x] [%s] \r\n\0"),devId, address,regValue, b);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// *****************************************************************************************************
// SOLO PARA USO EN MODO SERVICE.
if ( systemVars.wrkMode != WK_SERVICE) {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("WARNING: Debe pasar a modo SERVICE !!!\r\n"));
sp5K_printStr(&cmd_printfBuff);
return;
}
// ADC
// read adc channel
// El canal es de 0..3/0..7 y representa el canal fisico en el conector, NO
// EL PROPIO CANAL DEL A/D
if (!strcmp_P( strupr(argv[1]), PSTR("ADC\0"))) {
pcbChannel = atoi(argv[2]);
if ( NRO_CHANNELS == 3 ) {
switch (pcbChannel ) {
case 0:
adcChannel = 3;
break;
case 1:
adcChannel = 5;
break;
case 2:
adcChannel = 7;
break;
case 3:
adcChannel = 1; // Bateria
break;
}
}
retS = ADS7828_convert( adcChannel, &adcRetValue );
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("adc_%d(%d)=[%d]\r\n\0"),pcbChannel, adcChannel, adcRetValue);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// FRAME
// Lee todos los canales y presenta el frame.
if (!strcmp_P( strupr(argv[1]), PSTR("FRAME\0"))) {
SIGNAL_tkDataReadFrame();
return;
}
// EEPROM
// read ee addr length
if (!strcmp_P( strupr(argv[1]), PSTR("EE\0"))) {
eeAddress = atol(argv[2]);
length = atoi(argv[3]);
// Buffer control.
if (length > EERDBUFLENGHT) {
length = EERDBUFLENGHT;
}
retS = EE_read( eeAddress, length, &eeRdBuffer);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("addr=[%d] data=[%s]\r\n\0"),eeAddress,eeRdBuffer);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// MEMORY DUMP
if (!strcmp_P( strupr(argv[1]), PSTR("MEMORY\0"))) {
recCount = 0;
for (;;) {
vTaskDelay( (portTickType)(50 / portTICK_RATE_MS) );
rcdIndex = BD_getRDptr();
bdGetStatus = BD_get( &rdFrame, rcdIndex);
// BD vacia
if (bdGetStatus == 0) {
break;
}
recCount++;
// Armo el frame
memset( cmd_printfBuff, NULL, CHAR128);
pos = 0;
pos = snprintf_P( &cmd_printfBuff, CHAR128, PSTR("(%d/%d)>" ), recCount, rcdIndex);
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR( "%04d%02d%02d,"),rdFrame.rtc.year,rdFrame.rtc.month, rdFrame.rtc.day );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%02d%02d%02d,"),rdFrame.rtc.hour,rdFrame.rtc.min, rdFrame.rtc.sec );
// Valores analogicos
for ( channel = 0; channel < NRO_CHANNELS; channel++) {
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%s=%.2f"),systemVars.aChName[channel],rdFrame.analogIn[channel] );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR(","));
}
// Valores digitales.
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%s=%.2f,"), systemVars.dChName[0], rdFrame.din0_pCount );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR( "%s=%.2f"), systemVars.dChName[1], rdFrame.din0_pCount );
#ifdef CHANNELS_3
// Bateria
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR(",bt=%.2f"), rdFrame.batt );
#endif
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR("<\r\n\0") );
// Imprimo
sp5K_printStr(&cmd_printfBuff);
BD_delete(-1);
taskYIELD();
}
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n\0"));
sp5K_printStr(&cmd_printfBuff);
return;
}
// CMD NOT FOUND
if (xSemaphoreTake( sem_CmdUart, MSTOTAKECMDUARTSEMPH ) == pdTRUE ) {
rprintfProgStrM(CMD_UART, "ERROR\r\n");
rprintfProgStrM(CMD_UART, "CMD NOT DEFINED\r\n");
xSemaphoreGive( sem_CmdUart );
}
return;
}
void SP5K_statusFunction(void)
{
RtcTimeType rtcDateTime;
u08 pos, channel;
u16 dialTimer;
u08 mStatus;
frameDataType frame;
u08 gprsState, gprsSubState, dataState;
rtcGetTime(&rtcDateTime);
getDataFrame(&frame);
dialTimer = getTimeToNextDial();
memset( &cmd_printfBuff, '\0', CHAR128);
if (xSemaphoreTake( sem_CmdUart, MSTOTAKECMDUARTSEMPH ) == pdTRUE ) {
snprintf_P( cmd_printfBuff,CHAR128,PSTR("\r\nSpymovil %s %s\0"), SP5K_MODELO, SP5K_VERSION);
rprintfStr(CMD_UART, cmd_printfBuff );
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" %d-%s-%s\0"), NRO_CHANNELS, EE_TYPE, FTYPE);
rprintfStr(CMD_UART, cmd_printfBuff );
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" %s %s\r\n\0"), SP5K_REV, SP5K_DATE );
rprintfStr(CMD_UART, cmd_printfBuff );
/* DlgId */
snprintf_P( cmd_printfBuff,CHAR128,PSTR("dlgid: %s\r\n\0"), systemVars.dlgId );
rprintfStr(CMD_UART, cmd_printfBuff );
/* Fecha y Hora */
snprintf_P( cmd_printfBuff,CHAR128,PSTR("rtc: %02d/%02d/%04d \0"),rtcDateTime.day,rtcDateTime.month, rtcDateTime.year );
rprintfStr(CMD_UART, cmd_printfBuff );
snprintf_P( cmd_printfBuff,CHAR128,PSTR("%02d:%02d:%02d\r\n\0"),rtcDateTime.hour,rtcDateTime.min, rtcDateTime.sec );
rprintfStr(CMD_UART, cmd_printfBuff );
// SERVER ---------------------------------------------------------------------------------------
snprintf_P( cmd_printfBuff,CHAR128,PSTR(">Server:\r\n\0"));
rprintfStr(CMD_UART, cmd_printfBuff );
/* APN */
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" apn: %s\r\n\0"), systemVars.apn );
rprintfStr(CMD_UART, cmd_printfBuff );
/* SERVER IP:SERVER PORT */
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" server ip:port: %s:%s\r\n\0"), systemVars.serverAddress,systemVars.serverPort );
rprintfStr(CMD_UART, cmd_printfBuff );
/* SERVER SCRIPT */
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" server script: %s\r\n\0"), systemVars.serverScript );
rprintfStr(CMD_UART, cmd_printfBuff );
/* SERVER PASSWD */
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" passwd: %s\r\n\0"), systemVars.passwd );
rprintfStr(CMD_UART, cmd_printfBuff );
// MODEM ---------------------------------------------------------------------------------------
snprintf_P( cmd_printfBuff,CHAR128,PSTR(">Modem:\r\n\0"));
rprintfStr(CMD_UART, cmd_printfBuff );
/* Modem status */
mStatus = getModemStatus();
switch (mStatus) {
case M_OFF:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" modem: OFF\r\n\0"));
break;
case M_OFF_IDLE:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" modem: OFF Idle\r\n\0"));
break;
case M_ON_CONFIG:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" modem: ON & configurating.\r\n\0"));
break;
case M_ON_READY:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" modem: ON & ready(apn,ip).\r\n\0"));
break;
default:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" modem: ERROR\r\n\0"));
break;
}
rprintfStr(CMD_UART, cmd_printfBuff );
/* DLGIP */
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" dlg ip: %s\r\n\0"), systemVars.dlgIp );
rprintfStr(CMD_UART, cmd_printfBuff );
/* CSQ */
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" signalQ: csq=%d, dBm=%d\r\n\0"), systemVars.csq, systemVars.dbm );
rprintfStr(CMD_UART, cmd_printfBuff );
// DCD/RI/TERMSW
if ( systemVars.dcd == 0 ) { pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR(" pines: dcd=ON,\0")); }
if ( systemVars.dcd == 1 ) { pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR(" pines: dcd=OFF,\0"));}
if ( systemVars.ri == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("ri=ON,\0")); }
if ( systemVars.ri == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("ri=OFF,\0"));}
if ( systemVars.termsw == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("term=ON\r\n\0")); }
if ( systemVars.termsw == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("term=OFF\r\n\0"));}
rprintfStr(CMD_UART, cmd_printfBuff );
// SYSTEM ---------------------------------------------------------------------------------------
snprintf_P( cmd_printfBuff,CHAR128,PSTR(">System:\r\n\0"));
rprintfStr(CMD_UART, cmd_printfBuff );
/* Memoria */
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" memory: wrPtr=%d, rdPtr=%d, usedRec=%d, freeRecs=%d\r\n\0"), BD_getWRptr(), BD_getRDptr(), BD_getRcsUsed(), BD_getRcsFree() );
rprintfStr(CMD_UART, cmd_printfBuff );
/* WRK mode (NORMAL / SERVICE) */
switch (systemVars.wrkMode) {
case WK_NORMAL:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" wrkmode: normal\r\n\0"));
break;
case WK_SERVICE:
snprintf_P( &cmd_printfBuff,CHAR128,PSTR(" wrkmode: service\r\n\0"));
break;
case WK_MONITOR:
snprintf_P( &cmd_printfBuff,CHAR128,PSTR(" wrkmode: monitor\r\n\0"));
break;
default:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" wrkmode: ERROR\r\n\0"));
break;
}
rprintfStr(CMD_UART, cmd_printfBuff );
/* PWR mode (CONTINUO / DISCRETO) */
switch (systemVars.pwrMode) {
case PWR_CONTINUO:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" pwrmode: continuo\r\n\0"));
break;
case PWR_DISCRETO:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" pwrmode: discreto\r\n\0"));
break;
default:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" pwrmode: ERROR\r\n\0"));
break;
}
rprintfStr(CMD_UART, cmd_printfBuff );
#ifdef CHANNELS_3
/* Consigna */
switch (systemVars.consigna.tipo) {
case CONS_NONE:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" consigna: none\r\n\0"));
break;
case CONS_DOBLE:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" consigna: doble (dia->%02d:%02d, noche->%02d:%02d)\r\n\0"), systemVars.consigna.hh_A,systemVars.consigna.mm_A,systemVars.consigna.hh_B,systemVars.consigna.mm_B );
break;
default:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" consigna: ERROR\r\n\0"));
break;
}
rprintfStr(CMD_UART, cmd_printfBuff );
#endif
/* Timers */
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" timerPoll: %d/%d\r\n\0"),systemVars.timerPoll, getTimeToNextPoll() );
rprintfStr(CMD_UART, cmd_printfBuff );
if (systemVars.pwrMode == PWR_CONTINUO ) {
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR(" timerDial: -1(%d)/\0"),systemVars.timerDial );
} else {
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR(" timerDial: %d/\0"),systemVars.timerDial );
}
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("%d\r\n\0"), dialTimer );
rprintfStr(CMD_UART, cmd_printfBuff );
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" khTimer: %d\r\n\0"),houseKeepingTimer );
rprintfStr(CMD_UART, cmd_printfBuff );
// Debug Options.
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR(" debugLevel: \0"));
if ( systemVars.debugLevel == D_NONE) {
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("none") );
} else {
if ( (systemVars.debugLevel & D_DATA) != 0) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("+data")); }
if ( (systemVars.debugLevel & D_GPRS) != 0) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("+gprs")); }
if ( (systemVars.debugLevel & D_BD) != 0) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("+bd")); }
if ( (systemVars.debugLevel & D_I2C) != 0) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("+i2c")); }
if ( (systemVars.debugLevel & D_DIGITAL) != 0) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("+digital")); }
}
snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("\r\n\0"));
rprintfStr(CMD_UART, cmd_printfBuff );
// Log Options
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR(" logLevel: \0"));
if ( systemVars.logLevel == LOG_NONE) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("none")); }
if ( systemVars.logLevel == LOG_INFO) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("info")); }
if ( systemVars.logLevel == LOG_WARN) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("warn")); }
if ( systemVars.logLevel == LOG_ALERT) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("alert")); }
snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("\r\n\0"));
rprintfStr(CMD_UART, cmd_printfBuff );
getStatusGprsSM( &gprsState, &gprsSubState);
getStatusDataSM( &dataState );
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" tkGprs:%d/%d, tkData:%d\r\n\0"), gprsState, gprsSubState, dataState);
rprintfStr(CMD_UART, cmd_printfBuff );
// CONFIG ---------------------------------------------------------------------------------------
snprintf_P( cmd_printfBuff,CHAR128,PSTR(">Config:\r\n\0"));
rprintfStr(CMD_UART, cmd_printfBuff );
/* Configuracion del sistema */
switch (mcpDevice) {
case MCP23008:
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" analog=%d, digital=2.\r\n\0"),NRO_CHANNELS);
break;
case MCP23018:
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR(" analog=%d, digital=2, valves=4.\r\n\0"),NRO_CHANNELS);
break;
default:
snprintf_P( cmd_printfBuff,CHAR128,PSTR("ERROR !! No analog system detected\r\n\0"));
break;
}
rprintfStr(CMD_UART, cmd_printfBuff );
#ifdef CHANNELS_3
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" batt{0-15V}\r\n\0"));
rprintfStr(CMD_UART, cmd_printfBuff );
#endif
for ( channel = 0; channel < NRO_CHANNELS; channel++) {
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" a%d{%d-%dmA/%d-%d, %.2f/%.2f}(%s)\r\n\0"),channel, systemVars.Imin[channel],systemVars.Imax[channel],systemVars.Mmin[channel],systemVars.Mmax[channel], systemVars.offmmin[channel], systemVars.offmmax[channel], systemVars. aChName[channel] );
rprintfStr(CMD_UART, cmd_printfBuff );
}
/* Configuracion de canales digitales */
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" d0{%.2f p/p} (%s)\r\n\0"), systemVars.magPP[0],systemVars.dChName[0]);
rprintfStr(CMD_UART, cmd_printfBuff );
snprintf_P( cmd_printfBuff,CHAR128,PSTR(" d1{%.2f p/p} (%s)\r\n\0"), systemVars.magPP[1],systemVars.dChName[1]);
rprintfStr(CMD_UART, cmd_printfBuff );
// VALUES ---------------------------------------------------------------------------------------
snprintf_P( cmd_printfBuff,CHAR128,PSTR(">Values:\r\n\0"));
rprintfStr(CMD_UART, cmd_printfBuff );
pos = 0;
// Armo el frame
memset( &cmd_printfBuff, NULL, CHAR128);
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR( " %04d%02d%02d,"),frame.rtc.year,frame.rtc.month, frame.rtc.day );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%02d%02d%02d,"),frame.rtc.hour,frame.rtc.min, frame.rtc.sec );
// Valores analogicos
for ( channel = 0; channel < NRO_CHANNELS; channel++) {
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%s=%.2f,"),systemVars.aChName[channel],frame.analogIn[channel] );
}
// Valores digitales.
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%sP=%.2f,"),systemVars.dChName[0], frame.din0_pCount );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR( "%sP=%.2f"), systemVars.dChName[1], frame.din1_pCount );
#ifdef CHANNELS_3
// Bateria
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR(",bt=%.2f%"),frame.batt );
#endif
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR("\r\n\0") );
// Imprimo
rprintfStr(CMD_UART, &cmd_printfBuff );
xSemaphoreGive( sem_CmdUart );
}
}
static void rtcRecv()
{
//INFO("RTC Read command 0x%02X\n", (rtc.cmd >> 1));
memset(&rtc.data[0], 0, sizeof(rtc.data));
switch (rtc.cmd >> 1)
{
case 0: // status register 1
//INFO("RTC: read regstatus1 (0x%02X)\n", rtc.regStatus1);
rtc.regStatus1 &= 0x0F;
rtc.data[0] = rtc.regStatus1;
//rtc.regStatus1 &= 0x7F;
break;
case 1: // status register 2
//INFO("RTC: read regstatus2 (0x%02X)\n", rtc.regStatus1);
rtc.data[0] = rtc.regStatus2;
break;
case 2: // date & time
{
//INFO("RTC: read date & time\n");
DateTime tm = rtcGetTime();
rtc.data[0] = toBCD(tm.get_Year() % 100);
rtc.data[1] = toBCD(tm.get_Month());
rtc.data[2] = toBCD(tm.get_Day());
//zero 24-apr-2010 - this is nonsense.
//but it is so wrong, someone mustve thought they knew what they were doing, so i am leaving it...
//rtc.data[3] = (tm.tm_wday + 6) & 7;
//if (rtc.data[3] == 7) rtc.data[3] = 6;
//do this instead (gbatek seems to say monday=0 but i don't think that is right)
//0=sunday is necessary to make animal crossing behave
//maybe it means "custom assignment" can be specified by the game
rtc.data[3] = tm.get_DayOfWeek();
int hour = tm.get_Hour();
if (!(rtc.regStatus1 & 0x02)) hour %= 12;
rtc.data[4] = ((hour < 12) ? 0x00 : 0x40) | toBCD(hour);
rtc.data[5] = toBCD(tm.get_Minute());
rtc.data[6] = toBCD(tm.get_Second());
break;
}
case 3: // time
{
//INFO("RTC: read time\n");
DateTime tm = rtcGetTime();
int hour = tm.get_Hour();
if (!(rtc.regStatus1 & 0x02)) hour %= 12;
rtc.data[0] = ((hour < 12) ? 0x00 : 0x40) | toBCD(hour);
rtc.data[1] = toBCD(tm.get_Minute());
rtc.data[2] = toBCD(tm.get_Second());
break;
}
case 4: // freq/alarm 1
/*if (cmdBitsSize[0x04] == 8)
INFO("RTC: read INT1 freq\n");
else
INFO("RTC: read INT1 alarm1\n");*/
//NDS_makeARM7Int(7);
break;
case 5: // alarm 2
//INFO("RTC: read alarm 2\n");
break;
case 6: // clock adjust
//INFO("RTC: read clock adjust\n");
rtc.data[0] = rtc.regAdjustment;
break;
case 7: // free register
//INFO("RTC: read free register\n");
rtc.data[0] = rtc.regFree;
break;
}
}
static void rtcRecv()
{
//INFO("RTC Read command 0x%02X\n", (rtc.cmd >> 1));
memset(&rtc.data[0], 0, sizeof(rtc.data));
switch (rtc.cmd >> 1)
{
case 0: // status register 1
//INFO("RTC: read regstatus1 (0x%02X)\n", rtc.regStatus1);
rtc.regStatus1 &= 0x0F;
rtc.data[0] = rtc.regStatus1;
//rtc.regStatus1 &= 0x7F;
break;
case 1: // status register 2
//INFO("RTC: read regstatus2 (0x%02X)\n", rtc.regStatus1);
rtc.data[0] = rtc.regStatus2;
break;
case 2: // date & time
{
//INFO("RTC: read date & time\n");
struct tm tm = rtcGetTime();
rtc.data[0] = toBCD(tm.tm_year % 100);
rtc.data[1] = toBCD(tm.tm_mon + 1);
rtc.data[2] = toBCD(tm.tm_mday);
rtc.data[3] = (tm.tm_wday + 7) & 7;
if (rtc.data[3] == 7) rtc.data[3] = 6;
if (!(rtc.regStatus1 & 0x02)) tm.tm_hour %= 12;
rtc.data[4] = ((tm.tm_hour < 12) ? 0x00 : 0x40) | toBCD(tm.tm_hour);
rtc.data[5] = toBCD(tm.tm_min);
rtc.data[6] = toBCD(tm.tm_sec);
break;
}
case 3: // time
{
//INFO("RTC: read time\n");
struct tm tm = rtcGetTime();
if (!(rtc.regStatus1 & 0x02)) tm.tm_hour %= 12;
rtc.data[0] = ((tm.tm_hour < 12) ? 0x00 : 0x40) | toBCD(tm.tm_hour);
rtc.data[1] = toBCD(tm.tm_min);
rtc.data[2] = toBCD(tm.tm_sec);
break;
}
case 4: // freq/alarm 1
/*if (cmdBitsSize[0x04] == 8)
INFO("RTC: read INT1 freq\n");
else
INFO("RTC: read INT1 alarm1\n");*/
//NDS_makeARM7Int(7);
break;
case 5: // alarm 2
//INFO("RTC: read alarm 2\n");
break;
case 6: // clock adjust
//INFO("RTC: read clock adjust\n");
rtc.data[0] = rtc.regAdjustment;
break;
case 7: // free register
//INFO("RTC: read free register\n");
rtc.data[0] = rtc.regFree;
break;
}
}
/**
* @brief Gets raw time from RTC and converts it to unix format.
*
* @param[in] rtcp pointer to RTC driver structure
* @return Unix time value in seconds.
*
* @api
*/
time_t rtcGetTimeUnixSec(RTCDriver *rtcp) {
RTCTime timespec = {0,0};
rtcGetTime(rtcp, ×pec);
return timespec.tv_sec;
}
/**
* @brief Gets raw time from RTC and converts it to canonicalized format.
*
* @param[in] rtcp pointer to RTC driver structure
* @param[out] timp pointer to a @p tm structure as defined in time.h
*
* @api
*/
void rtcGetTimeTm(RTCDriver *rtcp, struct tm *timp) {
RTCTime timespec = {0,0};
rtcGetTime(rtcp, ×pec);
localtime_r((time_t *)&(timespec.tv_sec), timp);
}
void setStartTime(void)
{
rtcGetTime(RTC_DRIVER, ×pec);
rtcConvertDateTimeToStructTm(×pec, &startTime,0);
}
void VcountHandler()
{
static int lastbut = -1;
uint8 ct[sizeof(IPC->time.rtc)];
uint16 but=0, x=0, y=0, xpx=0, ypx=0, z1=0, z2=0;
but = REG_KEYXY;
if(!((but ^ lastbut) & (1<<6)))
{
tempPos = touchReadXY();
if(tempPos.x == 0 || tempPos.y == 0)
{
but |= (1 <<6);
lastbut = but;
}
else
{
x = tempPos.x;
y = tempPos.y;
xpx = tempPos.px;
ypx = tempPos.py;
z1 = tempPos.z1;
z2 = tempPos.z2;
}
}
else
{
lastbut = but;
but |= (1 <<6);
}
if(vcount == 80)
{
first = tempPos;
}
else
{
if(abs(xpx - first.px) > 10 || abs(ypx - first.py) > 10 || (but & (1<<6)))
{
but |= (1 <<6);
lastbut = but;
}
else
{
IPC->mailBusy = 1;
IPC->touchX = x;
IPC->touchY = y;
IPC->touchXpx = xpx;
IPC->touchYpx = ypx;
IPC->touchZ1 = z1;
IPC->touchZ2 = z2;
IPC->mailBusy = 0;
}
}
// Read the time
rtcGetTime((uint8 *)ct);
BCDToInteger((uint8 *)&(ct[1]), 7);
u8 i;
u8 *temp;
temp = (u8*)&IPC->time.rtc;
for(i=0; i<sizeof(ct); i++)
{
temp[i] = ct[i];
}
IPC->buttons = but;
vcount ^= (80 ^ 130);
SetYtrigger(vcount);
}
