void DoAutoZero(void){
LCD_FullDisp( " Ready for Auto-Zero",
"(Keep Pitob Ass. Out",
"& Sampling Pump Off)",
" Press Enter Key ");
//w8 for user to press ENTER key
WaitFor(EnterKey);
//Enter key pressed, go to AUTOZERO of Pitot_DP, Orifice_DP and Orifice_GAS_DP.
//User is expected to remove any input to system, hence read values are offsets
LCD_FullDisp( " Doing Auto-Zero ",
"(Keep Pitob Ass. Out",
"& Sampling Pump Off)",
" ");
delay_sec(1);
OrifPart_DP.Zero= ExtAnalogRead(Ch_Orifice_DP);
LCD_Setcursor(4,2);
LCD_Print("------"); //Graphic loading Effect ;)
delay_sec(1);
Pitot_DP.Zero= ExtAnalogRead(Ch_Pitot_DP);
LCD_Print("------");
delay_sec(1);
OrifGas_DP.Zero= ExtAnalogRead(Ch_Orifice_Gas_DP);
LCD_Print("------");
LCD_FullDisp( " ",
" Auto-Zero done ",
" Press Enter Key ",
" ");
WaitFor(EnterKey);
}
void main()
{
unsigned int n=0;
while(1)
{
if(n==5)
{
led_seg=0xFF;
n=0;
bzr=1;
}
else
{
led_seg=0x0F;
bzr=0;
}
delay_sec(1);
led_seg=0x00;
delay_sec(1);
sev_seg=ch[n];
n++;
}
}
/* start the main program */
void main()
{
/*Configure all the ports as output */
TRISA=0x00;
TRISB=0x00;
TRISC=0x00;
TRISD=0x00;
TRISE=0x00;
while(1)
{
/* Turn On all the leds and wait for one second */
PORTA=LedOn;
PORTB=LedOn;
PORTC=LedOn;
PORTD=LedOn;
PORTE=LedOn;
delay_sec(1);
/* Turn off all the leds and wait for one second */
PORTA=LedOff;
PORTB=LedOff;
PORTC=LedOff;
PORTD=LedOff;
PORTE=LedOff;
delay_sec(1);
}
}
int main(void) {
InitLEDPort();
YellowLEDOn();
delay_sec(1);
YellowLEDOff();
delay_sec(1);
YellowLEDOn();
delay_sec(1);
i2c_init(); // init I2C interface
#ifdef UART_DEBUG
uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
sei();
uart_puts_P("\r\n'lsm303test' ready!\r\n");
#endif // UART_DEBUG
#ifdef LSM303DLH_USE_ACC
LSM303DLHInitACC( I2C_DEV_LSM303DLH_ACC1 );
#endif // LSM303DLH_USE_ACC
#ifdef LSM303DLH_USE_MAG
LSM303DLHInitMAG( I2C_DEV_LSM303DLH_MAG );
#endif // LSM303DLH_USE_MAG
while ( 1 ) {
#ifdef UART_DEBUG
uart_puts_P("\r\nRunning test... ");
#endif // UART_DEBUG
#if (defined LSM303DLH_USE_ACC) || (defined LSM303DLH_USE_MAG)
# ifdef LSM303DLH_USE_ACC
LSM303DLHTestACC();
# endif // LSM303DLH_USE_ACC
# ifdef LSM303DLH_USE_MAG
LSM303DLHTestMAG();
# endif // LSM303DLH_USE_MAG
#else
# ifdef UART_DEBUG
uart_puts_p( cCRLF );
# endif // UART_DEBUG
delay_sec(2);
#endif // LSM303DLH_USE_ACC || LSM303DLH_USE_MAG
}
return 0;
}
void flash_led_long()
{
//LED_PORT |= _BV(LED);
turn_led_off();
delay_sec();
//LED_PORT &= ~_BV(LED);
turn_led_on();
delay_sec();
//LED_PORT |= _BV(LED);
turn_led_off();
delay_sec();
}
void main(void) {
init();
while(1) // main loop
{
/* if (btn_pressed)
{
if (btn_pressed==BTN_BACK) LCDoff();
if (btn_pressed==BTN_OK) LCDon();
if (btn_pressed==BTN_UP) backlightOn();
if (btn_pressed==BTN_DOWN) backlightOff();
btn_pressed=0;
};
*/
defaultRX = 1;
NRF_init(85);
while(!isThereTemperatureReady())
{
setAddr(17, 0);
showTime();
delay_sec(1);
};
defaultRX = 0;
NRF_init(86);
TXBuf[0] = 0x10;
TXBuf[1] = 0xff;
TXBuf[2] = RXBuf[2];
TXBuf[3] = RXBuf[3];
TXBuf[4] = RXBuf[4];
NRF_transmit(5);
NRF_down();
char i;
for (i=0; i<9; i++)
{
delay_sec(60);
};
delay_sec(30);
};
}
void main(void) {
uint8_t momentum[2] = {1, 1};
int8_t last_direction[2] = {0,0};
setup();
sei(); // enable interrupts
// This loop runs forever, its sole purpose is to keep the heater power constant
// it can be interrupted at any point by a TWI event
for (;;) {
for(uint8_t ii = 0; ii < EGG_BUS_NUM_HOSTED_SENSORS; ii++){
int8_t direction = heater_control_manage(ii, momentum[ii]) > 0 ? 1 : -1;
if(direction == last_direction[ii] && direction != 0){
momentum[ii] += 1; // change faster
}
else{
momentum[ii] = 1; // reset to slow changes
}
if(direction != 0){
last_direction[ii] = direction;
}
}
delay_sec(3); // only change the heater voltage every three seconds or so to give it time to settle in
}
}
int
main(void) {
uint8_t byte = 0x01;
uint8_t up = 1, intensity = 1;
init8x8();
delay_sec(2);
for (;;) {
for ( uint8_t digit = 0; digit < 8; ++digit )
tx8x8(digit,byte++);
++byte;
if ( up ) {
if ( ++intensity >= 16 )
up = 0;
else tx8x8(8,intensity); /* Increase intensity */
} else {
if ( --intensity == 0 )
up = 1;
else tx8x8(8,intensity); /* Decrease intensity */
}
}
return 0;
}
void main()
{
unsigned int i;
for(i=0;i<2;i++)
{
seven_seg=ch[i];
delay_sec(1);
}
}
void Disp_IntroLcdMsgs(void){
LCD_PowerOff();
LCD_Frame1(); //make good looking frame around LCD
LCD_Setcursor(1,9);
LCD_Print(" ");
LCD_Setcursor(1,10);
LCD_DataWrite(1); //prints polltech logo that is stored at location 1
LCD_Setcursor(2,2);
LCD_Print(" Polltech ");
LCD_Setcursor(3,2);
LCD_Print(" Instruments ");
LCD_PowerOn();
delay_sec(1);
LCD_Setcursor(2,2);
LCD_Print("StackMonitoringKit");
LCD_Setcursor(3,2);
LCD_Print(" Model PEM-SMK 20 ");
delay_sec(1);
}
void printTripHystory(signed int point)
{
int temp;
LCD_clear();
temp = point + '0';
strcpy(st, "TRIP [0]");
st[6] = point + '0';
PrintLCD(0,0,st);
delay_sec();
sci_rx_msg_start = sci_rx_msg_end = 0;
strcpy(gSciTxBuf,"9:4:903:0.000e+1"); // rq trip code
gSciTxBuf[8] = temp;
SendSciString( gSciTxBuf );
delay_sec();
if( getSciMsg(st)) printLCD(0,10,st); // disp code
else DisplayChar( 0 , 10, '-');
sci_rx_msg_start = sci_rx_msg_end = 0;
strcpy(gSciTxBuf,"9:4:903:0.500e+1"); // trip time
gSciTxBuf[8] = temp;
SendSciString( gSciTxBuf );
delay_sec();
if( getSciMsg(st)) printLCD(2,0,st); // time
else DisplayChar( 2 , 1, '-');
sci_rx_msg_start = sci_rx_msg_end = 0;
strcpy(gSciTxBuf,"9:4:903:0.600e+1"); // rq trip message
gSciTxBuf[8] = temp;
SendSciString( gSciTxBuf );
delay_sec();
if( getSciMsg(st)) printLCD(1,0,st); // disp message
else DisplayChar( 1 , 1, '-');
sci_rx_msg_start = sci_rx_msg_end = 0;
strcpy(gSciTxBuf,"9:4:903:0.400e+1"); // trip VDC
gSciTxBuf[8] = temp;
SendSciString( gSciTxBuf );
delay_sec();
if( getSciMsg(st)) printLCD(3,0,st); // debug
else{
strcpy(st," - ");
printLCD(3,0,st);
}
sci_rx_msg_start = sci_rx_msg_end = 0;
strcpy(gSciTxBuf,"9:4:903:0.100e+1"); // trip data
gSciTxBuf[8] = temp;
SendSciString( gSciTxBuf );
delay_sec();
if( getSciMsg(st)) printLCD(3,10,st); // debug
else DisplayChar( 3 , 10, '-');
}
void main()
{
int i;
lcd_init();
for(i=0;i<lcd_tab[i]!='\0';i++)
{
lcd_data(lcd_tab[i]);
S1=1;
S2=0;
seg_data=seg_tab1[i];
//delay_ms(10);
S1=0;
S2=1;
seg_data=seg_tab2[i];
delay_sec(1);
lcd_cmd(0x02);
}
while(1);
}
void autonomous_routine0(void)
{
DPRINTF("Starting autonomous routine...\n");
controller_begin_autonomous_mode();
/*
* Place your autonomous code here. The example below drives
* the robot forward (or backward) for 2 seconds and then stops.
*/
pwm_write(RIGHT_DRIVE_PORT, AUTON_DRIVE_SPEED);
pwm_write(LEFT_DRIVE_PORT, -AUTON_DRIVE_SPEED);
controller_submit_data(WAIT);
delay_sec(2);
pwm_write(RIGHT_DRIVE_PORT, MOTOR_STOP);
pwm_write(LEFT_DRIVE_PORT, MOTOR_STOP);
controller_submit_data(WAIT);
controller_end_autonomous_mode();
DPRINTF("Ending autonomous routine...\n");
}
int OBNTCHK(double A, double L, double R)
{
UPRST &u=uprst;
int ntk;
//printf("\n BEFORE PUSKCHV");
//delay_sec(3);
//#avm# 08/07/2013
printf("Наводимся в точку A=%f L=%f R=%f\n", A, L, R);
if (!PUSKCHV(A,L,R)) return 0;
printf("Навелись в точку A=%f L=%f R=%f\n", cd[0], cd[1], cd[2]);
ntk=1;
double Az, H;
absmet(ntk, cd[0], cd[1], cd[2], 0, 0, &Az, &H);
printf("Коорд.центра канала %d: Az=%f H=%f\n", ntk, Az*RG, H*RG);
//#avm# 08/07/2013
VU_OTKR(RABTK);
//if (!RESVU()) return 0;
//printf("\n BEFORE DELAY");
delay_sec(2); //пауза 2 сек
//printf("\n AFTER DELAY");
if (!IZMERAPOI(RABTK)) return 0;
for(ntk=1; ntk<=MAXTK; ntk++) {
if (!RABTK[ntk]) continue;
if (KKOAPOI[ntk]>0)
MetodOMR(ntk);
}
IZMERKO(RABTK);
if (u.kolko>0 || (IMITAPOI && CVS==1))
if (!OBRKO(RABTK,1)) return 0;
stopcsn();
rabOK();
return 1;
}
int BARIER56(ZONA &z)
{
UPRST &u=uprst;
double A,L,R;
int ntk;
A=z.A;
L=z.LN;
R=z.RN;
PUSKCHV(z.A,L,R);
VU_OTKR(RABTK);
// if (!RESVU()) return 0;
printf("выполнен переброс\n");
delay_sec(5); //пауза 2 сек
printf("начато наблюдение на барьере\n");
for(;;) {
if (!IZMERAPOI(RABTK)) return 0;
for(ntk=1; ntk<=MAXTK; ntk++) {
if (!RABTK[ntk]) continue;
if (KKOAPOI[ntk]>0)
MetodOMR(ntk);
}
IZMERKO(RABTK);
if (u.kolko>0) {
if (!OBRKO(RABTK,1)) return 0;
}
rabOK();
z.percent=100.;
}
stopcsn();
return RESCSN();
}
static void LSM303DLHTestACC(void) {
#ifdef UART_DEBUG
uart_puts_P("\r\n");
#endif // UART_DEBUG
LSM303DLHData acc_data;
// --- read accelerometer values
uint8_t ret = LSM303DLHReadACC( I2C_DEV_LSM303DLH_ACC1, &acc_data );
if ( ret ) {
YellowLEDOff();
RedLEDOn(); // show error
#ifdef UART_DEBUG
if ( ret == I2C_ERR_NO_DEVICE ) uart_puts_P("ACC: I2C_ERR_NO_DEV\r\n");
#endif // UART_DEBUG
#ifdef UART_DEBUG
if ( ret == I2C_ERROR ) uart_puts_P("ACC: I2C_ERROR\r\n");
#endif // UART_DEBUG
return;
}
PrintSensorData( "AX", acc_data.fSensorX );
PrintSensorData( "AY", acc_data.fSensorY );
PrintSensorData( "AZ", acc_data.fSensorZ );
uart_puts_p( cCRLF );
delay_sec(1);
}
static void LSM303DLHTestMAG(void) {
#ifdef UART_DEBUG
uart_puts_P("\r\n");
#endif // UART_DEBUG
LSM303DLHData mag_data;
// --- read magnetometer values
uint8_t ret = LSM303DLHReadMAG( I2C_DEV_LSM303DLH_MAG, &mag_data );
if ( ret ) {
YellowLEDOff();
RedLEDOn(); // show error
#ifdef UART_DEBUG
if ( ret == I2C_ERR_NO_DEVICE ) uart_puts_P("MAG: I2C_ERR_NO_DEV\r\n");
#endif // UART_DEBUG
#ifdef UART_DEBUG
if ( ret == I2C_ERROR ) uart_puts_P("MAG: I2C_ERROR\r\n");
#endif // UART_DEBUG
return;
}
PrintSensorData( "MX", mag_data.fSensorX );
PrintSensorData( "MY", mag_data.fSensorY );
PrintSensorData( "MZ", mag_data.fSensorZ );
uart_puts_p( cCRLF );
delay_sec(1);
}
// Execute dwell in seconds.
void mc_dwell(float seconds)
{
if (sys.state == STATE_CHECK_MODE) { return; }
protocol_buffer_synchronize();
delay_sec(seconds, DELAY_MODE_DWELL);
}
int main (void)
{
system_init();
Initialize_Hardware();
#ifndef BypassLCD
CalibrationModeChk();
Disp_IntroLcdMsgs(); //Display company name, model name
// DoAutoZero();
LCD_Clrscr();
#endif
LCD_Setcursor(3,20);
LCD_DataWrite(ARROW);
LCD_Setcursor(1,1);
ExtADCHi=ExtADCLo+ExtADCMid+ExtADCHi;
while(1){
Spi_Get3BytesfromExtADC(Ch_Orifice_DP);
}
// volatile float asd= Compute_PT100Temp(9900);
//LCD_FullDisp( LCD_BLANK_LINE_MACRO,
//" Erase stored data? ",
//" Yes / No ",
//LCD_BLANK_LINE_MACRO);
//LCD_Frame2();
// volatile uint32_t as= CombineDigitstoNumber1(arr, 3);
volatile uint8_t selected=0;
// selected =LCD_MenuHandle(MenuSize(CalibrationMenu),CalibrationMenu);
// LCD_FullDisp(MSG[0],MSG[1],MSG[2],MSG[3]);
// LCD_FullDisp(CalibrationMenu[0],CalibrationMenu[1],CalibrationMenu[2],CalibrationMenu[3]);
// LCD_MenuDisplay(CalibrationMenu, 4);
LCD_Setcursor(1,2);
LCD_CursorOn();
LCD_DispAscii(selected);
// LCD_DispVariable(12345,2,10,0,1);
Ambient_PT100.STDvalue=10021;
volatile uint32_t ans=GetNumDataFromUser(32768,2,3,1,10);
LCD_DispVariable(ans, 2, 3, 3, 10);
volatile uint8_t a,b,c,d;
a=EE_MISCAddr(c);
b=EE_CALAddr(EE_OrifPart_Z);
c=EE_CALAddr(EE_AuxTemp_STDUP);
d=EE_CALAddr(EE_Abs_ADCLOW);
a=a+b+c+d;
while (1)
{
PinSet(BuzzerPin);
delay_sec(2);
PinClr(BuzzerPin);
delay_sec(2);
}
// Insert application code here, after the board has been initialized.
}
void timer(void)
{
int C = 0; // carry
delay_sec(1);
// SL
if(SL == 9) {
SL = 0;
C = 1;
}
else {
SL += 1;
}
// SH
if(C == 1) {
if(SH == 5) {
SH = 0;
C = 1;
}
else {
SH += 1;
C = 0;
}
}
// ML
if(C == 1) {
if(ML == 9) {
ML = 0;
C = 1;
}
else {
ML += 1;
C = 0;
}
}
// MH
if(C == 1) {
if(MH == 5) {
MH = 0;
C = 1;
}
else {
MH += 1;
C = 0;
}
}
// HL
if(C == 1) {
if(HL == 3 && HH == 2) {
HL = 0;
HH = 0;
return;
}
if(HL == 9) {
HL = 0;
C = 1;
}
else {
HL += 1;
C = 0;
}
}
// HH
if(C == 1) {
HH += 1;
}
}
int main(void)
{
i2c_init(); // init I2C interface
#ifdef USE_UART
uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
uart_puts_P("'twitest' ready!\r\n");
sei();
#endif // USE_UART
uint8_t ret = 0;
while ( 1 ) {
#ifdef USE_UART
uart_puts_P("Loop...\r\n");
#endif // USE_UART
if ( ret ) {
i2c_init(); // init I2C interface
#ifdef USE_UART
uart_puts_P("I2C init!\r\n");
#endif // USE_UART
}
#if (TEST_PCF8574A == 1)
// test with PCF8574A
ret = i2c_start(I2C_DEV8574A | I2C_WRITE);
if ( ret ) {
/* failed to issue start condition, possibly no device found */
i2c_stop();
#ifdef USE_UART
uart_puts_P("Error - no PCF8574A device!\r\n");
#endif // USE_UART
delay_sec(1);
continue;
}
else {
/* issuing start condition ok, device accessible */
i2c_write(0xfe); // write data to IO extender
i2c_stop(); // set stop conditon = release bus
#ifdef USE_UART
uart_puts_P("PCF8574A OK!\r\n");
#endif // USE_UART
}
#endif // TEST_PCF8574A
#if (TEST_DISP == 1 )
ret = I2C_DisplayWrite();
if ( ret ) {
delay_sec(1);
continue;
}
#endif // TEST_DISP
delay_msec10(20);
}
return 0;
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
* main function
*-------------------------------------------------------------------------------------------------------------------------------------------
*/
int
main ()
{
static uint_fast8_t last_ldr_value = 0xFF;
struct tm tm;
LISTENER_DATA lis;
ESP8266_INFO * esp8266_infop;
uint_fast8_t esp8266_is_up = 0;
uint_fast8_t code;
#if SAVE_RAM == 0
IRMP_DATA irmp_data;
uint32_t stop_time;
uint_fast8_t cmd;
#endif
uint_fast8_t status_led_cnt = 0;
uint_fast8_t display_flag = DISPLAY_FLAG_UPDATE_ALL;
uint_fast8_t show_temperature = 0;
uint_fast8_t time_changed = 0;
uint_fast8_t power_is_on = 1;
uint_fast8_t night_power_is_on = 1;
uint_fast8_t ldr_value;
uint_fast8_t ap_mode = 0;
SystemInit ();
SystemCoreClockUpdate(); // needed for Nucleo board
#if defined (STM32F103) // disable JTAG to get back PB3, PB4, PA13, PA14, PA15
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); // turn on clock for the alternate function register
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); // disable the JTAG, enable the SWJ interface
#endif
log_init (); // initilize logger on uart
#if SAVE_RAM == 0
irmp_init (); // initialize IRMP
#endif
timer2_init (); // initialize timer2 for IRMP, DCF77, EEPROM etc.
delay_init (DELAY_RESOLUTION_1_US); // initialize delay functions with granularity of 1 us
board_led_init (); // initialize GPIO for green LED on disco or nucleo board
button_init (); // initialize GPIO for user button on disco or nucleo board
rtc_init (); // initialize I2C RTC
eeprom_init (); // initialize I2C EEPROM
if (button_pressed ()) // set ESP8266 into flash mode
{
board_led_on ();
esp8266_flash ();
}
log_msg ("\r\nWelcome to WordClock Logger!");
log_msg ("----------------------------");
log_str ("Version: ");
log_msg (VERSION);
if (rtc_is_up)
{
log_msg ("rtc is online");
}
else
{
log_msg ("rtc is offline");
}
if (eeprom_is_up)
{
log_msg ("eeprom is online");
read_version_from_eeprom ();
log_printf ("current eeprom version: 0x%08x\r\n", eeprom_version);
if ((eeprom_version & 0xFF0000FF) == 0x00000000)
{ // Upper and Lower Byte must be 0x00
if (eeprom_version >= EEPROM_VERSION_1_5_0)
{
#if SAVE_RAM == 0
log_msg ("reading ir codes from eeprom");
remote_ir_read_codes_from_eeprom ();
#endif
log_msg ("reading display configuration from eeprom");
display_read_config_from_eeprom ();
log_msg ("reading timeserver data from eeprom");
timeserver_read_data_from_eeprom ();
}
if (eeprom_version >= EEPROM_VERSION_1_7_0)
{
log_msg ("reading night timers from eeprom");
night_read_data_from_eeprom ();
}
}
}
else
{
log_msg ("eeprom is offline");
}
ldr_init (); // initialize LDR (ADC)
display_init (); // initialize display
dcf77_init (); // initialize DCF77
night_init (); // initialize night time routines
short_isr = 1;
temp_init (); // initialize DS18xx
short_isr = 0;
display_reset_led_states ();
display_mode = display_get_display_mode ();
animation_mode = display_get_animation_mode ();
auto_brightness = display_get_automatic_brightness_control ();
if (eeprom_is_up)
{
if (eeprom_version != EEPROM_VERSION)
{
log_printf ("updating EEPROM to version 0x%08x\r\n", EEPROM_VERSION);
eeprom_version = EEPROM_VERSION;
write_version_to_eeprom ();
#if SAVE_RAM == 0
remote_ir_write_codes_to_eeprom ();
#endif
display_write_config_to_eeprom ();
timeserver_write_data_to_eeprom ();
night_write_data_to_eeprom ();
eeprom_version = EEPROM_VERSION;
}
}
ds3231_flag = 1;
#if SAVE_RAM == 0
stop_time = uptime + 3; // wait 3 seconds for IR signal...
display_set_status_led (1, 1, 1); // show white status LED
while (uptime < stop_time)
{
if (irmp_get_data (&irmp_data)) // got IR signal?
{
display_set_status_led (1, 0, 0); // yes, show red status LED
delay_sec (1); // and wait 1 second
(void) irmp_get_data (&irmp_data); // flush input of IRMP now
display_set_status_led (0, 0, 0); // and switch status LED off
log_msg ("calling IR learn function");
if (remote_ir_learn ()) // learn IR commands
{
remote_ir_write_codes_to_eeprom (); // if successful, save them in EEPROM
}
break; // and break the loop
}
}
#endif
display_set_status_led (0, 0, 0); // switch off status LED
esp8266_init ();
esp8266_infop = esp8266_get_info ();
while (1)
{
if (! ap_mode && esp8266_is_up && button_pressed ()) // if user pressed user button, set ESP8266 to AP mode
{
ap_mode = 1;
log_msg ("user button pressed: configuring esp8266 as access point");
esp8266_is_online = 0;
esp8266_infop->is_online = 0;
esp8266_infop->ipaddress[0] = '\0';
esp8266_accesspoint ("wordclock", "1234567890");
}
if (status_led_cnt)
{
status_led_cnt--;
if (! status_led_cnt)
{
display_set_status_led (0, 0, 0);
}
}
if ((code = listener (&lis)) != 0)
{
display_set_status_led (1, 0, 0); // got net command, light red status LED
status_led_cnt = STATUS_LED_FLASH_TIME;
switch (code)
{
case LISTENER_SET_COLOR_CODE: // set color
{
display_set_colors (&(lis.rgb));
log_printf ("command: set colors to %d %d %d\r\n", lis.rgb.red, lis.rgb.green, lis.rgb.blue);
break;
}
case LISTENER_POWER_CODE: // power on/off
{
if (power_is_on != lis.power)
{
power_is_on = lis.power;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
log_msg ("command: set power");
}
break;
}
case LISTENER_DISPLAY_MODE_CODE: // set display mode
{
if (display_mode != lis.mode)
{
display_mode = display_set_display_mode (lis.mode);
display_flag = DISPLAY_FLAG_UPDATE_ALL;
log_printf ("command: set display mode to %d\r\n", display_mode);
}
break;
}
case LISTENER_ANIMATION_MODE_CODE: // set animation mode
{
if (animation_mode != lis.mode)
{
animation_mode = display_set_animation_mode (lis.mode);
animation_flag = 0;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
log_printf ("command: set animation mode to %d\r\n", animation_flag);
}
break;
}
case LISTENER_DISPLAY_TEMPERATURE_CODE: // set animation mode
{
show_temperature = 1;
log_msg ("command: show temperature");
break;
}
case LISTENER_SET_BRIGHTNESS_CODE: // set brightness
{
if (auto_brightness)
{
auto_brightness = 0;
last_ldr_value = 0xFF;
display_set_automatic_brightness_control (auto_brightness);
}
display_set_brightness (lis.brightness);
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
log_printf ("command: set brightness to %d, disable autmomatic brightness control per LDR\r\n", lis.brightness);
break;
}
case LISTENER_SET_AUTOMATIC_BRIHGHTNESS_CODE: // automatic brightness control on/off
{
if (lis.automatic_brightness_control)
{
auto_brightness = 1;
log_msg ("command: enable automatic brightness control");
}
else
{
auto_brightness = 0;
log_msg ("command: disable automatic brightness control");
}
last_ldr_value = 0xFF;
display_set_automatic_brightness_control (auto_brightness);
break;
}
case LISTENER_TEST_DISPLAY_CODE: // test display
{
log_msg ("command: start display test");
display_test ();
break;
}
case LISTENER_SET_DATE_TIME_CODE: // set date/time
{
if (rtc_is_up)
{
rtc_set_date_time (&(lis.tm));
}
if (hour != (uint_fast8_t) lis.tm.tm_hour || minute != (uint_fast8_t) lis.tm.tm_min)
{
display_flag = DISPLAY_FLAG_UPDATE_ALL;
}
wday = lis.tm.tm_wday;
hour = lis.tm.tm_hour;
minute = lis.tm.tm_min;
second = lis.tm.tm_sec;
log_printf ("command: set time to %s %4d-%02d-%02d %02d:%02d:%02d\r\n",
wdays_en[lis.tm.tm_wday], lis.tm.tm_year + 1900, lis.tm.tm_mon + 1, lis.tm.tm_mday,
lis.tm.tm_hour, lis.tm.tm_min, lis.tm.tm_sec);
break;
}
case LISTENER_GET_NET_TIME_CODE: // get net time
{
net_time_flag = 1;
log_msg ("command: start net time request");
break;
}
case LISTENER_IR_LEARN_CODE: // IR learn
{
#if SAVE_RAM == 0
log_msg ("command: learn IR codes");
if (remote_ir_learn ())
{
remote_ir_write_codes_to_eeprom ();
}
#endif
break;
}
case LISTENER_SAVE_DISPLAY_CONFIGURATION: // save display configuration
{
display_write_config_to_eeprom ();
log_msg ("command: save display settings");
break;
}
}
}
if (auto_brightness && ldr_poll_brightness (&ldr_value))
{
if (ldr_value + 1 < last_ldr_value || ldr_value > last_ldr_value + 1) // difference greater than 2
{
log_printf ("ldr: old brightnes: %d new brightness: %d\r\n", last_ldr_value, ldr_value);
last_ldr_value = ldr_value;
display_set_brightness (ldr_value);
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
}
}
if (!esp8266_is_up) // esp8266 up yet?
{
if (esp8266_infop->is_up)
{
esp8266_is_up = 1;
log_msg ("esp8266 now up");
}
}
else
{ // esp8266 is up...
if (! esp8266_is_online) // but not online yet...
{
if (esp8266_infop->is_online) // now online?
{
char buf[32];
esp8266_is_online = 1;
log_msg ("esp8266 now online");
sprintf (buf, " IP %s", esp8266_infop->ipaddress);
display_banner (buf);
display_flag = DISPLAY_FLAG_UPDATE_ALL;
net_time_flag = 1;
}
}
}
if (dcf77_time(&tm))
{
display_set_status_led (1, 1, 0); // got DCF77 time, light yellow = green + red LED
status_led_cnt = 50;
if (rtc_is_up)
{
rtc_set_date_time (&tm);
}
if (hour != (uint_fast8_t) tm.tm_hour || minute != (uint_fast8_t) tm.tm_min)
{
display_flag = DISPLAY_FLAG_UPDATE_ALL;
}
wday = tm.tm_wday;
hour = tm.tm_hour;
minute = tm.tm_min;
second = tm.tm_sec;
log_printf ("dcf77: %s %4d-%02d-%02d %02d:%02d:%02d\r\n",
wdays_en[tm.tm_wday], tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
}
if (ds3231_flag)
{
if (rtc_is_up && rtc_get_date_time (&tm))
{
if (hour != (uint_fast8_t) tm.tm_hour || minute != (uint_fast8_t) tm.tm_min)
{
display_flag = DISPLAY_FLAG_UPDATE_ALL;
}
wday = tm.tm_wday;
hour = tm.tm_hour;
minute = tm.tm_min;
second = tm.tm_sec;
log_printf ("read rtc: %s %4d-%02d-%02d %02d:%02d:%02d\r\n",
wdays_en[tm.tm_wday], tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
}
ds3231_flag = 0;
}
if (auto_brightness && ldr_conversion_flag)
{
ldr_start_conversion ();
ldr_conversion_flag = 0;
}
if (net_time_flag)
{
if (esp8266_infop->is_online)
{
display_set_status_led (0, 0, 1); // light blue status LED
status_led_cnt = STATUS_LED_FLASH_TIME;
timeserver_start_timeserver_request (); // start a timeserver request, answer follows...
}
net_time_flag = 0;
net_time_countdown = 3800; // next net time after 3800 sec
}
if (show_time_flag) // set every full minute
{
#if WCLOCK24H == 1
display_flag = DISPLAY_FLAG_UPDATE_ALL;
#else
if (minute % 5)
{
display_flag = DISPLAY_FLAG_UPDATE_MINUTES; // only update minute LEDs
}
else
{
display_flag = DISPLAY_FLAG_UPDATE_ALL;
}
#endif
show_time_flag = 0;
}
if (power_is_on == night_power_is_on && night_check_night_times (power_is_on, wday, hour * 60 + minute))
{
power_is_on = ! power_is_on;
night_power_is_on = ! night_power_is_on;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
log_printf ("Found Timer: %s at %02d:%02d\r\n", power_is_on ? "on" : "off", hour, minute);
}
if (show_temperature)
{
uint_fast8_t temperature_index;
show_temperature = 0;
if (ds18xx_is_up)
{
short_isr = 1;
temperature_index = temp_read_temp_index ();
short_isr = 0;
log_printf ("got temperature from DS18xxx: %d%s\r\n", temperature_index / 2, (temperature_index % 2) ? ".5" : "");
}
else if (rtc_is_up)
{
temperature_index = rtc_get_temperature_index ();
log_printf ("got temperature from RTC: %d%s\r\n", temperature_index / 2, (temperature_index % 2) ? ".5" : "");
}
else
{
temperature_index = 0xFF;
log_msg ("no temperature available");
}
if (temperature_index != 0xFF)
{
display_temperature (power_is_on, temperature_index);
#if WCLOCK24H == 1 // WC24H shows temperature with animation, WC12H rolls itself
uint32_t stop_time;
stop_time = uptime + 5;
while (uptime < stop_time)
{
if (animation_flag)
{
animation_flag = 0;
display_animation ();
}
}
#endif
display_flag = DISPLAY_FLAG_UPDATE_ALL; // force update
}
}
if (display_flag) // refresh display (time/mode changed)
{
log_msg ("update display");
#if WCLOCK24H == 1
if (display_mode == MODES_COUNT - 1) // temperature
{
uint_fast8_t temperature_index;
if (ds18xx_is_up)
{
short_isr = 1;
temperature_index = temp_read_temp_index ();
short_isr = 0;
log_printf ("got temperature from DS18xxx: %d%s\r\n", temperature_index / 2, (temperature_index % 2) ? ".5" : "");
}
else if (rtc_is_up)
{
temperature_index = rtc_get_temperature_index ();
log_printf ("got temperature from RTC: %d%s\r\n", temperature_index / 2, (temperature_index % 2) ? ".5" : "");
}
else
{
temperature_index = 0x00;
log_msg ("no temperature available");
}
display_clock (power_is_on, 0, temperature_index - 20, display_flag); // show new time
}
else
{
display_clock (power_is_on, hour, minute, display_flag); // show new time
}
#else
display_clock (power_is_on, hour, minute, display_flag); // show new time
#endif
display_flag = DISPLAY_FLAG_NONE;
}
if (animation_flag)
{
animation_flag = 0;
display_animation ();
}
if (dcf77_flag)
{
dcf77_flag = 0;
dcf77_tick ();
}
#if SAVE_RAM == 0
cmd = remote_ir_get_cmd (); // get IR command
if (cmd != REMOTE_IR_CMD_INVALID) // got IR command, light green LED
{
display_set_status_led (1, 0, 0);
status_led_cnt = STATUS_LED_FLASH_TIME;
}
if (cmd != REMOTE_IR_CMD_INVALID) // if command valid, log command code
{
switch (cmd)
{
case REMOTE_IR_CMD_POWER: log_msg ("IRMP: POWER key"); break;
case REMOTE_IR_CMD_OK: log_msg ("IRMP: OK key"); break;
case REMOTE_IR_CMD_DECREMENT_DISPLAY_MODE: log_msg ("IRMP: decrement display mode"); break;
case REMOTE_IR_CMD_INCREMENT_DISPLAY_MODE: log_msg ("IRMP: increment display mode"); break;
case REMOTE_IR_CMD_DECREMENT_ANIMATION_MODE: log_msg ("IRMP: decrement animation mode"); break;
case REMOTE_IR_CMD_INCREMENT_ANIMATION_MODE: log_msg ("IRMP: increment animation mode"); break;
case REMOTE_IR_CMD_DECREMENT_HOUR: log_msg ("IRMP: decrement hour"); break;
case REMOTE_IR_CMD_INCREMENT_HOUR: log_msg ("IRMP: increment hour"); break;
case REMOTE_IR_CMD_DECREMENT_MINUTE: log_msg ("IRMP: decrement minute"); break;
case REMOTE_IR_CMD_INCREMENT_MINUTE: log_msg ("IRMP: increment minute"); break;
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_RED: log_msg ("IRMP: decrement red brightness"); break;
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_RED: log_msg ("IRMP: increment red brightness"); break;
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_GREEN: log_msg ("IRMP: decrement green brightness"); break;
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_GREEN: log_msg ("IRMP: increment green brightness"); break;
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_BLUE: log_msg ("IRMP: decrement blue brightness"); break;
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_BLUE: log_msg ("IRMP: increment blue brightness"); break;
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS: log_msg ("IRMP: decrement brightness"); break;
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS: log_msg ("IRMP: increment brightness"); break;
case REMOTE_IR_CMD_GET_TEMPERATURE: log_msg ("IRMP: get temperature"); break;
}
}
switch (cmd)
{
case REMOTE_IR_CMD_POWER:
{
power_is_on = ! power_is_on;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
break;
}
case REMOTE_IR_CMD_OK:
{
display_write_config_to_eeprom ();
break;
}
case REMOTE_IR_CMD_DECREMENT_DISPLAY_MODE: // decrement display mode
{
display_mode = display_decrement_display_mode ();
display_flag = DISPLAY_FLAG_UPDATE_ALL;
break;
}
case REMOTE_IR_CMD_INCREMENT_DISPLAY_MODE: // increment display mode
{
display_mode = display_increment_display_mode ();
display_flag = DISPLAY_FLAG_UPDATE_ALL;
break;
}
case REMOTE_IR_CMD_DECREMENT_ANIMATION_MODE: // decrement display mode
{
animation_mode = display_decrement_animation_mode ();
display_flag = DISPLAY_FLAG_UPDATE_ALL;
break;
}
case REMOTE_IR_CMD_INCREMENT_ANIMATION_MODE: // increment display mode
{
animation_mode = display_increment_animation_mode ();
display_flag = DISPLAY_FLAG_UPDATE_ALL;
break;
}
case REMOTE_IR_CMD_DECREMENT_HOUR: // decrement hour
{
if (hour > 0)
{
hour--;
}
else
{
hour = 23;
}
second = 0;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
time_changed = 1;
break;
}
case REMOTE_IR_CMD_INCREMENT_HOUR: // increment hour
{
if (hour < 23)
{
hour++;
}
else
{
hour = 0;
}
second = 0;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
time_changed = 1;
break;
}
case REMOTE_IR_CMD_DECREMENT_MINUTE: // decrement minute
{
if (minute > 0)
{
minute--;
}
else
{
minute = 59;
}
second = 0;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
time_changed = 1;
break;
}
case REMOTE_IR_CMD_INCREMENT_MINUTE: // increment minute
{
if (minute < 59)
{
minute++;
}
else
{
minute = 0;
}
second = 0;
display_flag = DISPLAY_FLAG_UPDATE_ALL;
time_changed = 1;
break;
}
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_RED: // decrement red brightness
{
display_decrement_color_red ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_RED: // increment red brightness
{
display_increment_color_red ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_GREEN: // decrement green brightness
{
display_decrement_color_green ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_GREEN: // increment green brightness
{
display_increment_color_green ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS_BLUE: // decrement blue brightness
{
display_decrement_color_blue ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS_BLUE: // increment blue brightness
{
display_increment_color_blue ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_AUTO_BRIGHTNESS_CONTROL: // toggle auto brightness
{
auto_brightness = ! auto_brightness;
last_ldr_value = 0xFF;
display_set_automatic_brightness_control (auto_brightness);
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_DECREMENT_BRIGHTNESS: // decrement brightness
{
if (auto_brightness)
{
auto_brightness = 0;
last_ldr_value = 0xFF;
display_set_automatic_brightness_control (auto_brightness);
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
}
display_decrement_brightness ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_INCREMENT_BRIGHTNESS: // increment brightness
{
if (auto_brightness)
{
auto_brightness = 0;
last_ldr_value = 0xFF;
display_set_automatic_brightness_control (auto_brightness);
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
}
display_increment_brightness ();
display_flag = DISPLAY_FLAG_UPDATE_NO_ANIMATION;
break;
}
case REMOTE_IR_CMD_GET_TEMPERATURE: // get temperature
{
show_temperature = 1;
break;
}
default:
{
break;
}
}
#endif // SAVE_RAM == 0
if (time_changed)
{
if (rtc_is_up)
{
tm.tm_hour = hour;
tm.tm_min = minute;
tm.tm_sec = second;
rtc_set_date_time (&tm);
}
time_changed = 0;
}
}
return 0;
}
