int main(void) {
uart_init();
adc0_init();
uint16_t adc_value;
char adc_value_str[5];
while(1) {
// Get the ADC value
ADCSRA |= (1 << ADSC); // Start ADC conversion
loop_until_bit_is_clear(ADCSRA, ADSC); // Wait until done
adc_value = ADC; // Read ADC in
// Send the value to UART
snprintf((char *) &adc_value_str, 5, "%d", adc_value);
uart_send_string(adc_value_str); // Send a string to UART
uart_send_string("\r\n"); // Send a string to UART
// Wait
_delay_ms(1000); // Wait 1000ms
}
return(0);
}
/**
* Initializes the High Level System such as IO Pins and Drivers
*/
void high_level_init(void)
{
// Initialize all board pins (early) that are connected internally.
board_io_pins_initialize();
#if ENABLE_TELEMETRY
/* Add default telemetry components */
tlm_component_add("disk");
tlm_component_add("debug");
#endif
/**
* Set-up Timer0 so that delay_ms(us) functions will work.
* This function is used by FreeRTOS run time statistics.
* If FreeRTOS is used, timer will be set-up anyway.
* If FreeRTOS is not used, call it here such that delay_ms(us) functions will work.
*/
vConfigureTimerForRunTimeStats();
/**
* Intentional delay here because this gives the user some time to
* close COM Port at Hyperload and Open it at Hercules
*/
delay_ms(STARTUP_DELAY_MS);
hl_print_line();
/* Print boot info */
#if USE_REDUCED_PRINTF
const unsigned int cpuClock = sys_get_cpu_clock();
const unsigned int sig = cpuClock / (1000 * 1000);
const unsigned int fraction = (cpuClock - (sig*1000*1000)) / 1000;
printf("System Boot @ %u.%u Mhz\n", sig, fraction);
#else
printf("System Boot @ %.3f Mhz\n", sys_get_cpu_clock() / (1000 * 1000.0f));
#endif
if(boot_watchdog_recover == sys_get_boot_type()) {
char taskName[sizeof(FAULT_LAST_RUNNING_TASK_NAME) * 2] = { 0 };
memcpy(&taskName[0], (void*) &(FAULT_LAST_RUNNING_TASK_NAME), sizeof(FAULT_LAST_RUNNING_TASK_NAME));
hl_print_line();
printf("System rebooted after crash. Relevant info:\n"
"PC: 0x%08X. LR: 0x%08X. PSR: 0x%08X\n"
"Possible last running OS Task: '%s'\n",
(unsigned int)FAULT_PC, (unsigned int)FAULT_LR, (unsigned int)FAULT_PSR,
taskName);
hl_print_line();
}
/**
* Initialize the Peripherals used in the system
* I2C2 : Used by LED Display, Acceleration Sensor, Temperature Sensor
* ADC0 : Used by Light Sensor
* SPI0 : Used by Nordic
* SPI1 : Used by SD Card & External SPI Flash Memory
*/
adc0_init();
ssp1_init();
ssp0_init(SPI0_CLOCK_SPEED_MHZ);
if (!I2C2::getInstance().init(I2C2_CLOCK_SPEED_KHZ)) {
puts("ERROR: Possible short on SDA or SCL wire (I2C2)!");
}
/* Initialize nordic wireless mesh network before setting up sys_setup_rit()
* callback since it may access NULL function pointers.
*/
if (!wireless_init()) {
puts("ERROR: Failed to initialize wireless");
}
/* Set-up our RIT callback to perform some background book-keeping
* If FreeRTOS is running, this service is disabled and FreeRTOS
* tick hook will call hl_periodic_service()
* @warning RIT interrupt should be setup before SD card is mounted
* since it relies on our timer.
*/
sys_rit_setup(hl_periodic_service, g_time_per_rit_isr_ms);
/**
* If Flash is not mounted, it is probably a new board and the flash is not
* formatted so format it, alert the user, and try to re-mount it
*/
if(!hl_mount_storage(Storage::getFlashDrive(), " Flash "))
{
printf("FLASH not formatted, formatting now ... ");
printf("%s\n", FR_OK == Storage::getFlashDrive().format() ? "Done" : "Error");
hl_mount_storage(Storage::getFlashDrive(), " Flash ");
}
hl_mount_storage(Storage::getSDDrive(), "SD Card");
/* After SD card is initted, set desired speed for spi1 */
ssp1_set_max_clock(SPI1_CLOCK_SPEED_MHZ);
hl_print_line();
#if LOG_BOOT_INFO_TO_FILE
log_boot_info(__DATE__);
#endif
/* Initialize all sensors of this board. */
if(!hl_init_board_io()) {
hl_print_line();
LD.setLeftDigit('-');
LD.setRightDigit('-');
LE.setAll(0xFF);
}
else {
LD.setNumber(TS.getFarenheit());
}
/* After Flash memory is mounted, try to set node address from a file */
hl_wireless_set_addr_from_file();
srand(LS.getRawValue() + time(NULL));
// Display CPU speed in Mhz on LED display
// LD.setNumber(sys_get_cpu_clock()/(1000*1000));
/* Print memory information before we call main() */
do {
char buff[512] = { 0 };
sys_get_mem_info_str(buff);
printf("%s", buff);
hl_print_line();
} while(0);
hl_handle_board_id();
hl_show_prog_info();
hl_print_line();
puts("Calling your main()");
hl_print_line();
}
/**
* Initializes the High Level System such as IO Pins and Drivers
*/
void high_level_init(void)
{
// Initialize all board pins (early) that are connected internally.
board_io_pins_initialize();
/**
* Initialize the Peripherals used in the system.
* I2C2 : Used by LED Display, Acceleration Sensor, Temperature Sensor
* ADC0 : Used by Light Sensor
* SPI0 : Used by Nordic
* SPI1 : Used by SD Card & External SPI Flash Memory
*/
adc0_init();
ssp1_init();
ssp0_init(SYS_CFG_SPI0_CLK_MHZ);
if (!I2C2::getInstance().init(SYS_CFG_I2C2_CLK_KHZ)) {
puts("ERROR: Possible short on SDA or SCL wire (I2C2)!");
}
/**
* This timer does several things:
* - Makes delay_ms() and delay_us() methods functional.
* - Provides run-time counter for FreeRTOS task statistics (cpu usage)
* - Provides timer needed by SD card init() and mesh network: nordic driver uses delay_us()
*
* The slightly tricky part is that the mesh networking task will start to be serviced every
* one millisecond, so initialize this and immediately initialize the wireless (mesh/nordic)
* so by the time 1ms elapses, the pointers are initalized (and not NULL).
*/
lpc_sys_setup_system_timer();
/* After the Nordic SPI is initialized, initialize the wireless system asap otherwise
* the background task may access NULL pointers of the mesh networking task.
*
* @warning Need SSP0 init before initializing nordic wireless.
* @warning Nordic uses timer delay, so we need the timer setup.
*/
if (!wireless_init()) {
puts("ERROR: Failed to initialize wireless");
}
/* Add default telemetry components if telemetry is enabled */
#if SYS_CFG_ENABLE_TLM
tlm_component_add(SYS_CFG_DISK_TLM_NAME);
tlm_component_add(SYS_CFG_DEBUG_DLM_NAME);
#endif
/**
* User configured startup delay to close Hyperload COM port and re-open it at Hercules serial window.
* Since the timer is setup that is now resetting the watchdog, we can delay without a problem.
*/
delay_ms(SYS_CFG_STARTUP_DELAY_MS);
hl_print_line();
/* Print out CPU speed and what caused the system boot */
hl_print_boot_info();
/**
* If Flash is not mounted, it is probably a new board and the flash is not
* formatted so format it, so alert the user, and try to re-mount it.
*/
if (!hl_mount_storage(Storage::getFlashDrive(), " Flash "))
{
printf("Erasing and formatting SPI flash, this can take a while ... ");
flash_chip_erase();
printf("%s\n", FR_OK == Storage::getFlashDrive().format() ? "Done" : "Error");
if (!hl_mount_storage(Storage::getFlashDrive(), " Flash "))
{
printf("SPI FLASH is possibly damaged!\n");
printf("Page size: %u\n", (unsigned) flash_get_page_size());
printf("Mem size: %u (raw bytes)\n", (unsigned) (flash_get_page_count() * flash_get_page_size()));
}
}
hl_mount_storage(Storage::getSDDrive(), "SD Card");
/* SD card initialization modifies the SPI speed, so after it has been initialized, reset desired speed for spi1 */
ssp1_set_max_clock(SYS_CFG_SPI1_CLK_MHZ);
hl_print_line();
/* File I/O is up, so log the boot message if chosen by the user */
#ifdef SYS_CFG_LOG_BOOT_INFO_FILENAME
log_boot_info(__DATE__);
#endif
/* File I/O is up, so initialize the logger if user chose the option */
#if SYS_CFG_INITIALIZE_LOGGER
logger_init(SYS_CFG_LOGGER_TASK_PRIORITY);
#endif
/* Initialize all sensors of this board and display "--" on the LED display if an error has occurred. */
if(!hl_init_board_io()) {
hl_print_line();
LD.setLeftDigit('-');
LD.setRightDigit('-');
LE.setAll(0xFF);
}
else {
LD.setNumber(TS.getFarenheit());
}
/* After Flash memory is mounted, try to set node address from a file */
hl_wireless_set_addr_from_file();
/* Feed the random seed to get random numbers from the rand() function */
srand(LS.getRawValue() + time(NULL));
/* Print memory information before we call main() */
do {
char buff[512] = { 0 };
sys_get_mem_info_str(buff);
printf("%s", buff);
hl_print_line();
} while(0);
/* Print miscellaneous info */
hl_handle_board_id();
hl_show_prog_info();
hl_print_line();
/* and finally ... call the user's main() method */
puts("Calling your main()");
hl_print_line();
}
int main(void)
{
struct rtc_time_var rtc;
uint8_t timer0_prev_sec;
char buf[256];
#ifdef APP_ADC_EEPROM
uint8_t adc_curr = 0;
uint8_t adc_prev = 0;
int adc_diff;
uint16_t eeprom_index = 0;
uint8_t eeprom_nbr_chars = 0;
#endif
/* Initialize UART0, serial printing over USB on Arduino Mega */
uart0_init();
/* Initialize blinking LED */
led_init();
/* Initialize I2C */
i2c_init();
/* Initialize Timer0 */
timer0_init();
/* Initialize INT4 button */
button_init();
/* Initialize ADC */
adc0_init();
/* Enable global interrupts (used in I2C) */
sei();
/* Added startup delay after IRQ-enable and followed by a boot print */
_delay_ms(1000);
printf("\n\nTiny RTC firmware successfully started!\n\n");
printf("RTC DS1307 I2C-addr:0x%x\n", DS1307);
printf("EEPROM AT24C32 I2C-addr:0x%x\n\n", AT24C32);
rtc_init();
/* Write dummy data to the RTC RAM */
rtc_set_ram_buf((uint8_t *)Dummy_RTC_RAM, strlen(Dummy_RTC_RAM));
/* Write dummy data to the EEPROM */
eeprom_set_data(0, (uint8_t *)Dummy_EEPROM, strlen(Dummy_EEPROM));
_delay_ms(1000);
/* Read and print dummy data from RTC RAM */
memset(buf, 0, sizeof(buf));
rtc_get_ram_buf((uint8_t *)buf, strlen(Dummy_RTC_RAM));
printf("RTC RAM read result:%s\n", buf);
/* Read and print dummy data from EEPROM */
memset(buf, 0, sizeof(buf));
eeprom_get_data(0, (uint8_t *)buf, strlen(Dummy_EEPROM));
printf("EEPROM read result:%s\n\n", buf);
timer0_prev_sec = g_tmr0_sec;
/* Main loop */
while (1) {
if (g_print) {
g_print = 0;
#ifdef APP_ADC_EEPROM
/* Read out stored EEPROM data upon button-press */
eeprom_get_data(0, (uint8_t *)buf, eeprom_index);
printf("Stored data[%d]:\n%s\n", eeprom_index, buf);
#else
/* Dummy print upon button-press */
printf("Button pressed\n");
#endif
}
if (timer0_prev_sec == g_tmr0_sec)
continue;
timer0_prev_sec = g_tmr0_sec;
led_toggle();
rtc_get_time_var(&rtc);
#ifdef APP_ADC_EEPROM
/* Poll the current ADC value to see if there is a +/-10%
* deviation since the last sample.
*/
adc_curr = adc0_get_val_percentage();
adc_diff = adc_curr - adc_prev;
adc_prev = adc_curr;
if (adc_diff > -10 && adc_diff < 10)
continue;
/* Create a char-array containing the RTC-time and the ADC
* percentage value and store it in the EEPROM.
*/
eeprom_nbr_chars = snprintf(buf, 16, "%d%d:%d%d - %d%%\n",
rtc.min_10, rtc.min_1, rtc.sec_10, rtc.sec_1,
adc0_get_val_percentage());
printf("eeprom_index:%d eeprom_nbr_chars:%d %s\n",
eeprom_index, eeprom_nbr_chars, buf);
eeprom_set_data(eeprom_index, (uint8_t *)buf, eeprom_nbr_chars);
eeprom_index += eeprom_nbr_chars;
#else
/* Print out the ADC value and the RTC time every second */
printf("Elapsed RTC time - min:%d%d sec:%d%d\n",
rtc.min_10, rtc.min_1, rtc.sec_10, rtc.sec_1);
printf("Current adc_val:%d %d%%\n\n",
adc0_get_val(), adc0_get_val_percentage());
#endif
}
}
