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;
}
