static inline void HW_Init (void)
{
PORTC = 0x7C; // Pull-ups on everything except ADC0 and ADC1;
DDRC = 0; // Everything is input;
// PD4 as output - used as a trigger source for oscilloscope
// PD5 as output - used to switch a load while debugging
// PD6 (OC0A) as output.
// All inputs with pull-up
PORTD = (1<<PD3)| (1<<PD7);
DDRD = (1<<PD2) | (1<<PD4) | (1<<PD5) | (1<<PD6);
uart_init();
vfd_init();
// PS = 64 -> f = (18.432M/64) = 288 kHz -> ~20.6 ksps
// Vref = Int 1.10V
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1);
ADMUX = ((1<<REFS0) | (1<<REFS1)) + VIN_CH; // ADC1 -> leitura da tensão de entrada
ADCSRA |= (1<<ADSC); // Descarta a primeira leitura do ADC
while (ADCSRA & (1<<ADSC));
// Configura Timer 2 -> timeout da serial
// PS = 1024 -> interrupção a cada ~21.8 ms, sempre que o timer dá overflow
// TCCR2B = (1<<CS22) | (1<<CS21) | (1<<CS20); -> só ligar quando receber alguma coisa
TIMSK2 = (1<<TOIE2);
// Configura PWM
// Também usa para gerar o refresh do max6921, com a interrupção de overflow
TCCR0A = (1<<COM0A1) | (1<<WGM01) | (1<<WGM00);
TCCR0B = (1<<CS00);
}
int
vfd_draw_str( const char *str )
{
if (!vfd_is_open)
vfd_init();
return 0;
}
int main(void){
_delay_ms(250);
Vfd_ctrl vfdisplay;
vfdisplay.vfd_wr_port = &PORTC;
vfdisplay.vfd_wr_ddr = &DDRC;
vfdisplay.vfd_wr_pin_mask = _BV(PC0);
vfdisplay.vfd_a0_port = &PORTC;
vfdisplay.vfd_a0_ddr = &DDRC;
vfdisplay.vfd_a0_pin_mask = _BV(PC1);
vfdisplay.vfd_cs_port = &PORTC;
vfdisplay.vfd_cs_ddr = &DDRC;
vfdisplay.vfd_cs_pin_mask = _BV(PC3);
vfdisplay.vfd_busy_port = &PORTC;
vfdisplay.vfd_busy_ddr = &DDRC;
vfdisplay.vfd_busy_pin = &PINC;
vfdisplay.vfd_busy_pin_mask = _BV(PC2);
vfdisplay.vfd_reset_port = &PORTC;
vfdisplay.vfd_reset_ddr = &DDRC;
vfdisplay.vfd_reset_pin_mask = _BV(PC4);
vfdisplay.vfd_data_port = &PORTD;
vfdisplay.vfd_data_ddr = &DDRD;
vfd_init(vfdisplay);
vfd_putc(vfdisplay,VFD_CMD_DC5);
char currentTime[] = "13:37";
char sunriseTime[] = "14:63";
char sunsetTime[] = "42:42";
while(1){
vfd_putcmd(vfdisplay,0x00);
vfd_puts(vfdisplay,"Time: ");
vfd_puts(vfdisplay,currentTime);
vfd_puts(vfdisplay," Sunrise: ");
vfd_puts(vfdisplay,sunriseTime);
vfd_puts(vfdisplay," Sunset: ");
vfd_puts(vfdisplay,sunsetTime);
vfd_putcmd(vfdisplay,0x28);
for (uint8_t i = 0; i < 40; i++){
vfd_putc(vfdisplay,0x7F);
}
_delay_ms(250);
}
}
void wakeup(void) {
if (!sleepmode)
return;
CLKPR = _BV(CLKPCE);
CLKPR = 0;
DEBUGP("waketime");
sleepmode = 0;
// plugged in
// wait to verify
_delay_ms(20);
if (ACSR & _BV(ACO))
return;
// turn on pullups
initbuttons();
dimmer_init();
// turn on boost
brightness_level = eeprom_read_byte((uint8_t *)EE_BRIGHT);
boost_init(brightness_level);
// turn on vfd control
vfd_init();
// turn on display
VFDSWITCH_PORT &= ~_BV(VFDSWITCH);
VFDBLANK_PORT &= ~_BV(VFDBLANK);
volume = eeprom_read_byte((uint8_t *)EE_VOLUME); // reset
speaker_init();
kickthedog();
setalarmstate();
// wake up sound
beep(880, 1);
beep(1760, 1);
beep(3520, 1);
kickthedog();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(vfd_process, ev, data)
{
PROCESS_POLLHANDLER();
PROCESS_EXITHANDLER();
PROCESS_BEGIN();
vfd_init();
vfd_print_char(2, 'A');
while(1) {
uint8_t btns;
btns = vfd_read_btns();
if(btns) {
leds_on(LEDS_RED);
} else {
leds_off(LEDS_RED);
}
PROCESS_PAUSE();
}
PROCESS_END();
}
int main(void) {
// uint8_t i;
uint8_t mcustate;
// turn boost off
TCCR0B = 0;
BOOST_DDR |= _BV(BOOST);
BOOST_PORT &= ~_BV(BOOST); // pull boost fet low
// check if we were reset
mcustate = MCUSR;
MCUSR = 0;
wdt_disable();
// now turn it back on... 2 second time out
//WDTCSR |= _BV(WDP0) | _BV(WDP1) | _BV(WDP2);
//WDTCSR = _BV(WDE);
wdt_enable(WDTO_2S);
kickthedog();
// we lost power at some point so lets alert the user
// that the time may be wrong (the clock still works)
timeunknown = 1;
// have we read the time & date from eeprom?
restored = 0;
// setup uart
uart_init(BRRL_192);
//DEBUGP("VFD Clock");
DEBUGP("!");
//DEBUGP("turning on anacomp");
// set up analog comparator
ACSR = _BV(ACBG) | _BV(ACIE); // use bandgap, intr. on toggle!
// settle!
if (ACSR & _BV(ACO)) {
// hmm we should not interrupt here
ACSR |= _BV(ACI);
// even in low power mode, we run the clock
DEBUGP("clock init");
clock_init();
} else {
// we aren't in low power mode so init stuff
// init io's
initbuttons();
VFDSWITCH_PORT &= ~_BV(VFDSWITCH);
DEBUGP("turning on buttons");
// set up button interrupts
DEBUGP("turning on alarmsw");
// set off an interrupt if alarm is set or unset
EICRA = _BV(ISC00);
EIMSK = _BV(INT0);
displaymode = SHOW_TIME;
DEBUGP("vfd init");
vfd_init();
dimmer_init();
DEBUGP("boost init");
brightness_level = eeprom_read_byte((uint8_t *)EE_BRIGHT);
boost_init(brightness_level);
sei();
region = eeprom_read_byte((uint8_t *)EE_REGION);
DEBUGP("speaker init");
speaker_init();
beep(4000, 1);
DEBUGP("clock init");
clock_init();
DEBUGP("alarm init");
setalarmstate();
}
DEBUGP("done");
while (1) {
//_delay_ms(100);
kickthedog();
//uart_putc_hex(ACSR);
if (ACSR & _BV(ACO)) {
// DEBUGP("SLEEPYTIME");
gotosleep();
continue;
}
//DEBUGP(".");
if (just_pressed & 0x1) {
just_pressed = 0;
switch(displaymode) {
case (SHOW_TIME):
displaymode = SET_ALARM;
display_str("set alarm");
set_alarm();
break;
case (SET_ALARM):
displaymode = SET_TIME;
display_str("set time");
set_time();
timeunknown = 0;
break;
case (SET_TIME):
displaymode = SET_DATE;
display_str("set date");
set_date();
break;
case (SET_DATE):
displaymode = SET_BRIGHTNESS;
display_str("set brit");
set_brightness();
break;
case (SET_BRIGHTNESS):
displaymode = SET_DIMMER;
display_str("set dimr");
set_dimmer();
break;
case (SET_DIMMER):
displaymode = SET_VOLUME;
display_str("set vol ");
set_volume();
break;
case (SET_VOLUME):
displaymode = SET_REGION;
display_str("set regn");
set_region();
break;
/*
case (SET_REGION):
displaymode = SET_SNOOZE;
display_str("set snoz");
set_snooze();
break;
*/
default:
displaymode = SHOW_TIME;
}
} else if ((just_pressed & 0x2) || (just_pressed & 0x4)) {
just_pressed = 0;
displaymode = NONE;
display_date(DAY);
kickthedog();
delayms(1500);
kickthedog();
displaymode = SHOW_TIME;
}
}
}
int main (void) {
global_watt_hours_epoch = epoch;
global_voltage_string = malloc(32);
global_current_string = malloc(32);
global_frequency_string = malloc(32);
global_active_power_string = malloc(32);
global_apparent_power_string = malloc(32);
global_reactive_power_string = malloc(32);
global_power_factor_string = malloc(32);
global_phase_angle_string = malloc(32);
sysclk_init();
board_init();
pmc_enable_periph_clk(PIN_ADE7753_ZX_ID);
pio_handler_set(PIN_ADE7753_ZX_PIO, PIN_ADE7753_ZX_ID, PIN_ADE7753_ZX_MASK, PIN_ADE7753_ZX_ATTR, ZX_Handler);
NVIC_EnableIRQ((IRQn_Type)PIN_ADE7753_ZX_ID);
pio_handler_set_priority(PIN_ADE7753_ZX_PIO, (IRQn_Type)PIN_ADE7753_ZX_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_ADE7753_ZX_PIO, PIN_ADE7753_ZX_MASK);
pmc_enable_periph_clk(PIN_ADE7753_IRQ_ID);
pio_handler_set(PIN_ADE7753_IRQ_PIO, PIN_ADE7753_IRQ_ID, PIN_ADE7753_IRQ_MASK, PIN_ADE7753_IRQ_ATTR, IRQ_Handler);
NVIC_EnableIRQ((IRQn_Type)PIN_ADE7753_IRQ_ID);
pio_handler_set_priority(PIN_ADE7753_IRQ_PIO, (IRQn_Type)PIN_ADE7753_IRQ_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_ADE7753_IRQ_PIO, PIN_ADE7753_IRQ_MASK);
pmc_enable_periph_clk(PIN_FP_BUTTON_LOAD_ID);
pio_handler_set(PIN_FP_BUTTON_LOAD_PIO, PIN_FP_BUTTON_LOAD_ID, PIN_FP_BUTTON_LOAD_MASK, PIN_FP_BUTTON_LOAD_ATTR, FP_LOAD_Handler);
NVIC_EnableIRQ((IRQn_Type)PIN_FP_BUTTON_LOAD_ID);
pio_handler_set_priority(PIN_FP_BUTTON_LOAD_PIO, (IRQn_Type)PIN_FP_BUTTON_LOAD_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_FP_BUTTON_LOAD_PIO, PIN_FP_BUTTON_LOAD_MASK);
pmc_enable_periph_clk(PIN_FP_BUTTON_UP_ID);
pio_handler_set(PIN_FP_BUTTON_UP_PIO, PIN_FP_BUTTON_UP_ID, PIN_FP_BUTTON_UP_MASK, PIN_FP_BUTTON_UP_ATTR, FP_UP_Handler);
NVIC_EnableIRQ((IRQn_Type)PIN_FP_BUTTON_UP_ID);
pio_handler_set_priority(PIN_FP_BUTTON_UP_PIO, (IRQn_Type)PIN_FP_BUTTON_UP_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_FP_BUTTON_UP_PIO, PIN_FP_BUTTON_UP_MASK);
pmc_enable_periph_clk(PIN_FP_BUTTON_DOWN_ID);
pio_handler_set(PIN_FP_BUTTON_DOWN_PIO, PIN_FP_BUTTON_DOWN_ID, PIN_FP_BUTTON_DOWN_MASK, PIN_FP_BUTTON_DOWN_ATTR, FP_DOWN_Handler);
NVIC_EnableIRQ((IRQn_Type)PIN_FP_BUTTON_DOWN_ID);
pio_handler_set_priority(PIN_FP_BUTTON_DOWN_PIO, (IRQn_Type)PIN_FP_BUTTON_DOWN_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_FP_BUTTON_DOWN_PIO, PIN_FP_BUTTON_DOWN_MASK);
pmc_enable_periph_clk(PIN_FP_BUTTON_BACK_ID);
pio_handler_set(PIN_FP_BUTTON_BACK_PIO, PIN_FP_BUTTON_BACK_ID, PIN_FP_BUTTON_BACK_MASK, PIN_FP_BUTTON_BACK_ATTR, FP_BACK_Handler);
NVIC_EnableIRQ((IRQn_Type)PIN_FP_BUTTON_BACK_ID);
pio_handler_set_priority(PIN_FP_BUTTON_BACK_PIO, (IRQn_Type)PIN_FP_BUTTON_BACK_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_FP_BUTTON_BACK_PIO, PIN_FP_BUTTON_BACK_MASK);
/*
pmc_enable_periph_clk(PIN_FP_ENCODER_Q1_ID);
pio_handler_set(PIN_FP_ENCODER_Q1_PIO, PIN_FP_ENCODER_Q1_ID, PIN_FP_ENCODER_Q1_MASK, PIN_FP_ENCODER_Q1_ATTR, FP_ENCODER_Handler);
NVIC_EnableIRQ((IRQn_Type)PIN_FP_ENCODER_Q1_ID);
pio_handler_set_priority(PIN_FP_ENCODER_Q1_PIO, (IRQn_Type)PIN_FP_ENCODER_Q1_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_FP_ENCODER_Q1_PIO, PIN_FP_ENCODER_Q1_MASK);
pmc_enable_periph_clk(PIN_FP_ENCODER_Q2_ID);
pio_handler_set(PIN_FP_ENCODER_Q2_PIO, PIN_FP_ENCODER_Q2_ID, PIN_FP_ENCODER_Q2_MASK, PIN_FP_ENCODER_Q2_ATTR, FP_ENCODER_Handler);
NVIC_EnableIRQ((IRQn_Type)PIN_FP_ENCODER_Q2_ID);
pio_handler_set_priority(PIN_FP_ENCODER_Q2_PIO, (IRQn_Type)PIN_FP_ENCODER_Q2_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_FP_ENCODER_Q2_PIO, PIN_FP_ENCODER_Q2_MASK);
*/
ioport_set_pin_level(LED1_GPIO, false);
ioport_set_pin_level(LED2_GPIO, false);
ioport_set_pin_level(LED3_GPIO, false);
ioport_set_pin_level(FP_LED0_GPIO, false);
ioport_set_pin_level(FP_LED1_GPIO, false);
ioport_set_pin_level(FP_LED2_GPIO, false);
ioport_set_pin_level(FP_LED3_GPIO, true);
ioport_set_pin_level(RELAY_1_GPIO, false);
ioport_set_pin_level(RELAY_2_GPIO, false);
/* Initialize the console uart */
configure_console();
spi_master_initialize();
// We need to configure the ade7753...
// ...to have a current gain of 2...
uint8_t gain = ADE7753_GAIN_PGA1_2;
ade7753_write(ADE7753_REGISTER_GAIN, &gain, ADE7753_REGISTER_GAIN_BYTES);
// and a measurment of 2000 half line cycles
uint32_t linecyc_int = 200;
ade7753_write(ADE7753_REGISTER_LINECYC, &linecyc_int, ADE7753_REGISTER_LINECYC_BYTES);
uint32_t mode_register = 0x0080;
ade7753_write(ADE7753_REGISTER_MODE, &mode_register, ADE7753_REGISTER_MODE_BYTES);
uint32_t irqen_register = 0x04;
ade7753_write(ADE7753_REGISTER_IRQEN, &irqen_register, ADE7753_REGISTER_IRQEN_BYTES);
uint8_t phase_offset = 14;
ade7753_write(ADE7753_REGISTER_PHCAL, &phase_offset, ADE7753_REGISTER_PHCAL_BYTES);
char input;
vfd_init();
//vfd_cursor_on();
vfd_gui_splash(__DATE__, __TIME__);
delay_s(5);
vfd_clear();
menu_state = MENU_STATE_VAFAAR;
for(;;) {
if (menu_state == MENU_STATE_SPLASH) {
if (changed == true) {
vfd_clear();
vfd_home();
vfd_gui_splash(__DATE__, __TIME__);
//vfd_gui_splash();
changed = false;
}
} else if (menu_state == MENU_STATE_VAFAAR) {
if (changed == true) {
vfd_clear();
changed = false;
}
vfd_home();
vfd_gui_vaf_aar();
} else if (menu_state == MENU_STATE_TRIG) {
if (changed == true) {
vfd_clear();
changed = false;
}
vfd_home();
vfd_gui_trig();
} else if (menu_state == MENU_STATE_COST) {
if (changed == true) {
vfd_clear();
changed = false;
}
vfd_home();
vfd_gui_cost();
} else if (menu_state == MENU_STATE_CONFIG) {
if (changed == true) {
vfd_clear();
changed = false;
}
vfd_home();
vfd_gui_config();
} else {
vfd_clear();
}
}
}
