/***** Initialisation *****/
void init()
{
unsigned char i ;
cli(); // Désactiver toutes les interruptions
sDDR(DDRD,1); // mettre port TX en sortie
sbiBF(PORTD,0); // mettre pull-up sur RX
for(i=0;i<=4;i++) // Initialiser les demandes à 0 qui signifie qu'il n'y a pas de demande de la part de la FoxBoard
{
data[i]=0x00;
}
i2c_init(); // Initialisation interface I2C
init_3964r(); // Initialisation de la communication en protocole 3964 avec la FoxBoard
ENABLE_RX_INT_USART; // Autoriser les interruption série RX
fonctionnement_RX = 1; // mode de réception
init_watchdog(); // Initilise les reset
InitADC(); // Initialise les ADC
sei(); // Activer toutes les interruptions
}
static void plug_devices(void) {
/* Port ranges 0x0 -> 0xF */
port_map[0x0] = init_control();
port_map[0x1] = init_flash();
port_map[0x2] = init_sha256();
port_map[0x3] = init_usb();
port_map[0x4] = init_lcd();
port_map[0x5] = init_intrpt();
port_map[0x6] = init_watchdog();
port_map[0x7] = init_gpt();
port_map[0x8] = init_rtc();
port_map[0x9] = init_protected();
port_map[0xA] = init_keypad();
port_map[0xB] = init_backlight();
port_map[0xC] = init_cxxx();
port_map[0xD] = init_dxxx();
port_map[0xE] = init_exxx();
port_map[0xF] = init_fxxx();
reset_proc_count = 0;
/* Populate reset callbacks */
add_reset_proc(lcd_reset);
add_reset_proc(keypad_reset);
add_reset_proc(gpt_reset);
add_reset_proc(rtc_reset);
add_reset_proc(watchdog_reset);
add_reset_proc(cpu_reset);
gui_console_printf("[CEmu] Initialized APB...\n");
}
int main(void)
{
laser_off();
bootloaderSwitcher();
init_serial_number();
USB_Start();
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
setupJP5();
setupJP6();
setupLeds();
init_watchdog();
setup_interlock();
//debug: flas the light on boot, to watch for watchdog resets
setCoilLed(1);
initialize_led_override();
if (LED_OVERRIDES_EN){
play_long_spin(); //Spin the led's while we load the rest of this stuff
}
initialize_pwm();
initialize_dripper();
setCornerLed(0);
setInLed(0);
setCoilLed(0);
setUSBLed(0);
SysTick_Config(SystemCoreClock / 2000); //48MHz/2000 gives us 2000 ticks per second (2KHz)
int last_drip_count = g_dripcount;
while(1) {
serialio_feed();
updateADC();
if (move_count!=0){
g_twig_coils=0;
g_key_coil_gate=0;
}
if (g_dripcount != last_drip_count) {
last_drip_count = g_dripcount;
send_updated_drip_count();
}
if ((tick % 500) == 0) {
send_printer_status();
}
}
}
t_nmf_error METH(construct)(void)
{
t_uint16 i;
/* Initialize internal private data */
for (i=0; i<RESOURCE_MAX; i++) {
rm_fifo_flush(i);
}
init_watchdog();
rmDebugMode = DBG_MODE_NORMAL;
hwInitDone = FALSE;
return NMF_OK;
} /* end of construct() function */
int Sentinel::start() {
if (!load_config()) {
logging::error("Error opening config file: " + config_path_);
return -1;
}
if (watchdog_path_.length() == 0)
logging::info("Watchdog disabled.");
else if (!init_watchdog())
// watchdog not available
logging::info("Watchdog not available. Continuing without it.");
return watch();
}
int main (void){
init_watchdog();
init_leds();
init_pushbutton();
while(1){
if ((P1IN & BUTTON) == BUTTON){
P1OUT |= 0x01; // LED0 on
P1OUT &= 0xBF; // LED1 off
}
else{
P1OUT &= 0xFE; // LED0 off
P1OUT |= 0x40; // LED on
}
}
return 0;
}
/******************************************************************************
** Function name: main
**
** Description: Program entry point. Contains initializations and menu loop
**
** Parameters: None
** Returned value: Program exit value
**
******************************************************************************/
int main(void)
{
SystemInit();
SystemCoreClockUpdate();
setCANBUS1();
load_nonpersistent();
SysTick_Config(SystemCoreClock / 10); // 100mS Systicker.
I2C1Init();
ADCInit(ADC_CLK);
init_GPIO();
init_watchdog();
while(1){shunt_read();}
return 0;
}
int main(int argc, char* argv[])
{
int ret = EXIT_SUCCESS;
int childstatus;
pid_t pid;
const char taskname[13]="trinity-main";
outputstd("Trinity " VERSION " Dave Jones <*****@*****.**>\n");
progname = argv[0];
initpid = getpid();
page_size = getpagesize();
num_online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
max_children = num_online_cpus; /* possibly overridden in params. */
if (init_random() == FALSE)
exit(EXIT_FAILURE);
set_seed(0);
select_syscall_tables();
create_shm();
/* We do this before the parse_args because --fds will need to
* operate on it when implemented.
*/
setup_fd_providers();
parse_args(argc, argv);
init_uids();
change_tmp_dir();
init_logging();
init_shm();
kernel_taint_initial = check_tainted();
if (kernel_taint_initial != 0)
output(0, "Kernel was tainted on startup. Will ignore flags that are already set.\n");
if (munge_tables() == FALSE) {
ret = EXIT_FAILURE;
goto out;
}
if (show_syscall_list == TRUE) {
dump_syscall_tables();
goto out;
}
init_syscalls();
if (show_ioctl_list == TRUE) {
dump_ioctls();
goto out;
}
do_uid0_check();
if (do_specific_domain == TRUE)
find_specific_domain(specific_domain_optarg);
setup_initial_mappings();
parse_devices();
pids_init();
setup_main_signals();
/* check if we ctrl'c or something went wrong during init. */
if (shm->exit_reason != STILL_RUNNING)
goto cleanup_fds;
init_watchdog();
/* do an extra fork so that the watchdog and the children don't share a common parent */
fflush(stdout);
pid = fork();
if (pid == 0) {
shm->mainpid = getpid();
setup_main_signals();
no_bind_to_cpu = RAND_BOOL();
output(0, "Main thread is alive.\n");
prctl(PR_SET_NAME, (unsigned long) &taskname);
set_seed(0);
if (open_fds() == FALSE) {
if (shm->exit_reason != STILL_RUNNING)
panic(EXIT_FD_INIT_FAILURE); // FIXME: Later, push this down to multiple EXIT's.
exit_main_fail();
}
if (dropprivs == TRUE) //FIXME: Push down into child processes later.
drop_privs();
main_loop();
shm->mainpid = 0;
_exit(EXIT_SUCCESS);
}
/* wait for main loop process to exit. */
(void)waitpid(pid, &childstatus, 0);
/* wait for watchdog to exit. */
waitpid(watchdog_pid, &childstatus, 0);
output(0, "Ran %ld syscalls. Successes: %ld Failures: %ld\n",
shm->stats.total_syscalls_done - 1, shm->stats.successes, shm->stats.failures);
cleanup_fds:
close_sockets();
destroy_initial_mappings();
shutdown_logging();
ret = set_exit_code(shm->exit_reason);
out:
exit(ret);
}
/**
* Main system entry point
*/
int main (void) {
SystemInit();
/* Initialise Pins */
CUTDOWN_OFF();
HEATER_OFF();
MBED_OFF();
GREEN_OFF();
/* Update the value of SystemCoreClock */
SystemCoreClockUpdate();
/* Initialise Interfaces */
i2c_init();
spi_init(process_imu_frame); // IMU
sd_spi_init(); // SD
uart_init(); // GPS
pwrmon_init(); // ADC
/* Initialise Sensors */
init_barometer();
/* SD Card */
if (initialise_card()) { // Initialised to something
if (disk_initialize() == 0) { // Disk initialisation was successful
sd_good = 1;
}
}
GREEN_ON();
/* Configure the SysTick */
NVIC_SetPriority(SysTick_IRQn, 0); // Highest Priority Interrupt
SysTick_Config(SystemCoreClock / RTTY_BAUD);
/* Watchdog - Disabled for debugging */
#ifndef WATCHDOG_DISABLED
init_watchdog();
#endif
struct barometer* b;
struct imu_raw ir;
struct gps_data gd;
struct gps_time gt;
double alt, ext_temp;
int tx_length; // The length of the built tx string
char tx_string[TX_STRING_LENGTH];
while (1) {
/* Grab Data */
pwrmon_start(pwrmon_callback);
b = get_barometer();
get_imu_raw_data(&ir);
get_gps_data(&gd);
get_gps_time(>);
ext_temp = get_temperature();
/* Data Processing */
if (b->valid) {
alt = pressure_to_altitude(b->pressure);
} else {
alt = -1;
b->temperature = -1;
}
/* Act on the data */
control_gsm(alt);
control_cutdown(ticks_until_cutdown, alt);
control_heater(b->temperature);
/* Create a protocol string */
int cutstat;
if (ticks_until_cutdown == 0) {
cutstat = -1;
} else {
cutstat = ticks_until_cutdown / (RTTY_BAUD*60);
}
tx_length = build_communications_frame(tx_string, TX_STRING_LENGTH,
>, b, &gd, alt, ext_temp, &ir,
cutstat, cutdown_voltage);
/* Transmit - Quietly fails if another transmission is ongoing */
rtty_set_string(tx_string, tx_length);
/* Store */
if (sd_good) {
tx_length -= 2; // Remove \n\0
tx_length += communications_frame_add_extra(tx_string + tx_length,
TX_STRING_LENGTH - tx_length, &ir);
disk_write_next_block((uint8_t*)tx_string, tx_length+1); // Include null terminator
}
/* Housekeeping */
GREEN_TOGGLE();
feed_watchdog();
}
}
int main(int argc, char* argv[])
{
int ret = EXIT_SUCCESS;
int childstatus;
unsigned int i;
outputstd("Trinity v" __stringify(VERSION) " Dave Jones <*****@*****.**>\n");
progname = argv[0];
initpid = getpid();
page_size = getpagesize();
num_online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
select_syscall_tables();
if (create_shm())
exit(EXIT_FAILURE);
parse_args(argc, argv);
outputstd("Done parsing arguments.\n");
if (kernel_taint_mask != (int)0xFFFFFFFF) {
outputstd("Custom kernel taint mask has been specified: 0x%08x (%d).\n", kernel_taint_mask, kernel_taint_mask);
}
if (user_specified_children != 0)
max_children = user_specified_children;
else
max_children = sysconf(_SC_NPROCESSORS_ONLN);
if (max_children > MAX_NR_CHILDREN) {
outputerr("Increase MAX_NR_CHILDREN!\n");
exit(EXIT_FAILURE);
}
setup_shm_postargs();
if (logging == TRUE)
open_logfiles();
if (munge_tables() == FALSE) {
ret = EXIT_FAILURE;
goto out;
}
if (show_syscall_list == TRUE) {
dump_syscall_tables();
goto out;
}
init_syscalls();
if (show_ioctl_list == TRUE) {
dump_ioctls();
goto out;
}
if (getuid() == 0) {
if (dangerous == TRUE) {
outputstd("DANGER: RUNNING AS ROOT.\n");
outputstd("Unless you are running in a virtual machine, this could cause serious problems such as overwriting CMOS\n");
outputstd("or similar which could potentially make this machine unbootable without a firmware reset.\n\n");
outputstd("ctrl-c now unless you really know what you are doing.\n");
for (i = 10; i > 0; i--) {
outputstd("Continuing in %d seconds.\r", i);
(void)fflush(stdout);
sleep(1);
}
} else {
outputstd("Don't run as root (or pass --dangerous if you know what you are doing).\n");
exit(EXIT_FAILURE);
}
}
if (do_specific_proto == TRUE)
find_specific_proto(specific_proto_optarg);
init_buffers();
parse_devices();
pids_init();
setup_main_signals();
kernel_taint_initial = check_tainted();
if (kernel_taint_initial != 0) {
output(0, "Kernel was tainted on startup. Will ignore flags that are already set.\n");
}
change_tmp_dir();
/* check if we ctrl'c or something went wrong during init. */
if (shm->exit_reason != STILL_RUNNING)
goto cleanup_fds;
init_watchdog();
do_main_loop();
/* Shutting down. */
waitpid(watchdog_pid, &childstatus, 0);
output(0, "\nRan %ld syscalls. Successes: %ld Failures: %ld\n",
shm->total_syscalls_done - 1, shm->successes, shm->failures);
ret = EXIT_SUCCESS;
cleanup_fds:
close_sockets();
destroy_global_mappings();
if (logging == TRUE)
close_logfiles();
out:
exit(ret);
}
/* Main function */
int main(void) {
sc_time_t my_timer;
int32_t value;
dint();
#if USE_WATCHDOG
init_watchdog();
#else
WDTCTL = WDTCTL_INIT; //Init watchdog timer
#endif
init_ports();
init_clock();
sc_init_timer();
scandal_init();
config_read();
{volatile int i;
for(i=0; i<100; i++)
;
}
/* Below here, we assume we have a config */
/* Send out the error that we've reset -- it's not fatal obviously,
but we want to know when it happens, and it really is an error,
since something that's solar powered should be fairly constantly
powered */
scandal_do_user_err(UNSWMPPTNG_ERROR_WATCHDOG_RESET);
/* Make sure our variables are set up properly */
tracker_status = 0;
/* Initialise FPGA (or, our case, CPLD) stuff */
fpga_init();
/* Starts the ADC and control loop interrupt */
control_init();
/* Initialise the PV tracking mechanism */
pv_track_init();
eint();
my_timer = sc_get_timer();
while (1) {
sc_time_t timeval;
timeval = sc_get_timer();
handle_scandal();
/* pv_track sends data when it feels like it */
pv_track_send_data();
/* Periodically send out the values recorded by the ADC */
if(timeval >= my_timer + TELEMETRY_UPDATE_PERIOD){
my_timer = timeval;
toggle_yellow_led();
#if USE_WATCHDOG
kick_watchdog();
#endif
mpptng_do_errors();
pv_track_send_telemetry();
/* We send the Input current and voltage from
within the pvtrack module */
/* scandal_send_scaled_channel(TELEM_LOW, UNSWMPPTNG_IN_VOLTAGE,
sample_adc(MEAS_VIN1));
scandal_send_scaled_channel(TELEM_LOW, UNSWMPPTNG_IN_CURRENT,
sample_adc(MEAS_IIN1));*/
scandal_send_scaled_channel(TELEM_LOW, UNSWMPPTNG_OUT_VOLTAGE,
sample_adc(MEAS_VOUT));
scandal_send_scaled_channel(TELEM_LOW, UNSWMPPTNG_HEATSINK_TEMP,
sample_adc(MEAS_THEATSINK));
scandal_send_scaled_channel(TELEM_LOW, UNSWMPPTNG_15V,
sample_adc(MEAS_15V));
scandal_send_channel(TELEM_LOW, UNSWMPPTNG_STATUS,
tracker_status);
/* Pre-scale for the temperature */
{
int32_t degC = sample_adc(MEAS_TAMBIENT);
degC = (((degC - 1615)*704*1000)/4095);
scandal_send_scaled_channel(TELEM_LOW, UNSWMPPTNG_AMBIENT_TEMP,
degC);
}
#if DEBUG >= 1
scandal_send_channel(TELEM_LOW, 134, output);
scandal_send_channel(TELEM_LOW, 136, fpga_nFS());
#endif
}
/* If we're not tracking,
check to see that our start-up criteria are satisfied, and then
initialise the control loops and restart tracking */
if((tracker_status & STATUS_TRACKING) == 0){
/* Check the input voltage */
value = sample_adc(MEAS_VIN1);
scandal_get_scaled_value(UNSWMPPTNG_IN_VOLTAGE, &value);
if(value < config.min_vin)
continue;
/* Check the output voltage */
value = sample_adc(MEAS_VOUT);
scandal_get_scaled_value(UNSWMPPTNG_OUT_VOLTAGE, &value);
if(value > config.max_vout)
continue;
tracker_status |= STATUS_TRACKING;
/* Initialise the tracking algorithm */
// pv_track_init();
/* Reset the FPGA */
fs_reset();
/* Initialise the control loop */
control_start();
/* Enable the FPGA */
fpga_enable(FPGA_ON);
}
}
}
int main(int argc, char* argv[])
{
int ret = EXIT_SUCCESS;
unsigned int i;
printf("Trinity v" __stringify(VERSION) " Dave Jones <*****@*****.**> 2012\n");
progname = argv[0];
setup_syscall_tables();
parse_args(argc, argv);
/* If we didn't pass -c or -x, mark all syscalls active. */
if ((do_specific_syscall == FALSE) && (do_exclude_syscall == FALSE))
mark_all_syscalls_active();
if (getuid() == 0) {
if (dangerous == TRUE) {
printf("DANGER: RUNNING AS ROOT.\n");
printf("Unless you are running in a virtual machine, this could cause serious problems such as overwriting CMOS\n");
printf("or similar which could potentially make this machine unbootable without a firmware reset.\n\n");
printf("ctrl-c now unless you really know what you are doing.\n");
for (i = 10; i > 0; i--) {
printf("Continuing in %d seconds.\r", i);
(void)fflush(stdout);
sleep(1);
}
} else {
printf("Don't run as root (or pass --dangerous if you know what you are doing).\n");
exit(EXIT_FAILURE);
}
}
if (create_shm())
exit(EXIT_FAILURE);
/* Set seed in parent thread*/
set_seed(0);
if (desired_group != GROUP_NONE) {
ret = setup_syscall_group(desired_group);
if (ret == FALSE) {
ret = EXIT_FAILURE;
goto cleanup_shm;
}
}
if (show_syscall_list == TRUE) {
dump_syscall_tables();
goto cleanup_shm;
}
if (validate_syscall_tables() == FALSE) {
printf("No syscalls were enabled!\n");
printf("Use 32bit:%d 64bit:%d\n", use_32bit, use_64bit);
goto cleanup_shm;
}
sanity_check_tables();
if (logging == TRUE)
open_logfiles();
if (do_specific_syscall == FALSE) {
if (biarch == TRUE)
output(0, "Fuzzing %d 32-bit syscalls & %d 64-bit syscalls.\n",
max_nr_32bit_syscalls, max_nr_64bit_syscalls);
else
output(0, "Fuzzing %d syscalls.\n", max_nr_syscalls);
}
if (do_specific_proto == TRUE)
find_specific_proto(specific_proto_optarg);
page_size = getpagesize();
init_buffers();
mask_signals();
if (check_tainted() != 0) {
output(0, "Kernel was tainted on startup. Will keep running if trinity causes an oops.\n");
do_check_tainted = TRUE;
}
/* just in case we're not using the test.sh harness. */
chmod("tmp/", 0755);
ret = chdir("tmp/");
if (!ret) {
/* nothing right now */
}
if (shm->exit_reason != STILL_RUNNING)
goto cleanup_fds;
init_watchdog();
do_main_loop();
printf("\nRan %ld syscalls. Successes: %ld Failures: %ld\n",
shm->total_syscalls_done - 1, shm->successes, shm->failures);
ret = EXIT_SUCCESS;
cleanup_fds:
for (i = 0; i < nr_sockets; i++) {
struct linger ling;
ling.l_onoff = FALSE; /* linger active */
setsockopt(shm->socket_fds[i], SOL_SOCKET, SO_LINGER, &ling, sizeof(struct linger));
shutdown(shm->socket_fds[i], SHUT_RDWR);
close(shm->socket_fds[i]);
}
destroy_maps();
if (logging == TRUE)
close_logfiles();
cleanup_shm:
if (shm != NULL)
munmap(shm, sizeof(struct shm_s));
exit(ret);
}
int main(int argc, char* argv[])
{
int ret = EXIT_SUCCESS;
int childstatus;
unsigned int i;
printf("Trinity v" __stringify(VERSION) " Dave Jones <*****@*****.**>\n");
progname = argv[0];
page_size = getpagesize();
select_syscall_tables();
if (create_shm())
exit(EXIT_FAILURE);
parse_args(argc, argv);
printf("Done parsing arguments.\n");
setup_shm_postargs();
if (logging == TRUE)
open_logfiles();
if (munge_tables() == FALSE) {
ret = EXIT_FAILURE;
goto out;
}
if (show_syscall_list == TRUE) {
dump_syscall_tables();
goto out;
}
if (show_ioctl_list == TRUE) {
dump_ioctls();
goto out;
}
if (getuid() == 0) {
if (dangerous == TRUE) {
printf("DANGER: RUNNING AS ROOT.\n");
printf("Unless you are running in a virtual machine, this could cause serious problems such as overwriting CMOS\n");
printf("or similar which could potentially make this machine unbootable without a firmware reset.\n\n");
printf("ctrl-c now unless you really know what you are doing.\n");
for (i = 10; i > 0; i--) {
printf("Continuing in %d seconds.\r", i);
(void)fflush(stdout);
sleep(1);
}
} else {
printf("Don't run as root (or pass --dangerous if you know what you are doing).\n");
exit(EXIT_FAILURE);
}
}
if (do_specific_proto == TRUE)
find_specific_proto(specific_proto_optarg);
init_buffers();
parse_devices();
pids_init();
setup_main_signals();
if (check_tainted() != 0) {
output(0, "Kernel was tainted on startup. Will keep running if trinity causes an oops.\n");
ignore_tainted = TRUE;
}
/* just in case we're not using the test.sh harness. */
chmod("tmp/", 0755);
ret = chdir("tmp/");
if (!ret) {
/* nothing right now */
}
if (shm->exit_reason != STILL_RUNNING)
goto cleanup_fds;
init_watchdog();
do_main_loop();
waitpid(shm->watchdog_pid, &childstatus, 0);
printf("\nRan %ld syscalls. Successes: %ld Failures: %ld\n",
shm->total_syscalls_done - 1, shm->successes, shm->failures);
ret = EXIT_SUCCESS;
cleanup_fds:
for (i = 0; i < nr_sockets; i++) {
struct linger ling;
ling.l_onoff = FALSE; /* linger active */
setsockopt(shm->socket_fds[i], SOL_SOCKET, SO_LINGER, &ling, sizeof(struct linger));
shutdown(shm->socket_fds[i], SHUT_RDWR);
close(shm->socket_fds[i]);
}
destroy_maps();
if (logging == TRUE)
close_logfiles();
out:
exit(ret);
}
/** This is where it all starts ++++++++++++++++++++++++++++++++++++++++++
main is entered as a result of one of SEVERAL events:
- Normal startup from press of reset button.
- Battery inserted.
- After DFU (Device Firmware Upgrade) at manufacturing Quality Assurance or user DFU.
- WatchDogTimer expiration and its interrupt handler didn't feed new value.
- Some error occured and
- Spontenous unknown reset.
All subsystems are initalized and any failures are noted and available later in init_status
Since some events occur after tag is deployed and no one can see the LEDs the system continues operating.
After initalizition (including setting up interrupts)
we loop here calling app_sched_execute and sd_app_evt_wait
*/
int main(void)
{
// LEDs first (they're easy and cannot fail) drivers/init/init.c
init_leds();
RED_LED_ON;
if( init_log() ) { init_status |=LOG_FAILED_INIT; }
else { NRF_LOG_INFO("LOG initalized \r\n"); } // subsequent initalizations assume log is working
// start watchdog now in case program hangs up.
// watchdog_default_handler logs error and resets the tag.
init_watchdog(NULL);
// Battery voltage initialization cannot fail under any reasonable circumstance.
battery_voltage_init();
vbat = getBattery();
if( vbat < BATTERY_MIN_V ) { init_status |=BATTERY_FAILED_INIT; }
else NRF_LOG_INFO("BATTERY initalized \r\n");
if(init_sensors() == NRF_SUCCESS )
{
model_plus = true;
NRF_LOG_INFO("Sensors initialized \r\n");
}
// Init NFC ASAP in case we're waking from deep sleep via NFC (todo)
// outputs ID:DEVICEID ,MAC:DEVICEADDR, SW:REVision
set_nfc_callback(app_nfc_callback);
if( init_nfc() ) { init_status |= NFC_FAILED_INIT; }
else { NRF_LOG_INFO("NFC init \r\n"); }
pin_interrupt_init();
if( pin_interrupt_enable(BSP_BUTTON_0, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIO_PIN_PULLUP, button_press_handler) )
{
init_status |= BUTTON_FAILED_INIT;
}
// Initialize BLE Stack. Starts LFCLK required for timer operation.
if( init_ble() ) { init_status |= BLE_FAILED_INIT; }
bluetooth_configure_advertisement_type(STARTUP_ADVERTISEMENT_TYPE);
bluetooth_tx_power_set(BLE_TX_POWER);
bluetooth_configure_advertising_interval(ADVERTISING_INTERVAL_STARTUP);
advertisement_delay = NRF_FICR->DEVICEID[0]&0x0F;
// Priorities 2 and 3 are after SD timing critical events.
// 6, 7 after SD non-critical events.
// Triggers ADC, so use 3.
ble_radio_notification_init(3,
NRF_RADIO_NOTIFICATION_DISTANCE_800US,
on_radio_evt);
// If GATT is enabled BLE init inits peer manager which uses flash.
// BLE init should handle insufficient space gracefully (i.e. erase flash and proceed).
// Flash must be initialized after softdevice.
if(flash_init())
{
NRF_LOG_ERROR("Failed to init flash \r\n");
}
size_t flash_space_remaining = 0;
flash_free_size_get(&flash_space_remaining);
NRF_LOG_INFO("Largest continuous space remaining %d bytes\r\n", flash_space_remaining);
if(4000 > flash_space_remaining)
{
NRF_LOG_INFO("Flash space is almost used, running gc\r\n")
flash_gc_run();
flash_free_size_get(&flash_space_remaining);
NRF_LOG_INFO("Continuous space remaining after gc %d bytes\r\n", flash_space_remaining);
}
else if (flash_record_get(FDS_FILE_ID, FDS_RECORD_ID, sizeof(tag_mode), &tag_mode))
{
NRF_LOG_INFO("Did not find mode in flash, is this first boot? \r\n");
}
else
{
NRF_LOG_INFO("Loaded mode %d from flash\r\n", tag_mode);
}
if( init_rtc() ) { init_status |= RTC_FAILED_INIT; }
else { NRF_LOG_INFO("RTC initialized \r\n"); }
// Initialize lis2dh12 and BME280 - TODO: Differentiate LIS2DH12 and BME280
if (model_plus)
{
lis2dh12_reset(); // Clear memory.
// Enable Low-To-Hi rising edge trigger interrupt on nRF52 to detect acceleration events.
if (pin_interrupt_enable(INT_ACC2_PIN, NRF_GPIOTE_POLARITY_LOTOHI, NRF_GPIO_PIN_NOPULL, lis2dh12_int2_handler) )
{
init_status |= ACC_INT_FAILED_INIT;
}
nrf_delay_ms(10); // Wait for LIS reboot.
// Enable XYZ axes.
lis2dh12_enable();
lis2dh12_set_scale(LIS2DH12_SCALE);
lis2dh12_set_sample_rate(LIS2DH12_SAMPLERATE_RAWv1);
lis2dh12_set_resolution(LIS2DH12_RESOLUTION);
lis2dh12_set_activity_interrupt_pin_2(LIS2DH12_ACTIVITY_THRESHOLD);
NRF_LOG_INFO("Accelerometer configuration done \r\n");
// oversampling must be set for each used sensor.
bme280_set_oversampling_hum (BME280_HUMIDITY_OVERSAMPLING);
bme280_set_oversampling_temp (BME280_TEMPERATURE_OVERSAMPLING);
bme280_set_oversampling_press(BME280_PRESSURE_OVERSAMPLING);
bme280_set_iir(BME280_IIR);
bme280_set_interval(BME280_DELAY);
bme280_set_mode(BME280_MODE_NORMAL);
NRF_LOG_INFO("BME280 configuration done \r\n");
}
// Enter stored mode after boot - or default mode if store mode was not found
app_sched_event_put (&tag_mode, sizeof(&tag_mode), change_mode);
// Initialize repeated timer for sensor read and single-shot timer for button reset
if( init_timer(main_timer_id, APP_TIMER_MODE_REPEATED, MAIN_LOOP_INTERVAL_RAW, main_timer_handler) )
{
init_status |= TIMER_FAILED_INIT;
}
if( init_timer(reset_timer_id, APP_TIMER_MODE_SINGLE_SHOT, BUTTON_RESET_TIME, reboot) )
{
init_status |= TIMER_FAILED_INIT;
}
// Init starts timers, stop the reset
app_timer_stop(reset_timer_id);
// Log errors, add a note to NFC, blink RED to visually indicate the problem
if (init_status)
{
snprintf((char* )NFC_message, NFC_message_length, "Error: %X", init_status);
NRF_LOG_WARNING (" -- Initalization error : %X \r\n", init_status);
for ( int16_t i=0; i<13; i++)
{
RED_LED_ON;
nrf_delay_ms(500u);
RED_LED_OFF;
nrf_delay_ms(500u);
}
}
// Turn green led on if model+ with no errors.
// Power manage turns led off
if (model_plus & !init_status)
{
GREEN_LED_ON;
}
// Turn off red led, leave green on to signal model+ without errors
RED_LED_OFF;
// Wait for sensors to take first sample
nrf_delay_ms(1000);
// Get first sample from sensors
app_sched_event_put (NULL, 0, main_sensor_task);
app_sched_execute();
// Start advertising
bluetooth_advertising_start();
NRF_LOG_INFO("Advertising started\r\n");
// Enter main loop. Executes tasks scheduled by timers and interrupts.
for (;;)
{
app_sched_execute();
// Sleep until next event.
power_manage();
}
}