uint8_t set_preset_variable(uint8_t num) {
if (num < 0 || num >= NUMBER_OF_PRESETS) {
//Out of range
return 1;
}
while(!bns[1] && (wd_clock <= 60)) {
if(bns[0]) {
bns[0] = false;
presets[num] -= 2;
if (presets[num] < SI4705_FM_LOW) presets[num] = SI4705_FM_HIGH;
ms_clock = 0; //force a redraw, reset activity
wd_clock = 0;
watchdog_feed();
}
if(bns[2]) {
bns[2] = false;
presets[num] += 2;
if (presets[num] > SI4705_FM_HIGH) presets[num] = SI4705_FM_LOW;
ms_clock = 0; //force a redraw, reset activity
wd_clock = 0;
watchdog_feed();
}
if ((ms_clock+125)%250 == 0) {
if (hol[0]) {
presets[num] -= 2;
if (presets[num] < SI4705_FM_LOW) presets[num] = SI4705_FM_HIGH;
ms_clock = 0; //force a redraw, reset activity
wd_clock = 0;
watchdog_feed();
}
if (hol[2]) {
presets[num] += 2;
if (presets[num] > SI4705_FM_HIGH) presets[num] = SI4705_FM_LOW;
ms_clock = 0; //force a redraw, reset activity
wd_clock = 0;
watchdog_feed();
}
}
if (ms_clock%1000 == 0) {
watchdog_entertain();
nokia5110_gotoXY(7, num);
snprintf(line, 12, "%d.%d ", presets[num]/10, presets[num]%10);
nokia5110_writeString(line);
} else if ((ms_clock + 500)%1000 == 0 && is_fresh) {
watchdog_entertain();
nokia5110_gotoXY(7, num);
nokia5110_writeString(" ");
}
}
if (bns[1]) {
eeprom_update_word(&saved_presets[num], presets[num]);
bns[1] = false;
wd_clock = 0;
return 0;
} else {
wd_clock = 0;
return 1;
}
}
int para_rm(unsigned char type)
{
unsigned int i,addr;
const struct paraitf *itf;
if((type==0)||(type>PARA_MAX))
return -1;
type--;
itf = ¶_interface[type];
addr = itf->sbase;
for(i=0;i<itf->ss;i++){
addr += i;
watchdog_feed();
flash_sector_erase(addr);
PrintLog(LOGTYPE_SHORT,"erase para type:%d,in sectore:%d\n",type,addr);
}
addr = itf->sbase+itf->ss;
for(i=0;i<itf->ss;i++){
addr += i;
watchdog_feed();
flash_sector_erase(addr);
PrintLog(LOGTYPE_SHORT,"erase para type:%d,in sectore:%d\n",type,addr);
}
return 0;
}
void task_run(void *arg)
{
SysTick_init();
mutex_init();
if(__init_GlobalLock()!=0)
SysReset();
__GlobalLock();
platpara_init();
printf("\r\nstart runing...\r\n");
printf("platform make at:\033[1;31;40m%s \033[0m\r\n",MKTIME);
printf("Sysetm \033[1;32;40m%s\033[0m start at:%s\r\n",SYSTEM_NAME,UTimeFormat(UTimeReadCurrent()));
RunAppTask();
while(1)
{
rtc_update(1);
if(UTimeReadCurrent()%300 == 0)
printf("\r\nTime:%s\r\n",UTimeFormat(UTimeReadCurrent()));
watchdog_feed();
#ifdef BIG_CONCENT
shining_led();
#endif
SysCheckTaskState();
sleep(50);
}
}
/**
* @ingroup firmware
*
*
*
* @param boot_dev
* @param arm_m_type
* @param atags
* @return
*/
int notmain(uint32_t boot_dev, uint32_t arm_m_type, uint32_t atags)
{
hardware_init();
dmx_init();
printf("Compiled on %s at %s\n", __DATE__, __TIME__);
ui_start(0x00); // User Interface
ui_reinit();
ui_text_line_1("DMX512 Receiver", 15);
ui_text_line_2("Booting........", 15);
dmx_devices_read_config();
dmx_devices_init();
watchdog_init();
events_init();
for (;;)
{
watchdog_feed();
int i = 0;
for (i = 0; i < sizeof(poll_table) / sizeof(poll_table[0]); i++)
{
poll_table[i].f();
}
events_check();
}
return 0;
}
void task_app(void *arg)
{
(void)arg;
__GlobalLock();
watchdog_feed();
if(SysInit()) {
DebugPrint(0,"system init failed!! quit\n");
return;
}
watchdog_feed();
if(ParamInit()) {
DebugPrint(0,"param init failed!! quit\n");
return;
}
watchdog_feed();
// MonitorInit();
RunTimeThread();
InitCenmet(); //´®¿Ú³±í
#ifndef TEST_PLC
SysCreateTask(SvrCommTask,0,"Svr Comm Task",-1,TASK_GPRS_STK_SIZE,TASK_GPRS_PRIO);//uplink 300 8
#endif
#ifdef BIG_CONCENT
InitUp485();
#endif
// MonitorTask();
#ifdef DEFINE_PLCOMM
PlcCommInit();
#endif
#ifdef TEST_PLC
SysCreateTask(RunTestTask,0,"Test Task",0,200,25);//test 200 25
#endif
// SysCreateTask(RunStackCheck,0,"Stack Check Task",0,200,26);//check 200 26
TtyShellStart();
//while(1)Sleep(2000);;
}
static long watchdog_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
if(cmd == FEED_DOG)
{
watchdog_feed();
}
return 0;
}
void check_periodic_timers() {
int i;
for (i = 0; i < (sizeof(events) / sizeof(events[0])); i++) {
if (clock.time > events_last[i] + events[i].period) {
events[i].f();
events_last[i] += events[i].period;
watchdog_feed();
}
}
}
/**
* @ingroup main
*
*/
inline static void events_check() {
int i;
const uint32_t micros_now = hardware_micros();
for (i = 0; i < (sizeof(events) / sizeof(events[0])); i++) {
if (micros_now > events_elapsed_time[i] + events[i].period) {
events[i].f();
events_elapsed_time[i] += events[i].period;
watchdog_feed();
}
}
}
void
watchdog_init(void)
{
// Set the timeout for the watchdog
LPC_WDT->WDTC = WATCHDOG_TIMER_VALUE;
// Enable the watchdog timer and make it cause a reset when it underflows
LPC_WDT->WDMOD |= 0x3;
watchdog_feed();
}
static inline void watchdog_enable(void)
{
unsigned long wathdog_enable_pin;
wathdog_enable_pin = watchdog->enable_pin;
/* we must feed dog once watchdog enable */
watchdog_feed();
gpio_set_value(wathdog_enable_pin,WATCHDOG_ENABLE);
}
void store_iap_start(void)
{
unsigned int i;
//PrintLog(LOGTYPE_SHORT,"ipa save code start\n");
for(i=FLASH_UPDATE_SECTOR_BASE;i<=FLASH_UPDATE_SECTOR_END;i++){
watchdog_feed();
flash_sector_erase(i);
//printf("erase flash sector %d",i);
}
icount.size = 0;
icount.records = 0;
}
/* Open the interlock and then stop forever.
*
* This is intended to be called at the end of panic() or similar.
*/
void __attribute__((noreturn)) hw_open_interlock_forever(void) {
/* Turn off all DAC channels. */
hw_dac_init();
if (hw_board_rev == HW_REV_MP1) {
/* Square wave */
int i;
LPC_GPIO2->FIODIR |= (1 << 8);
while (1) {
for (i = 0; i < 1000; i++) __NOP();
LPC_GPIO2->FIOSET = (1 << 8);
watchdog_feed();
for (i = 0; i < 1000; i++) __NOP();
LPC_GPIO2->FIOCLR = (1 << 8);
watchdog_feed();
}
} else {
/* Just do nothing */
while (1);
}
}
int main(void)
{
led_init();
key_init();
// timer0_init();
watchdog_init();
led_on(LED0);
/* feed dog, otherwise will reset when watchdog time expire */
watchdog_feed();
return 0;
}
int main(void) {
system_init();
uart_on(0, 115200, NULL);
adc_on();
uprintf(0, "System started\n");
msleep(5);
watchdog_config(&wdconf);
uprintf(0, "Watchdog started\n");
while (1) {
watchdog_feed();
chenillard(50);
/* ADC Test */
adc_display(LPC_ADC_NUM(0), 0);
}
return 0;
}
int main(void) {
DMA1_Stream0->CR=0;
DMA1_Stream1->CR=0;
DMA1_Stream2->CR=0;
DMA1_Stream3->CR=0;
DMA1_Stream4->CR=0;
DMA1_Stream5->CR=0;
DMA1_Stream6->CR=0;
DMA1_Stream7->CR=0;
DMA2_Stream0->CR=0;
DMA2_Stream1->CR=0;
DMA2_Stream2->CR=0;
DMA2_Stream3->CR=0;
DMA2_Stream4->CR=0;
DMA2_Stream5->CR=0;
DMA2_Stream6->CR=0;
DMA2_Stream7->CR=0;
palClearPad(GPIOD,7); // disable USBH power
// copy vector table
memcpy((char *)0x20000000, (const char *)&_vectors, 0x200);
// remap SRAM1 to 0x00000000
SYSCFG->MEMRMP |= 0x03;
// FMC_SDRAMDeInit(0);
// RCC->AHB3RSTR |= 1; //RCC_AHB3RSTR_FMCRST
RCC->AHB3ENR |= 1; //RCC_AHB3ENR_FMCEN;
// HAL_DeInit();
// HAL_Init();
watchdog_feed();
halInit();
// float usb inputs, hope the host notices detach...
palSetPadMode(GPIOA, 11, PAL_MODE_INPUT); palSetPadMode(GPIOA, 12, PAL_MODE_INPUT);
// setup LEDs
palSetPadMode(LED1_PORT,LED1_PIN,PAL_MODE_OUTPUT_PUSHPULL);
palSetPad(LED1_PORT,LED1_PIN);
#ifdef LED2_PIN
palSetPadMode(LED2_PORT,LED2_PIN,PAL_MODE_OUTPUT_PUSHPULL);
#endif
chSysInit();
watchdog_feed();
configSDRAM();
#ifdef SERIALDEBUG
// SD2 for serial debug output
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7) | PAL_MODE_INPUT); // RX
palSetPadMode(GPIOA, 2, PAL_MODE_OUTPUT_PUSHPULL); // TX
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); // TX
// 115200 baud
static const SerialConfig sd2Cfg = {115200, 0, 0, 0};
sdStart(&SD2, &sd2Cfg);
#endif
DBGPRINTCHAR('a');
uint32_t pbuf[16];
SDRAM_ReadBuffer(&pbuf[0], 0 + 0x050000, 16);
DBGPRINTCHAR('x');
watchdog_feed();
uint32_t *sdram32 = (uint32_t *)SDRAM_BANK_ADDR;
uint8_t *sdram8 = (uint8_t *)SDRAM_BANK_ADDR;
if ((sdram8[0] != 'f') || (sdram8[1] != 'l') || (sdram8[2] != 'a')
|| (sdram8[3] != 's') || (sdram8[4] != 'c') || (sdram8[5] != 'o')
|| (sdram8[6] != 'p') || (sdram8[7] != 'y')) {
DispayAbortErr(1);
}
DBGPRINTCHAR('b');
uint32_t flength = sdram32[2];
uint32_t fcrc = sdram32[3];
if (flength > 1 * 1024 * 1024) {
DispayAbortErr(2);
}
DBGPRINTCHAR('c');
DBGPRINTHEX(flength);
uint32_t ccrc = CalcCRC32((uint8_t *)(SDRAM_BANK_ADDR + 0x010), flength);
DBGPRINTCHAR('d');
DBGPRINTHEX(ccrc);
DBGPRINTHEX(fcrc);
if (ccrc != fcrc) {
DispayAbortErr(3);
}
DBGPRINTCHAR('e');
// unlock sequence
FLASH->KEYR = 0x45670123;
FLASH->KEYR = 0xCDEF89AB;
uint32_t i;
for (i = 0; i < 12; i++) {
flash_Erase_sector(i);
LCD_drawStringN(0, 3, "Erased sector", 128);
LCD_drawNumber3D(80, 3, i);
refresh_LCD();
palWritePad(LED2_PORT,LED2_PIN,1);
chThdSleepMilliseconds(100);
palWritePad(LED2_PORT,LED2_PIN,0);
DBGPRINTCHAR('f');
DBGPRINTHEX(i);
}
DBGPRINTCHAR('g');
DBGPRINTHEX(flength);
ccrc = CalcCRC32((uint8_t *)(SDRAM_BANK_ADDR + 0x010), flength);
DBGPRINTCHAR('h');
DBGPRINTHEX(ccrc);
DBGPRINTHEX(fcrc);
if (ccrc != fcrc) {
DispayAbortErr(4);
}
DBGPRINTCHAR('i');
int destptr = FLASH_BASE_ADDR; // flash base adress
uint32_t *srcptr = (uint32_t *)(SDRAM_BANK_ADDR + 0x010); // sdram base adress + header offset
for (i = 0; i < (flength + 3) / 4; i++) {
uint32_t d = *srcptr;
flash_ProgramWord(destptr, d);
if ((FLASH->SR != 0) && (FLASH->SR != 1)) {
DBGPRINTCHAR('z');
DBGPRINTHEX(FLASH->SR);
}
// DBGPRINTHEX(f);
if ((i & 0xFFF) == 0) {
palWritePad(LED2_PORT,LED2_PIN,1);
chThdSleepMilliseconds(100); palWritePad(LED2_PORT,LED2_PIN,0);
DBGPRINTCHAR('j');
DBGPRINTHEX(destptr);
DBGPRINTHEX(*(srcptr));
}
destptr += 4;
srcptr++;
}
DBGPRINTCHAR('k');
ccrc = CalcCRC32((uint8_t *)(FLASH_BASE_ADDR), flength);
DBGPRINTCHAR('l');
DBGPRINTHEX(ccrc);
DBGPRINTHEX(fcrc);
if (ccrc != fcrc) {
DispayAbortErr(5);
}
DBGPRINTCHAR('\r');
DBGPRINTCHAR('\n');
DBGPRINTCHAR('S');
DBGPRINTCHAR('U');
DBGPRINTCHAR('C');
DBGPRINTCHAR('C');
DBGPRINTCHAR('E');
DBGPRINTCHAR('S');
DBGPRINTCHAR('S');
DBGPRINTCHAR('\r');
DBGPRINTCHAR('\n');
chThdSleepMilliseconds(1000);
NVIC_SystemReset();
return 0;
}
int main(int argc, char **argv) {
__disable_irq();
LPC_GPIO2->FIODIR &= ~(1 << 8);
LPC_SC->PCLKSEL0 = PCLKSEL0_INIT_VALUE;
LPC_SC->PCLKSEL1 = PCLKSEL1_INIT_VALUE;
LPC_SC->PCONP = PCONP_INIT_VALUE;
clock_init();
serial_init();
/* Enable bus, usage, and mem faults. */
SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk | SCB_SHCSR_BUSFAULTENA_Msk
| SCB_SHCSR_USGFAULTENA_Msk;
#if 0
/* Disable write buffers. This is useful for debugging - wild writes
* are imprecise exceptions unless the Cortex's write buffering is
* disabled. However, this has a significant performance hit, so it
* should only be set if necessary. */
*((uint32_t *)0xE000E008) |= (1<<1);
#endif
debugf("\r\n###############\r\n");
debugf("# Ether Dream #\r\n");
debugf("###############\r\n");
debugf("Firmware: %s\r\n", build);
debugf("RSID: %d\r\n", LPC_SC->RSID);
LPC_SC->RSID = 0xF;
hw_get_board_rev();
debugf("Hardware Revision %d\n", hw_board_rev);
debugf("Starting up: led");
led_init();
led_set_frontled(1);
debugf(" skub");
skub_init();
debugf(" lwip\r\n");
lwip_init();
clock.time = 0;
clock.mtime = 0;
SysTick_Config(SystemCoreClock / 10000);
/* Initialize hardware */
FPA_init();
outputf("Entering main loop...");
watchdog_init();
/* Startup might have taken some time, so reset the periodic event
* timers. */
int i;
for (i = 0; i < (sizeof(events) / sizeof(events[0])); i++) {
events_last[i] = events[i].start + clock.time;
}
__enable_irq();
playback_set_src(SRC_NETWORK);
/* Default values */
dac_set_rate(30000);
ilda_set_fps_limit(30);
while (1) {
watchdog_feed();
/* Check the stuff we check on each loop iteration. */
for (i = 0; i < TABLE_LENGTH(poll); i++) {
poll_table[i].f();
}
/* Check for periodic events */
check_periodic_timers();
if (f0ad_flag) {
/* Re-enter the bootloader. */
outputf("Reentering bootloader...");
dac_stop(0);
FORCE_BOOTLOAD_FLAG = FORCE_BOOTLOAD_VALUE;
__disable_irq();
/* The watchdog timer will kick us soon... */
while(1);
}
}
}
void main(void)
{
unsigned char n,cmd,tasterpegel=0;
signed char cal;
// unsigned int m;
static __code signed char __at 0x1BFF trimsave;
#ifdef zeroswitch
static __code unsigned char __at 0x1BFE phisave={16};
#endif
unsigned char rm_count=0;
__bit wduf,tastergetoggelt=0;
wduf=WDCON&0x02;
restart_hw(); // Hardware zuruecksetzen
// im folgendem wird der watchdof underflow abgefragt und mit gedrücktem Progtaster
// ein resetten der cal Variable veranlasst um wieder per rs232 trimmen zu können.
TASTER=1;
if(!TASTER && wduf)cal=0;
else cal=trimsave;
TASTER=0;
TRIM = (TRIM+trimsave);
TRIM &= 0x3F;//oberen 2 bits ausblenden
#ifdef zeroswitch
if(phisave<=52) phival=phisave;
else phival=16;
#endif
TR0=1;
if (!wduf){// BUS return verzögerung nur wenn nicht watchdog underflow
for (n=0;n<50;n++) { // Warten bis Bus stabil
TR0=0; // Timer 0 anhalten
TH0=eeprom[ADDRTAB+1]; // Timer 0 setzen mit phys. Adr. damit Geräte unterschiedlich beginnen zu senden
TL0=eeprom[ADDRTAB+2];
TF0=0; // Überlauf-Flag zurücksetzen
TR0=1; // Timer 0 starten
while(!TF0);
}
}
watchdog_init();
watchdog_start();
restart_app(); // Anwendungsspezifische Einstellungen zuruecksetzen
if(!wduf)bus_return(); // Aktionen bei Busspannungswiederkehr
//...rs_init...(6);im folgenden direkt:
/* BRGCON&=0xFE; // Baudrate Generator stoppen
// P1M1&=0xFC; // RX und TX auf bidirectional setzen
// P1M2&=0xFC;
SCON=0x50; // Mode 1, receive enable
SSTAT|=0xE0; // TI wird am Ende des Stopbits gesetzt und Interrupt nur bei RX und double TX buffer an
BRGCON|=0x02; // Baudrate Generator verwenden aber noch gestoppt
BRGR1=0x2f; // Baudrate = cclk/((BRGR1,BRGR0)+16)
BRGR0=0xf0; // für 115200 0030 nehmen, autocal: 600bd= 0x2FF0
BRGCON|=0x01; // Baudrate Generator starten
*/
#ifndef debugmode
RS_INIT_600
#else
RS_INIT_115200
#endif
SBUF=0x55;
do {
watchdog_feed();
if(APPLICATION_RUN) { // nur wenn run-mode gesetzt
if(RTCCON>=0x80) delay_timer(); // Realtime clock Ueberlauf
#ifndef zeroswitch
if(TF0 && (TMOD & 0x0F)==0x01) { // Vollstrom für Relais ausschalten und wieder PWM ein
#ifndef SPIBISTAB
TMOD=(TMOD & 0xF0) + 2; // Timer 0 als PWM
TAMOD=0x01;
TH0=DUTY;
#endif
TF0=0;
#ifndef SPIBISTAB
AUXR1|=0x10; // PWM von Timer 0 auf Pin ausgeben
#endif
PWM=1; // PWM Pin muss auf 1 gesetzt werden, damit PWM geht !!!
#ifndef SPIBISTAB
#ifndef IO_BISTAB
TR0=1;
#endif
#endif
#ifdef IO_BISTAB
P0=0;// wenn Bistabile über IO diese ausschalten
#endif
}
#endif
#ifdef BUS_DOWN
if(TxD){
bus_down();
}
#endif
if (portchanged)port_schalten(); // Ausgänge schalten
// Rückmeldungen senden
if(rm_send) { // wenn nichts zu senden ist keine Zeit vertrödeln
if(rm_send & (1<<rm_count)) {
if(send_obj_value(rm_count + 12)) { // falls erfolgreich, dann nächste
rm_send&=(0xFF-(1<<rm_count));
rm_count++;
#ifdef MAX_PORTS_8
rm_count&=0x07;
#else
rm_count&=0x03;
#endif
}
}
else { // RM sollte nicht gesendet werden
rm_count++;
#ifdef MAX_PORTS_8
rm_count&=0x07;
#else
rm_count&=0x03;
#endif
}
}
else rm_count=0; // Immer mal wieder auf Null setzen, damit Reihenfolge von 1 bis 8 geht
// portbuffer flashen, Abbruch durch ext-int wird akzeptiert und später neu probiert
// T1-int wird solange abgeschaltet,
if (fb_state==0 && (TH1<0XC0) && (!wait_for_ack)&& portbuffer!=eeprom[PORTSAVE]) {
START_WRITECYCLE;
WRITE_BYTE(0x01,PORTSAVE,portbuffer);
STOP_WRITECYCLE;
}
}// end if(runstate...
// Telegrammverarbeitung..
if (tel_arrived || tel_sent) {
tel_arrived=0;
tel_sent=0;
process_tel();
}
else {
for(n=0;n<100;n++); // falls Hauptroutine keine Zeit verbraucht, der PROG LED etwas Zeit geben, damit sie auch leuchten kann
}
cmd;
#ifndef debugmode
// Eingehendes Terminal Kommando verarbeiten...
if (RI){
RI=0;
cmd=SBUF;
if(cmd=='c'){
while(!TI);
TI=0;
SBUF=0x55;
}
if(cmd=='+'){
TRIM--;
cal--;
}
if(cmd=='-'){
TRIM++;
cal++;
}
if(cmd=='w'){
EA=0;
START_WRITECYCLE; //cal an 0x1bff schreiben
#ifdef zeroswitch
FMADRH= 0x1B;
FMADRL= 0xFE;
FMDATA= phival;
#else
FMADRH= 0x1B;
FMADRL= 0xFF;
#endif
FMDATA= cal;
STOP_WRITECYCLE;
EA=1; //int wieder freigeben
}
if(cmd=='p')status60^=0x81; // Prog-Bit und Parity-Bit im system_state toggeln
#ifdef zeroswitch
if(cmd=='<'){
if (phival){
phival--;
TI=0;
SBUF=phival;
}
}
if(cmd=='>'){
if(phival<51){
phival++; //
TI=0;
SBUF=phival;
}
}
#endif
if(cmd=='v'){
while(!TI);
TI=0;
SBUF=VERSION;
}
if(cmd=='t'){
while(!TI);
TI=0;
SBUF=TYPE;
}
#ifdef MAX_PORTS_8
if(cmd >=49 && cmd <= 56){
portbuffer = portbuffer ^ (0x01<< (cmd-49));
port_schalten();
}
#else
if(cmd >=49 && cmd <= 52){
portbuffer = portbuffer ^ (0x01<< (cmd-49));
port_schalten();
}
#endif
}//end if(RI...
#else //ifndef debugmode
DEBUGPOINT;
#endif
TASTER=1; // Pin als Eingang schalten um Taster abzufragen
if(!TASTER){ // Taster gedrückt
if(tasterpegel<255) tasterpegel++;
else{
if(!tastergetoggelt)status60^=0x81; // Prog-Bit und Parity-Bit im system_state toggeln
tastergetoggelt=1;
}
}
else {
if(tasterpegel>0) tasterpegel--;
else tastergetoggelt=0;
}
TASTER=!(status60 & 0x01); // LED entsprechend Prog-Bit schalten (low=LED an)
} while(1);
}
uint8_t set_time_variable(CLOCK_PREFIX_t selection, time_t *input_time) {
uint8_t value = *((uint8_t*)input_time + selection); //get the selected value from the memory address
if (input_time == &time) { //If we're setting the clock's time
sprintf(line, "%02d/%02d/%02d", input_time->month, input_time->day, input_time->year);
nokia5110_gotoXY(0,1);
nokia5110_writeString(line);
sprintf(line, "%02d:%02d:%02d %s", input_time->hour - 12*(input_time->hour>12), input_time->minute, input_time->second, input_time->hour<12?"am":"pm");
nokia5110_gotoXY(0,2);
nokia5110_writeString(line);
} else { //If we're setting an alarm time
sprintf(line, "%02d:%02d %s", input_time->hour - 12*(input_time->hour>12), input_time->minute, input_time->hour<12?"am":"pm");
nokia5110_gotoXY(0,2);
nokia5110_writeString(line);
}
char str[] = "00";
if (selection == days) {
time_limits[selection] = days_in_month[input_time->month-1];
}
while(!bns[1] && (wd_clock <= 60)) {
if(bns[0]) {
bns[0] = false;
if (selection == months || selection == days) {
value = ((value+time_limits[selection]-2) % (time_limits[selection]) + 1);
} else {
value = ((value+time_limits[selection]-1) % (time_limits[selection]));
}
ms_clock = 0; //force a redraw, reset activity
wd_clock = 0;
watchdog_feed();
}
if(bns[2]) {
bns[2] = false;
if (selection == months || selection == days) {
value = ((value % time_limits[selection]) + 1);
} else {
value = ((value+1) % (time_limits[selection]));
}
ms_clock = 0; //force a redraw, reset activity
wd_clock = 0;
watchdog_feed();
}
if ((ms_clock+125)%250 == 0) {
if (hol[0]) {
if (selection == months || selection == days) {
value = ((value+time_limits[selection]-2) % (time_limits[selection]) + 1);
} else {
value = ((value+time_limits[selection]-1) % (time_limits[selection]));
}
ms_clock = 0; //force a redraw, reset activity
wd_clock = 0;
watchdog_feed();
}
if (hol[2]) {
if (selection == months || selection == days) {
value = ((value % time_limits[selection]) + 1);
} else {
value = ((value+1) % (time_limits[selection]));
}
ms_clock = 0; //force a redraw, reset activity
wd_clock = 0;
watchdog_feed();
}
}
if (ms_clock%1000 == 0) {
watchdog_entertain();
nokia5110_gotoXY((selection%3)*21, selection/3+1);
if (selection == hours) {
snprintf(str, 3, "%02d", value - 12*(value>12));
nokia5110_writeString(str);
nokia5110_gotoXY(42 + 21*(input_time == &time), 2);
nokia5110_writeString(value<12?"am":"pm");
} else {
snprintf(str, 3, "%02d", value);
nokia5110_writeString(str);
}
} else if ((ms_clock + 500)%1000 == 0 && is_fresh) {
watchdog_entertain();
nokia5110_gotoXY((selection%3)*21, selection/3+1);
nokia5110_writeString(" ");
}
}
if (bns[1]) {
bns[1] = false;
wd_clock = 0;
*((uint8_t*)input_time + selection) = value; //store the edited value in the memory address
if (selection == days) {
if (time.day > days_in_month[time.month - 1]) {
input_time->day = (days_in_month[time.month - 1] - (time.month == 2 && !ds1307_isleapyear(time.year))); //don't let users send the wrong number of days
}
}
if (selection == years) {
if ( time.day > (days_in_month[time.month - 1] - (time.month == 2 && !ds1307_isleapyear(time.year))) ) {
input_time->day = (days_in_month[time.month - 1] - (time.month == 2 && !ds1307_isleapyear(time.year))); //don't let users send the wrong number of days if it's not a leap year
}
}
if (input_time == &time) { //If we're setting the clock's time
sprintf(line, "%02d/%02d/%02d", input_time->month, input_time->day, input_time->year);
nokia5110_gotoXY(0,1);
nokia5110_writeString(line);
sprintf(line, "%02d:%02d:%02d %s", input_time->hour - 12*(input_time->hour>12), input_time->minute, input_time->second, input_time->hour<12?"am":"pm");
nokia5110_gotoXY(0,2);
nokia5110_writeString(line);
} else { //If we're setting an alarm time
sprintf(line, "%02d:%02d %s", input_time->hour - 12*(input_time->hour>12), input_time->minute, input_time->hour<12?"am":"pm");
nokia5110_gotoXY(0,2);
nokia5110_writeString(line);
}
return 0;
} else {
wd_clock = 0;
return 1;
}
}
static void main_sensor_task(void* p_data, uint16_t length)
{
// Signal mode by led color.
if (RAWv1 == tag_mode) { RED_LED_ON; }
else { GREEN_LED_ON; }
int32_t raw_t = 0;
uint32_t raw_p = 0;
uint32_t raw_h = 0;
lis2dh12_sensor_buffer_t buffer;
int32_t acc[3] = {0};
if (fast_advertising && ((millis() - fast_advertising_start) > ADVERTISING_STARTUP_PERIOD))
{
fast_advertising = false;
bluetooth_configure_advertisement_type(APPLICATION_ADVERTISEMENT_TYPE);
bluetooth_configure_advertising_interval(advertising_rates[tag_mode] + advertisement_delay);
bluetooth_apply_configuration();
}
// If we have all the sensors.
if (model_plus)
{
// Get raw environmental data.
bme280_read_measurements();
raw_t = bme280_get_temperature();
raw_p = bme280_get_pressure();
raw_h = bme280_get_humidity();
// Get accelerometer data.
lis2dh12_read_samples(&buffer, 1);
acc[0] = buffer.sensor.x;
acc[1] = buffer.sensor.y;
acc[2] = buffer.sensor.z;
}
// If only temperature sensor is present.
else
{
int32_t temp; // variable to hold temp reading
(void)sd_temp_get(&temp); // get new temperature
temp *= 25; // SD returns temp * 4. Ruuvi format expects temp * 100. 4*25 = 100.
raw_t = (int32_t) temp;
}
// Embed data into structure for parsing.
parseSensorData(&data, raw_t, raw_p, raw_h, vbat, acc);
NRF_LOG_DEBUG("temperature: %d, pressure: %d, humidity: %d x: %d y: %d z: %d\r\n", raw_t, raw_p, raw_h, acc[0], acc[1], acc[2]);
NRF_LOG_DEBUG("VBAT: %d send %d \r\n", vbat, data.vbat);
// Prepare bytearray to broadcast.
bme280_data_t environmental;
environmental.temperature = raw_t;
environmental.humidity = raw_h;
environmental.pressure = raw_p;
switch(tag_mode)
{
case RAWv2_FAST:
case RAWv2_SLOW:
encodeToRawFormat5(data_buffer, &environmental, &buffer.sensor, acceleration_events, vbat, BLE_TX_POWER);
break;
case RAWv1:
default:
encodeToSensorDataFormat(data_buffer, &data);
break;
}
updateAdvertisement();
watchdog_feed();
}
void inline home_state() {
if (init) {
schedule_insert(system_schedule, 0, ms_clock, get_time);
schedule_insert(system_schedule, 0, ms_clock, display_home_screen);
schedule_insert(system_schedule, 0, ms_clock, display_temp_and_alarm_settings);
schedule_insert(system_schedule, 0, ms_clock, start_ADC_conversion);
nokia5110_clear();
if (radio_is_on) {
si4705_power_off();
radio_is_on = false;
}
what_the_beep = false;
set_volume(0);
#ifndef USING_PRINTF
PORTD |= _BV(0); // Turn the radio LED off
PORTD |= _BV(1); // Turn the stereo status LED off
#endif
}
if(bns[0]) {
bns[0] = false;
}
if(bns[1]) {
bns[1] = false;
state = menu;
}
if(bns[2]) {
bns[2] = false;
}
if (event_is_ready) {
switch(next_event.id) {
case start_ADC_conversion:
ADC_start_conversion();
set_brightness(photo_avg/PHOTO_AVG_RESOLUTION);
schedule_insert(system_schedule, 20, ms_clock, start_ADC_conversion);
break;
case get_time:
ds1307_getdate_s(&time);
err = ds1307_getdayofweek(time.year, time.month, time.day);
schedule_insert(system_schedule, 1000, ms_clock, get_time);
//printf("%d:%d:%d\n", time.hour, time.minute, time.second);
break;
case display_home_screen:
snprintf(line, 12, "%02d:%02d", time.hour - 12*(time.hour>12), time.minute);
nokia5110_gotoXY(12,1);
nokia5110_writeString_megaFont(line);
snprintf(line, 12, " %s ", days_of_week[err]);
nokia5110_gotoXY(day_pixel_offsets[err],0);
nokia5110_writeString(line);
snprintf(line, 12, "%s", time.hour<12?"am":"pm");
nokia5110_gotoXY(68,3);
nokia5110_writeString(line);
snprintf(line, 9, "%d/%d/%d ", time.month, time.day, time.year);
nokia5110_gotoXY(0,4);
nokia5110_writeString(line);
schedule_insert(system_schedule, 1000, ms_clock, display_home_screen);
break;
case display_temp_and_alarm_settings:
init = false;
snprintf(line, 8, "%02d.%01d%cF ", (uint8_t)(temperature_avg/THERM_AVG_RESOLUTION/10), (uint8_t)(temperature_avg/THERM_AVG_RESOLUTION%10), 123);
nokia5110_gotoXY(0,5);
nokia5110_writeString(line);
nokia5110_gotoXY(63,4);
if (hol[3]) {
snprintf(line, 4, "A:%c", alarm_A_is_beep?124+(ADC_values[0]>80)+(ADC_values[0]>180):127);
} else {
snprintf(line, 4, "A: ");
}
nokia5110_writeString(line);
nokia5110_gotoXY(63,5);
if (hol[4]) {
snprintf(line, 4, "B:%c", alarm_B_is_beep?124+(ADC_values[0]>80)+(ADC_values[0]>180):127);
} else {
snprintf(line, 4, "B: ");
}
nokia5110_writeString(line);
schedule_insert(system_schedule, 100, ms_clock, display_temp_and_alarm_settings);
break;
default:
break;
}
}
watchdog_feed();
}
void inline menu_state() {
if (init) {
schedule_insert(system_schedule, 0, ms_clock, start_ADC_conversion);
menu_index = 0;
nokia5110_clear();
nokia5110_gotoXY(0,0);
if (last_state == home) {
nokia5110_writeString(">Radio");
} else {
nokia5110_writeString(">Radio Off");
}
nokia5110_gotoXY(0,1);
nokia5110_writeString(" Time-Set");
nokia5110_gotoXY(0,2);
nokia5110_writeString(" Set AlarmA");
nokia5110_gotoXY(0,3);
nokia5110_writeString(" Set AlarmB");
nokia5110_gotoXY(0,4);
if (last_state == home) {
nokia5110_writeString(" Set Presets");
} else {
nokia5110_writeString(" FM Presets");
}
nokia5110_gotoXY(0,5);
nokia5110_writeString(" Back");
}
if (bns[0]) {
bns[0] = false;
nokia5110_gotoXY(0, menu_index);
nokia5110_writeString(" ");
menu_index = (menu_index+1) % 6;
nokia5110_gotoXY(0, menu_index);
nokia5110_writeString(">");
wd_clock = 0; //reset activity
watchdog_feed();
}
if(bns[1]) {
bns[1] = false;
switch(menu_index) {
case 0:
if (last_state == home) {
state = radio;
} else {
state = home;
}
break;
case 1:
state = set_clock; break;
case 2:
state = set_alarm_A; break;
case 3:
state = set_alarm_B; break;
case 4:
state = preset; break;
default:
state = last_state; break;
}
}
if (bns[2]) {
bns[2] = false;
nokia5110_gotoXY(0, menu_index);
nokia5110_writeString(" ");
menu_index = (menu_index+5) % 6;
nokia5110_gotoXY(0, menu_index);
nokia5110_writeString(">");
wd_clock = 0; //reset activity
watchdog_feed();
}
if (event_is_ready) {
switch(next_event.id) {
case start_ADC_conversion:
ADC_start_conversion();
set_brightness(photo_avg/PHOTO_AVG_RESOLUTION);
schedule_insert(system_schedule, 20, ms_clock, start_ADC_conversion);
break;
default:
break;
}
}
if(wd_clock == 60) {
wd_clock = 0;
state = last_state;
}
}
void inline preset_state() {
if (init) {
schedule_insert(system_schedule, 0, ms_clock, start_ADC_conversion);
menu_index = 0;
nokia5110_clear();
for (err = 0; err < NUMBER_OF_PRESETS; err++) {
nokia5110_gotoXY(0, err);
snprintf(line, 12, " %u.%u", presets[err]/10, presets[err]%10);
nokia5110_writeString(line);
}
nokia5110_gotoXY(0,0);
nokia5110_writeString(">");
nokia5110_gotoXY(0,5);
nokia5110_writeString(" Back");
}
if (bns[0]) {
bns[0] = false;
nokia5110_gotoXY(0, menu_index);
nokia5110_writeString(" ");
menu_index = (menu_index+1) % 6;
nokia5110_gotoXY(0, menu_index);
nokia5110_writeString(">");
wd_clock = 0; // reset activity
watchdog_feed();
}
if (bns[1]) {
bns[1] = false;
if(menu_index == 5) {
state = last_state;
} else {
// choose preset
if (last_state == home) {
nokia5110_gotoXY(0,menu_index);
nokia5110_writeString(" ");
err = set_preset_variable(menu_index);
if (err) {
state = last_state;
}
nokia5110_gotoXY(0,menu_index);
snprintf(line, 12, ">%u.%u", presets[menu_index]/10, presets[menu_index]%10);
nokia5110_writeString(line);
} else {
if (channel != presets[menu_index]) {
channel = presets[menu_index];
si4705_set_channel(channel);
clear_radio_strings();
}
state = radio;
}
}
}
if (bns[2]) {
bns[2] = false;
nokia5110_gotoXY(0, menu_index);
nokia5110_writeString(" ");
menu_index = (menu_index+5) % 6;
nokia5110_gotoXY(0, menu_index);
nokia5110_writeString(">");
wd_clock = 0; //reset activity
watchdog_feed();
}
if (event_is_ready) {
switch(next_event.id) {
case start_ADC_conversion:
ADC_start_conversion();
set_brightness(photo_avg/PHOTO_AVG_RESOLUTION);
schedule_insert(system_schedule, 20, ms_clock, start_ADC_conversion);
break;
default:
break;
}
}
if(wd_clock == 60) {
wd_clock = 0;
state = last_state;
}
}
