int main(void) {
// init
uart_init(UART_BAUD_SELECT(UART_BAUD_RATE, F_CPU));
// enable interrupts after resetting the kicker
sei();
uart_puts_P("* Interrupts enabled. - ");
ports_init();
uart_puts_P("Ports initialized. - ");
kicker_init();
uart_puts_P("Kicker initialized. - ");
//kicker_uext(500);
uart_puts_P("Device initialized. Enter main loop\n");
for (;;) {
parser_process_uart();
}
return 0;
}
static uint8_t I2C_DisplayWrite(void)
{
static uint16_t data = 0;
uint8_t ret = 0;
ret = i2c_start( I2C_DISPLAY | I2C_WRITE); // set device address and write mode
if ( ret ) {
/* failed to issue start condition, possibly no device found */
i2c_stop();
#ifdef USE_UART
uart_puts_P("Error - no DISP device!\r\n");
#endif // USE_UART
return ret;
}
#ifdef USE_UART
uart_puts_P("Data: ");
int2uart( data );
uart_puts_P("\r\n");
#endif // USE_UART
if ( (data % 300) < 100 ) {
i2c_write(0x00); // write remote buffer address (always)
i2c_write(I2C_DISP_DATA); // write command
i2c_write(data & 0xff); // write data bytes to remote buffer
i2c_write((data & 0xff00) >> 8);
i2c_write(data & 0xff);
i2c_write((data & 0xff00) >> 8);
i2c_stop();
}
// fill menu_dir file-list
// skipping "start" number of entries while scanning FAT
void menu_builtdir(uint16_t start)
{
FRESULT res;
res = f_opendir(&dir, ".");
if (res) { uart_puts_P("f_opendir failed\r\n"); return; }
for(;;)
{
res = f_readdir(&dir, &Finfo);
if ((res != FR_OK) || !Finfo.fname[0])
break;
fn = *Finfo.lfname ? Finfo.lfname : Finfo.fname;
if (fn[0] == '.') continue;
if(Finfo.fattrib & AM_DIR)
uart_puts_P("/");
if(strstr(strlwr(fn), ".mp3")) // FIXME: memory leak?
{
}
}
}
static date_t parse_date(void) {
char* date_pos;
checked_r(char* token = parse_string(), 0);
char* ds = strtok_r(token, ".", &date_pos);
char* ms = strtok_r(NULL, ".", &date_pos);
char* ys = strtok_r(NULL, ".", &date_pos);
#ifdef COMMANDLINE_DEBUG
if ( !is_number(ds) || !is_number(ms) || !is_number(ys) ) {
parse_fail = 1;
uart_puts_P("ERR: parse_date: no date");
return 0;
}
#endif
uint8_t d = atoi8(ds);
uint8_t m = atoi8(ms);
uint8_t y = atoi8(ys);
#ifdef COMMANDLINE_DEBUG
if ( d > 31 || m > 12 || y > 99 ) {
parse_fail = 1;
uart_puts_P("ERR: parse_date: invalid date");
return 0;
}
#endif
return date_from_dmy(d, m, y);
}
// TODO: double check datasheet, could be faster (smaller delays)
void humidity_sensor_read(Humidity_Sensor h, char *read_data, uint16_t max_bytes) {
if (h.write) {} // stop complaining
i2c_start(AM2315_TWI_ADDRESS_WRITE); // Sensor doesn't respond to start signal
_delay_ms(2); // TODO: wait could be shorter?
i2c_stop(); // should be woke now
if(i2c_start(AM2315_TWI_ADDRESS_WRITE)) {// tell it to generate the temp and hum
uart_puts_P(PSTR("Couldn't communicate with humidity sensor\r\n"));
return;
}
i2c_write(READREGCODE);
i2c_write(BEGINREG);
i2c_write(NUMREGTOREAD);
i2c_stop();
_delay_ms(10); // TODO: wait could be shorter?
uint8_t ret[NUMBYTESTOSTORE];
i2c_start(AM2315_TWI_ADDRESS_READ); // now read the data
for (int i = 0; i < NUMBYTESTOSTORE - 1; i++) ret[i] = i2c_read(1);
ret[NUMBYTESTOSTORE - 1] = i2c_read(0); // this reads and sends a CRC signal
i2c_stop();
if (ret[0] != READREGCODE || ret[1] != NUMREGTOREAD) {
uart_puts_P(PSTR("Error reading humidity sensor\r\n"));
return;
}
// note that both these values are 10 times what they should be but
// representing with floating point is a terrible idea so we manipulate the
// print statement instead
uint16_t hum = ((ret[2] << 8) | ret[3]);
uint16_t temp = ((ret[4] << 8) | ret[5]); // NOTE that leading bit is sign
uart_printf("Humidity is %d.%d %%RH and Temperature is %s%d.%d C\r\n",
hum / 10, hum % 10, // hum / 10 first, then last digit goes after '.'
ret[4] & 0x80 ? "-" : "", // handle the sign (if leading is set, then neg)
(temp & 0x7f) / 10, temp % 10); // same as humidity except don't count b15
snprintf(read_data, max_bytes, "%d.%d %%RH\r\n", hum / 10, hum % 10);
}
static uint8_t search_sensors(void)
{
uint8_t i;
uint8_t id[OW_ROMCODE_SIZE];
uint8_t diff, nSensors;
uart_puts_P( NEWLINESTR "Scanning Bus for DS18X20" NEWLINESTR );
ow_reset();
nSensors = 0;
diff = OW_SEARCH_FIRST;
while ( diff != OW_LAST_DEVICE && nSensors < MAXSENSORS ) {
DS18X20_find_sensor( &diff, &id[0] );
if( diff == OW_PRESENCE_ERR ) {
uart_puts_P( "No Sensor found" NEWLINESTR );
break;
}
if( diff == OW_DATA_ERR ) {
uart_puts_P( "Bus Error" NEWLINESTR );
break;
}
for ( i=0; i < OW_ROMCODE_SIZE; i++ )
gSensorIDs[nSensors][i] = id[i];
nSensors++;
}
return nSensors;
}
static time_t parse_time(void) {
char* time_pos;
checked_r(char* token = parse_string(), time_from_hms(0,0,0));
char* hs = strtok_r(token, ":", &time_pos);
char* ms = strtok_r(NULL, ":", &time_pos);
char* ss = strtok_r(NULL, ":", &time_pos);
#ifdef COMMANDLINE_DEBUG
if ( !is_number(hs) || !is_number(ms) || !is_number(ss) ) {
parse_fail = 1;
uart_puts_P("ERR: parse_time: no numbers");
return time_from_hms(0, 0, 0);
}
#endif
uint8_t h = atoi8(hs);
uint8_t m = atoi8(ms);
uint8_t s = atoi8(ss);
#ifdef COMMANDLINE_DEBUG
if ( h >= 24 || m >= 60 || s >= 60 ) {
parse_fail = 1;
uart_puts_P("ERR: parse_time: invalid format");
return time_from_hms(0, 0, 0);
}
#endif
return time_from_hms(h, m, s);
}
/**
* @brief Outputs the current state of the stack
*
* This outputs the current state of the stack using UART. It is used
* within PRINT_STATE_STACK() and will only be compiled when LOG_USER_STATE
* == 1.
*
* @see PRINT_STATE_STACK()
*/
static void printStateStack()
{
uint8_t i=0;
uart_puts_P("stack: [");
for (; i < g_topOfStack; ++i) {
uart_putc(g_stateStack[i] + '0');
uart_putc(' ');
}
for (; i < USER_MAX_STATE_DEPTH; ++i) {
uart_putc('_');
uart_putc(' ');
}
uart_putc(']');
uart_puts_P("top: ");
uart_putc(g_topOfStack + '0');
uart_putc('\n');
}
int main(void){
DDRC = 0x00;
uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
sei();
unsigned int c;
while(1){
c = uart_getc();
if(c & UART_NO_DATA){
/*
* NO UART DATA available
*/
}
else{
/*
* New Data is avialable at the port.
* check the frame for overrun errro
*/
if ( c & UART_FRAME_ERROR ){
/* Framing Error detected, i.e no stop bit detected */
uart_puts_P("UART Frame Error: ");
}
if ( c & UART_OVERRUN_ERROR ){
/*
*
* Overrun, a character already present in the UART UDR register was
*
* not read by the interrupt handler before the next character arrived,
* one or more received characters have been dropped
*
*
*/
uart_puts_P("UART Overrun Error: ");
}
if ( c & UART_BUFFER_OVERFLOW ){
/*
*
* We are not reading the receive buffer fast enough,
*
* one or more received character have been dropped
*
*/
uart_puts_P("Buffer overflow error: ");
}
processData(c);
// PORTC = c;
}
}
return 0;
}
void pcf8583_init(void) {
uint8_t tmp[4];
rtc_state = RTC_NOT_FOUND;
uart_puts_P(PSTR("RTC "));
if (i2c_write_register(PCF8583_ADDR, REG_CONTROL, CTL_START_CLOCK) ||
i2c_read_registers(PCF8583_ADDR, REG_YEAR1, 4, tmp)) {
uart_puts_P(PSTR("not found"));
} else {
if (tmp[0] == (tmp[2] ^ 0xff) &&
tmp[1] == (tmp[3] ^ 0xff)) {
rtc_state = RTC_OK;
uart_puts_P(PSTR("ok"));
/* Dummy RTC read to update the year if required */
struct tm time;
read_rtc(&time);
} else {
rtc_state = RTC_INVALID;
uart_puts_P(PSTR("invalid"));
}
}
uart_putcrlf();
}
void cmd_write (uint64_t cluster, uint8_t adcport, uint64_t maxsize, uint8_t speed)
{
uart_puts_P("Writing...\r\n");
uint16_t maxblocks = maxsize / 512;
uint16_t block = 0;
char c = 0x00;
while(c != 'q')
{
char values[512] = {0x00};
for (uint16_t i = 0; i<=80; ++i)
{
adc_request(adcport);
uint16_t adcvalue = adc_read();
string_append(values, num2str(adcvalue, 10));
string_append(values, "\r\n");
for (uint8_t d = 0; d<=speed; ++d)
_delay_ms(3);
uart_puts(num2str(i, 10));
uart_puts(": ");
uart_puts(num2str(adcvalue, 10));
uart_puts("\r\n");
c = uart_getc();
if (c == 'q') break;
}
fat_write_file(cluster, (unsigned char*)values, block);
++block;
if (block >= maxblocks) break;
}
uart_puts_P("...done\r\n");
}
static void parse_get_humiditysetpoint(void) {
char buf[4];
uart_puts_P("+ ");
uart_puts(itoa8(settings.humidity_setpoint[DAY], buf));
uart_puts_P(" ");
uart_puts(itoa8(settings.humidity_setpoint[NIGHT], buf));
uart_puts_P(NEWLINE);
}
static void parse_get_outputs(void) {
for ( uint8_t i = OUTPUT_FIRST; i < OUTPUT_LAST; i ++ ) {
uart_puts_P("+ ");
portmap_print_output(i);
if ( output_values & _BV(i) ) uart_puts_P(" 1");
else uart_puts_P(" 0");
uart_puts_P(NEWLINE);
}
}
static void th_tl_dump(uint8_t *sp)
{
DS18X20_read_scratchpad( &gSensorIDs[0][0], sp, DS18X20_SP_SIZE );
uart_puts_P( "TH/TL in scratchpad of sensor 1 now : " );
uart_put_int( sp[DS18X20_TH_REG] );
uart_puts_P( " / " );
uart_put_int( sp[DS18X20_TL_REG] );
uart_puts_P( NEWLINESTR );
}
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 show_sp_uart( uint8_t *sp, size_t n )
{
size_t i;
uart_puts_P( "SP:" );
for( i = 0; i < n; i++ ) {
if ( i == n-1 ) uart_puts_P( "CRC:" );
uart_puthex_byte(sp[i]);
uart_puts_P(" ");
}
}
static void parse_get_daytime(void) {
char buf[18];
ttoa(settings.daytime[DAYTIME_BEGIN], buf+0);
ttoa(settings.daytime[DAYTIME_END], buf+9);
buf[8] = ' ';
uart_puts_P("+ ");
uart_puts(buf);
uart_puts_P(NEWLINE);
}
void can_bus_destroy(Can_Bus cb) {
if (cb.pin_count != 2) {
uart_puts_P(
PSTR("Error: Can Bus not initialized with 2 pins\r\n"));
return;
}
*cb.port[0] &= ~_BV(cb.reg_bit[0]); // clear pin before making it an input
*cb.ddr[0] &= ~_BV(cb.reg_bit[0]); // pins should be inputs by default
uart_puts_P(PSTR("Can Bus successfully de-initialized\r\n"));
}
static void uart_put_temp(int16_t decicelsius)
{
char s[10];
uart_put_int( decicelsius );
uart_puts_P(" deci°C, ");
DS18X20_format_from_decicelsius( decicelsius, s, 10 );
uart_puts( s );
uart_puts_P(" °C");
}
static void uart_put_temp_maxres(int32_t tval)
{
char s[10];
uart_put_longint( tval );
uart_puts_P(" °Ce-4, ");
DS18X20_format_from_maxres( tval, s, 10 );
uart_puts( s );
uart_puts_P(" °C");
}
// currently a hardcoded solution
void can_bus_init(Can_Bus cb) {
if (cb.pin_count != 2) {
uart_puts_P(
PSTR("Can Bus needs to be initialized with 2 pins (TX, RX)\r\n"));
return;
}
*cb.ddr[0] |= _BV(cb.reg_bit[0]); // TX is an output so set bit
*cb.ddr[1] &= ~_BV(cb.reg_bit[1]); // RX is input so clear bit
uart_puts_P(PSTR("Can Bus successfully initialized\r\n"));
}
void cmd_ls (uint32_t cluster)
{
uart_puts_P("\r\n|------------------------------------------------------|");
uart_puts_P("\r\n|Filename | Cluster | Attrib | Filesize |");
uart_puts_P("\r\n|------------------------------------------------------|\r\n");
for (uint8_t element = 1; element < 240; ++element)
{
struct fs_entry entry;
entry.cluster = fat_read_dir_ent(cluster, element,
&entry.size, &entry.attrib, (unsigned char *)entry.name);
if (entry.cluster == 0xffff) break;
uart_puts_P("| ");
uart_puts(setlen(entry.name, 15, 0x20));
uart_puts_P(" | ");
uart_puts(setlen(num2str(entry.cluster, 16), 8, 0x20));
uart_puts_P(" | ");
uart_puts(setlen(num2str(entry.attrib, 16), 8, 0x20));
uart_puts_P(" | ");
uart_puts(setlen(num2str(entry.size, 16), 12, 0x20));
uart_puts_P(" | ");
uart_puts("\r\n");
}
uart_puts_P("|------------------------------------------------------|\r\n");
}
uint8_t menu_start(const char *path)
{
Finfo.lfname = Lfname;
Finfo.lfsize = sizeof(Lfname);
res = f_mount(0, &fatfs);
if (res) { uart_puts_P("f_mount failed\r\n"); return; }
res = f_chdir("0:/music");
if (res) { uart_puts_P("f_chdir failed\r\n"); return; }
}
void DS18X20_uart_put_temp(const uint8_t subzero,
const uint8_t cel, const uint8_t cel_frac_bits)
{
uint8_t buffer[sizeof(int)*8+1];
int i;
uart_putc((subzero)?'-':'+');
uart_puti((int)cel);
uart_puts_P(".");
itoa(cel_frac_bits*DS18X20_FRACCONV,buffer,10);
for (i=0;i<4-strlen(buffer);i++) uart_puts_P("0");
uart_puts(buffer);
uart_puts_P("°C");
}
static uint8_t parse_int(void) {
checked_r(char* token = parse_string(), 0);
#ifdef COMMANDLINE_DEBUG
if ( !is_number(token) ) {
parse_fail = 1;
uart_puts_P("ERR: parse_int: no number: >");
uart_puts(token);
uart_puts_P("< " NEWLINE);
}
#endif
return atoi8(token);
}
void loopCommandLine(void) {
// print status if we're not in the menu
if (! menuEnabled) {
if (TimerReached(&cmdline_looptime, 1000)) {
printStatus();
}
}
// check for serial command
unsigned int c = uart_getc();
if (!(c & UART_NO_DATA)) {
if (! menuEnabled) {
menuEnabled=1;
printHelp();
}
switch((char) c) {
case 'x': case 'X': // terminates menu
uart_puts_P("Leaving menu." NEWLINESTR);
menuEnabled=0; break;
case 'b': case 'B': // show PID values
printPID(); break;
case 'r': case 'R': // reset PID values
restorePIDDefault(); break;
case 'o': case 'O': // print out PID debug data
togglePIDDebug(); break;
case 'p':
setPID_P(getPID_P() - delta); printPID(); break;
case 'P':
setPID_P(getPID_P() + delta); printPID();break;
case 'i':
setPID_I(getPID_I() - delta); printPID(); break;
case 'I':
setPID_I(getPID_I() + delta); printPID(); break;
case 'd':
setPID_D(getPID_D() - delta); printPID(); break;
case 'D':
setPID_D(getPID_D() + delta); printPID(); break;
case 't':
setPIDSetpoint(getPIDSetpoint() - delta); printPID(); break;
case 'T':
setPIDSetpoint(getPIDSetpoint() + delta); printPID(); break;
case 's': case 'S':
savePIDConfig(); break;
case '+': {// adjust delta
delta *= 10.0;
if (delta > MAX_DELTA) delta = MAX_DELTA;
uart_print_delta();
break;
}
case '-': {// adjust delta
delta /= 10.0;
if (delta < MIN_DELTA) delta = MIN_DELTA;
uart_print_delta();
break;
}
case '?': // show menu
printHelp(); break;
}
}
}
int main (void)
{
HW_Init();
// enquanto a tensão de entrada estiver abaixo de 8V e acima de 16V, não faz nada
do
{
ADCSRA |= (1<<ADSC);
while (ADCSRA & (1<<ADSC));
} while ((ADC < MIN_VI_COUNT) || (ADC > MAX_VI_COUNT));
VoltInp = ADC;
ADMUX = ((1<<REFS0) | (1<<REFS1)) + VOUT_CH; // feedback do conversor boost
ADCSRA |= (1<<ADIF) | (1<<ADIE); // limpa o flag e habilita interrupção do ADC
tPIsat_params.w_kp_pu = eeprom_read_word(&ee_PI_kp);
tPIsat_params.w_ki_pu = eeprom_read_word(&ee_PI_ki);
tPIsat_params.sp = eeprom_read_word(&ee_PI_SP);
ADCSRA |= (1<<ADSC); // Inicia primeira leitura do ADC
sei();
uart_puts_P(PSTR("Inicio VFD\r"));
vfd_setstring("Felipe Maimon");
for(;;)
{
State_Machine();
}
}
void can_bus_write(Can_Bus cb, char *str, uint16_t max_bytes) {
if (max_bytes) {} // stop complaining
if (cb.pin_count != 2 ||
((*cb.ddr[0] & _BV(cb.reg_bit[0])) == 0) || // TX should be output
((*cb.ddr[1] & _BV(cb.reg_bit[1])) != 0)) { // RX should be input
uart_puts_P(
PSTR("Error: Can Bus not initialized with 2 pins\r\n"));
return;
}
if (str[0] == 1) {
*cb.port[0] |= _BV(cb.reg_bit[0]);
_delay_us(50); // only allow it to turn on for a small amount of time (50us)
*cb.port[0] &= ~_BV(cb.reg_bit[0]);
}
uart_puts_P(PSTR("Successfully actuated CAN BUS for 50 us\r\n"));
}
static void eeprom_test(void)
{
uint8_t sp[DS18X20_SP_SIZE], th, tl;
uart_puts_P( NEWLINESTR "DS18x20 EEPROM support test for first sensor" NEWLINESTR );
// DS18X20_eeprom_to_scratchpad(&gSensorIDs[0][0]); // already done at power-on
th_tl_dump( sp );
th = sp[DS18X20_TH_REG];
tl = sp[DS18X20_TL_REG];
tl++;
th++;
DS18X20_write_scratchpad( &gSensorIDs[0][0], th, tl, DS18B20_12_BIT );
uart_puts_P( "TH+1 and TL+1 written to scratchpad" NEWLINESTR );
th_tl_dump( sp );
DS18X20_scratchpad_to_eeprom( DS18X20_POWER_PARASITE, &gSensorIDs[0][0] );
uart_puts_P( "scratchpad copied to DS18x20 EEPROM" NEWLINESTR );
DS18X20_write_scratchpad( &gSensorIDs[0][0], 0, 0, DS18B20_12_BIT );
uart_puts_P( "TH and TL in scratchpad set to 0" NEWLINESTR );
th_tl_dump( sp );
DS18X20_eeprom_to_scratchpad(&gSensorIDs[0][0]);
uart_puts_P( "DS18x20 EEPROM copied back to scratchpad" NEWLINESTR );
DS18X20_read_scratchpad( &gSensorIDs[0][0], sp, DS18X20_SP_SIZE );
if ( ( th == sp[DS18X20_TH_REG] ) && ( tl == sp[DS18X20_TL_REG] ) ) {
uart_puts_P( "TH and TL verified" NEWLINESTR );
} else {
uart_puts_P( "verify failed" NEWLINESTR );
}
th_tl_dump( sp );
}
/* DS1307 version, checks clock halt bit in seconds register */
void dsrtc_init(void) {
int16_t tmp;
rtc_state = RTC_NOT_FOUND;
uart_puts_P(PSTR("DS1307 "));
tmp = i2c_read_register(RTC_ADDR, REG_SECOND);
if (tmp < 0) {
uart_puts_P(PSTR("not found"));
} else {
if (tmp & STATUS_OSF) {
rtc_state = RTC_INVALID;
uart_puts_P(PSTR("invalid"));
} else {
rtc_state = RTC_OK;
uart_puts_P(PSTR("ok"));
}
}
uart_putcrlf();
}
