void main (void) { unsigned char flags; /* Init the hardware */ flags = catgenie_init(); #ifdef HAS_BLUETOOTH serial_init(BT_BITRATE); bluetooth_init(); serial_term(); #endif /* HAS_BLUETOOTH */ /* Initialize the serial port */ serial_init(BITRATE); printf("\n*** GenieDiag ***\n"); if (!nPOR) { DBG("Power-on reset\n"); flags |= POWER_FAILURE; } else if (!nBOR) { DBG("Brown-out reset\n"); flags |= POWER_FAILURE; } #ifdef __RESETBITS_ADDR else if (!__timeout) DBG("Watchdog reset\n"); else if (!__powerdown) DBG("Pin reset (sleep)\n"); else DBG("Pin reset\n"); #else else
int main(void) { // If transport layer is using UART with flow control we need to get one // GPIOTE user for the CTS wakeup pin. APP_GPIOTE_INIT(1); leds_init(); // Indicate that the application has started up. This can be used to verify that // application resets if reset button is pressed or the chip has been reset with // a debugger. The led will be off during reset. nrf_gpio_pin_set(MAIN_FUNCTION_LED_PIN_NO); connectivity_chip_reset(); bluetooth_init(); // Enter main loop. for (;;) { uint32_t err_code; // Start/restart advertising. if (m_start_adv_flag) { err_code = sd_ble_gap_adv_start(&m_adv_params); APP_ERROR_CHECK(err_code); nrf_gpio_pin_set(ADVERTISING_LED_PIN_NO); m_start_adv_flag = false; } // Power management. power_manage(); } }
/* State behaviour */ void behaviour_welcome(state_ptr state) { /* Set events to react to */ /* Do state actions */ /* Set menu */ osMutexWait(mutex_menuHandle, osWaitForever); menu_copy(&menu_welcome, ¤t_menu); osMutexRelease(mutex_menuHandle); /* Display menu */ uint32_t i; for (i = 0; i < menu_welcome.item_num; i++) { while (osMailPut(queue_lcdHandle, (void *) &menu_welcome.items[i]) != osOK) { osDelay(1); } } /* Do state actions */ bluetooth_init(); osDelay(2500); entry_to_running(state); }
static gboolean bluetooth_init_later(gpointer data) { OhmPlugin *plugin = data; if (plugin_is_real) bluetooth_init(plugin, DBG_BT); return FALSE; }
void init_octopus(void) { sysclk_init(); ioport_init(); leds_init(); bluetooth_init(); //bluetooth_init_interrupt(); switch_init(); //usb_init(); }
static void plugin_init(OhmPlugin *plugin) { OHM_DEBUG_INIT(media); dbusif_init(plugin); dresif_init(plugin); privacy_init(plugin); mute_init(plugin); bluetooth_init(plugin); audio_init(plugin); #if 0 DBG_PRIVACY = DBG_MUTE = DBG_BT = DBG_AUDIO = TRUE; DBG_DBUS = DBG_FS = DBG_DRES = TRUE; #endif }
/** * * @brief Perform basic hardware initialization * * Initialize the interrupt controller and UARTs present in the * platform. * * @return 0 */ static int pc_init(struct sys_device *arg) { ARG_UNUSED(arg); picInit(); /* NOP if not needed */ loapicInit(); /* NOP if not needed */ /* * IOAPIC is initialized with empty interrupt list * If there is a device connected to IOAPIC, the initialization * has to be changed to _IoApicInit (1 << DEV1_IRQ | 1 << DEV2_IRQ) */ ioapicInit(); /* NOP if not needed */ consoleInit(); /* NOP if not needed */ bluetooth_init(); /* NOP if not needed */ return 0; }
/**@brief Function for initializing services that will be used by the application. */ static void services_init(void) { #if 1 bluetooth_init(); #else /* YOUR_JOB: Add code to initialize the services used by the application.*/ uint32_t err_code; ble_adconvert_service_init_t init; // Initialize XXX Service. memset(&init, 0, sizeof(init)); init.evt_handler = on_ble_service_evt; init.ble_adconvert_service_advalue_initial_value.advalue = 0; err_code = ble_adconvert_service_init(&m_adconv, &init); APP_ERROR_CHECK(err_code); #endif }
void init(int use_http, char *address, int port){ // Setup periferal and library init_gui(); init_motors(); init_sensor(); init_compass(); calibrate_compass(0); // 0 = do not execute a new calibration of the compass // Load ball predefined positions get_positions(POINTS_FILE_NAME, &positions, &n_points); // Start bluetooth if(use_http) bluetooth_test_init(address, port); else bluetooth_init(); //bluetooth_register_and_start(fAction_t, fAck_t, fLead_t, fStart_t, fStop_t, fWait_t, fKick_t, fCancel_t); bluetooth_register_and_start(&follower_action_cb, NULL, &lead_cb, &start_cb, &stop_cb, NULL, NULL, &cancel_cb); // Reset global variables send_action_flag = 1; act = 0; end_game = 0; start_game = 0; wait = 0; cancel = 0; // Waiting for the game start set_light(LIT_LEFT, LIT_GREEN); set_light(LIT_RIGHT, LIT_GREEN); while(!start_game); //start game, robot rank and snake size initialized by start_cb // Initial position home.x = BORDER_X_MAX/2; home.y = (snake_size - robot_rank -1)*40 + 20; center.x = BORDER_X_MAX/4; center.y = BORDER_Y_MAX/2; robot = home; printf("[DEBUG] Starting position X: %d, Y: %d, T: %d\n", robot.x , robot.y, robot.t); update_sensor(SENSOR_GYRO); gyro_init_val = get_sensor_value(SENSOR_GYRO); set_light(LIT_LEFT, LIT_OFF); set_light(LIT_RIGHT, LIT_OFF); }
int main(void) { _delay_ms(250); servo_init(); ir_init(); bluetooth_init(); ultrasonic_init(); buttons_init(); sei(); while(1) { comm_exec(); move_proc(); if (button_get_state(1)) move_enable(false); if (button_get_state(2)) move_enable(true); } }
/* State behaviour */ void behaviour_h2h_connect(state_ptr state) { /* Set events to react to */ state->back = h2h_connect_to_main; state->h2h_connect = h2h_connect_to_h2h_ongoing; /* Do state actions */ /* Set menu */ osMailPut(queue_input_menuHandle, (void *) &menu_h2h_connect); /* Display menu */ uint32_t i; for (i = 0; i < menu_h2h_connect.item_num; i++) { osMailPut(queue_lcdHandle, (void *) &menu_h2h_connect.items[i]); } /* Do state actions */ bluetooth_init(); }
int main(void) { _delay_ms(50); init_task_man(); USART_INIT_POLLING(); bluetooth_init(); // USART_INIT_INTERRUPT(); AVC_init(1); sei(); // usart_put_c('t'); _delay_ms(200); // AVC_add_tx_transaction_from_list(SELF_REGISTER); sei(); // wdt_enable( WDTO_2S ); while(1){ // Reset watchdog. // wdt_reset(); process_tasks(); } }
static void* a2dp_thread(void *d) { struct bluetooth_data* data = (struct bluetooth_data*)d; a2dp_command_t command = A2DP_CMD_NONE; int err = 0; DBG("a2dp_thread started"); prctl(PR_SET_NAME, (int)"a2dp_thread", 0, 0, 0); pthread_mutex_lock(&data->mutex); data->started = 1; pthread_cond_signal(&data->thread_start); while (1) { while (1) { pthread_cond_wait(&data->thread_wait, &data->mutex); /* Initialization needed */ if (data->state == A2DP_STATE_NONE && data->command != A2DP_CMD_QUIT) { err = bluetooth_init(data); } /* New state command signaled */ if (command != data->command) { command = data->command; break; } } switch (command) { case A2DP_CMD_CONFIGURE: if (data->state != A2DP_STATE_INITIALIZED) break; err = bluetooth_configure(data); break; case A2DP_CMD_START: if (data->state != A2DP_STATE_CONFIGURED) break; err = bluetooth_start(data); break; case A2DP_CMD_STOP: if (data->state != A2DP_STATE_STARTED) break; err = bluetooth_stop(data); break; case A2DP_CMD_QUIT: bluetooth_close(data); sbc_finish(&data->sbc); a2dp_free(data); goto done; case A2DP_CMD_INIT: /* already called bluetooth_init() */ default: break; } // reset last command in case of error to allow // re-execution of the same command if (err < 0) { command = A2DP_CMD_NONE; } } done: pthread_mutex_unlock(&data->mutex); DBG("a2dp_thread finished"); return NULL; }
void picture_transfer_init() { bluetooth_init(); }
static int __init lenovo_sl_laptop_init(void) { int ret; acpi_status status; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28) if (!acpi_video_backlight_support()) control_backlight = 1; #endif hkey_handle = ec0_handle = NULL; if (acpi_disabled) return -ENODEV; lensl_wq = create_singlethread_workqueue(LENSL_WORKQUEUE_NAME); if (!lensl_wq) { vdbg_printk(LENSL_ERR, "Failed to create a workqueue\n"); return -ENOMEM; } status = acpi_get_handle(NULL, LENSL_HKEY, &hkey_handle); if (ACPI_FAILURE(status)) { vdbg_printk(LENSL_ERR, "Failed to get ACPI handle for %s\n", LENSL_HKEY); return -ENODEV; } status = acpi_get_handle(NULL, LENSL_EC0, &ec0_handle); if (ACPI_FAILURE(status)) { vdbg_printk(LENSL_ERR, "Failed to get ACPI handle for %s\n", LENSL_EC0); return -ENODEV; } lensl_pdev = platform_device_register_simple(LENSL_DRVR_NAME, -1, NULL, 0); if (IS_ERR(lensl_pdev)) { ret = PTR_ERR(lensl_pdev); lensl_pdev = NULL; vdbg_printk(LENSL_ERR, "Failed to register platform device\n"); return ret; } ret = hkey_inputdev_init(); if (ret) return -ENODEV; bluetooth_init(); if (control_backlight) backlight_init(); led_init(); mutex_init(&hkey_poll_mutex); hkey_poll_start(); hwmon_init(); if (debug_ec) lenovo_sl_procfs_init(); vdbg_printk(LENSL_INFO, "Loaded Lenovo ThinkPad SL Series driver\n"); return 0; }
/****************************************************************** * Main-function */ int main(void) { /************************************** * Set the clock to run at 80 MHz */ SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); /************************************** * Enable the floating-point-unit */ FPUEnable(); // We also want Lazystacking, so enable that too FPULazyStackingEnable(); // We also want to put numbers close to zero to zero FPUFlushToZeroModeSet(FPU_FLUSH_TO_ZERO_EN); /************************************** * Init variables */ uint16_t mapData[MAP_DATA_SIZE]; uint8_t stepDir = 0; /************************************** * Init peripherals used */ bluetooth_init(); init_stepper(); // Init the GPIOs used for the stepper and loading LED InitI2C1(); // Init the communication with the lidar-unit through I2C InitPWM(); setupTimers(); /************************************** * State 2 */ // Disable the timers that are used disableTimer(TIMER1_BASE); disableTimer(TIMER2_BASE); // Enable all interrupts IntMasterEnable(); /************************************** * State 3 */ // Indicate we should start with a scan regardless of what other things we have already got // from UART-interrupt // This means setting the appropriate bit in the status vector stat_vec |= TAKE_MEAS; /************************************** * State 4 */ // Contains main-loop where decisions should be made for ( ; ; ) { /********************************** * Decision tree */ // Highest priority case first // Check both interrupts at each iteration in the loop if ( int_vec & UART_INT ) { // Reset the indication int_vec &= ~UART_INT; // Remove drive-stop flag to enable movement stat_vec &= ~DRIVE_STOP; // Init data array uint8_t dataArr[MAX_UART_MSG_SIZE]; // Collect the message if ( readUARTMessage(dataArr, MAX_UART_MSG_SIZE) < SUCCESS ) { // If we have recieved more data than fits in the vector we should simply // go in here again and grab data int_vec |= UART_INT; } // We have gathered a message // and now need to determine what the message is parseMsg(dataArr, MAX_UART_MSG_SIZE); } // Checking drive (movement) interrupt if ( int_vec & TIMER2_INT ) { int_vec &= ~TIMER2_INT; // Disable TIMER2 disableTimer(TIMER2_BASE); // Set drive-stop in status vector stat_vec |= DRIVE_STOP; } // Checking measure interrupt if ( int_vec & TIMER1_INT ) { int_vec &= ~TIMER1_INT; // Disable TIMER1 disableTimer(TIMER1_BASE); // Take reading from LIDAR mapData[stepCount++] = readLidar(); SysCtlDelay(2000); // Take step // Note: We need to take double meas at randvillkor (100) !!!!! if ( stepCount > 0 && stepCount < 100 ) { stepDir = 1; } else if ( stepCount >= 100 && stepCount < 200) { stepDir = 0; } else { stepDir = 1; stepCount = 0; // Reset busy-flag stat_vec &= ~TAKE_MEAS; } step = takeStep(step, stepDir); // Request reading from LIDAR reqLidarMeas(); if ( stat_vec & TAKE_MEAS ) { // Restart TIMER1 enableTimer(TIMER1_BASE, (SYSCLOCK / MEASUREMENT_DELAY)); } else { sendUARTDataVector(mapData, MAP_DATA_SIZE); stat_vec &= ~BUSY; } } // Check the drive_stop flag, which always should be set unless we should move if ( stat_vec & DRIVE_STOP ) { // Stop all movement SetPWMLevel(0,0); halt(); // MAKE SURE all drive-flags are not set stat_vec &= ~(DRIVE_F | DRIVE_L | DRIVE_R | DRIVE_LL | BUSY); } // Should we drive? else if ( stat_vec & DRIVE ) { // Remove drive flag stat_vec &= ~DRIVE; // Increase PWM increase_PWM(0,MAX_FORWARD_SPEED,0,MAX_FORWARD_SPEED); if ( stat_vec & DRIVE_F ) { enableTimer(TIMER2_BASE, DRIVE_FORWARD_TIME); } else if ( stat_vec & DRIVE_LL ) { enableTimer(TIMER2_BASE, DRIVE_TURN_180_TIME); } else { enableTimer(TIMER2_BASE, DRIVE_TURN_TIME); } } if ( !(stat_vec & BUSY) ) { // Tasks switch ( stat_vec ) { case ((uint8_t)DRIVE_F) : // Call drive function go_forward(); // Set the drive flag & BUSY stat_vec |= DRIVE | BUSY; break; case ((uint8_t)DRIVE_L) : // Call drive-left function go_left(); // Set the drive flag stat_vec |= DRIVE | BUSY; break; case ((uint8_t)DRIVE_R) : // Call drive-right function go_right(); // Set the drive flag stat_vec |= DRIVE | BUSY; break; case ((uint8_t)DRIVE_LL) : // Call turn 180-degrees function go_back(); // Set the drive flag stat_vec |= DRIVE | BUSY; break; case ((uint8_t)TAKE_MEAS) : // Request reading from LIDAR reqLidarMeas(); // Start TIMER1 enableTimer(TIMER1_BASE, (SYSCLOCK / MEASUREMENT_DELAY)); // if sysclock = 1 s, 1/120 = 8.3 ms // We are busy stat_vec |= BUSY; break; default: break; } } } }
/*--------------------------------------------------------------------------*/ int main(int argc, char **argv) { /* * Initalize hardware. */ msp430_cpu_init(); clock_init(); uart_init(9600); /* Must come before first printf */ /* xmem_init(); */ PRINTF("iWatch 0.10 build at " __TIME__ " " __DATE__ "\n"); UCSCTL8 &= ~BIT2; /* * Hardware initialization done! */ /* * Initialize Contiki and our processes. */ process_init(); process_start(&etimer_process, NULL); rtimer_init(); ctimer_init(); energest_init(); ENERGEST_ON(ENERGEST_TYPE_CPU); backlight_init(); battery_init(); SPI_FLASH_Init(); if (system_testing()) { clock_time_t t; backlight_on(200, 0); t = clock_seconds(); // sleep 1 while(clock_seconds() - t <= 3); printf("$$OK BACKLIGHT\n"); t = clock_seconds(); while(clock_seconds() - t <= 3); backlight_on(0, 0); motor_on(200, 0); // sleep 1s t = clock_seconds(); while(clock_seconds() - t <= 3); printf("$$OK MOTOR\n"); t = clock_seconds(); while(clock_seconds() - t <= 3); motor_on(0, 0); #if PRODUCT_W001 I2C_Init(); codec_init(); codec_bypass(1); // sleep 1s t = clock_seconds(); while(clock_seconds() - t <= 3); printf("$$OK MIC\n"); // sleep 1s t = clock_seconds(); while(clock_seconds() - t <= 3); codec_bypass(0); codec_shutdown(); #endif } int reason = CheckUpgrade(); window_init(reason); button_init(); rtc_init(); CFSFontWrapperLoad(); system_init(); // check system status and do factor reset if needed I2C_Init(); //codec_init(); //ant_init(); bluetooth_init(); #ifdef PRODUCT_W004 //bmx_init(); #else mpu6050_init(); #endif // check the button status if (button_snapshot() & (1 << BUTTON_UP)) { clock_time_t t; // delay 1 second // button up is pressed, we will set emerging flag motor_on(200, CLOCK_SECOND * 2); t = clock_seconds(); while(clock_seconds() - t <= 1); if (button_snapshot() & (1 << BUTTON_UP)) system_setemerging(); motor_on(0, 0); } if (!system_retail()) { bluetooth_discoverable(1); } #if PRODUCT_W001 if (system_testing()) ant_init(MODE_HRM); #endif system_restore(); // protocol_init(); // protocol_start(1); process_start(&system_process, NULL); /* * This is the scheduler loop. */ msp430_dco_required = 0; /* check firmware update */ if (reason == 0xff) { printf("Start Upgrade\n"); Upgrade(); // never return if sucessfully upgrade } watchdog_start(); while(1) { int r; do { /* Reset watchdog. */ watchdog_periodic(); r = process_run(); } while(r > 0); /* * Idle processing. */ int s = splhigh(); /* Disable interrupts. */ /* uart1_active is for avoiding LPM3 when still sending or receiving */ if(process_nevents() != 0) { splx(s); /* Re-enable interrupts. */ } else { static unsigned long irq_energest = 0; /* Re-enable interrupts and go to sleep atomically. */ ENERGEST_OFF(ENERGEST_TYPE_CPU); ENERGEST_ON(ENERGEST_TYPE_LPM); /* We only want to measure the processing done in IRQs when we are asleep, so we discard the processing time done when we were awake. */ energest_type_set(ENERGEST_TYPE_IRQ, irq_energest); watchdog_stop(); if (shutdown_mode) { system_shutdown(1); // never return LPM4; } if (msp430_dco_required) { __low_power_mode_0(); } else { __low_power_mode_3(); } /* We get the current processing time for interrupts that was done during the LPM and store it for next time around. */ __disable_interrupt(); irq_energest = energest_type_time(ENERGEST_TYPE_IRQ); __enable_interrupt(); watchdog_start(); ENERGEST_OFF(ENERGEST_TYPE_LPM); ENERGEST_ON(ENERGEST_TYPE_CPU); } } }
/**@brief Function for initializing services that will be used by the application. */ static void services_init(void) { uint32_t err_code = bluetooth_init(); APP_ERROR_CHECK(err_code); }
int main () { pio_config_set (LED_GREEN_PIO, PIO_OUTPUT_HIGH); pio_config_set (LED_ORANGE_PIO, PIO_OUTPUT_HIGH); pio_config_set (LED_RED_PIO, PIO_OUTPUT_HIGH); pio_config_set (LED_BLUE_PIO, PIO_OUTPUT_HIGH); /* Initialise i2c */ i2c_motor = i2c_master_init (&i2c_bus_cfg, &i2c_motor_cfg); i2c_camera = i2c_master_init (&i2c_bus_cfg, &i2c_camera_cfg); /* Initialise bluetooth */ bluetooth_t btconn = bluetooth_init(115200); kernel_init (); kernel_taskRegister (bluetooth_comms_task, BLUETOOTH_COMMS_TASK, btconn, 10); kernel_taskRegister (action_commands_task, ACTION_COMMANDS_TASK, btconn, 100); kernel_start (); return 0; }