/*! \brief Initialize ADIS driver
*
*/
void adis_init() {
uint8_t i = 0;
//chMtxInit(&adis_driver.adis_mtx);
//chCondInit(&adis_driver.adis_cv1);
adis_driver.spi_instance = &SPID1;
adis_driver.state = ADIS_IDLE;
adis_driver.reg = ADIS_PRODUCT_ID;
adis_driver.debug_cb_count = 0;
adis_driver.debug_spi_count = 0;
for(i=0; i<ADIS_MAX_TX_BUFFER; ++i) {
adis_driver.adis_txbuf[i] = 0;
adis_cache_data.adis_tx_cache[i] = 0;
}
for(i=0; i<ADIS_MAX_RX_BUFFER; ++i) {
adis_driver.adis_rxbuf[i] = 0xa5;
adis_cache_data.adis_rx_cache[i] = 0xa5;
}
chEvtInit(&adis_dio1_event);
chEvtInit(&adis_spi_cb_txdone_event);
chEvtInit(&adis_spi_cb_newdata);
chEvtInit(&adis_spi_cb_releasebus);
}
// Polling monitor start.
static void tmr_init(void *p) {
chEvtInit(&inserted_event);
chEvtInit(&removed_event);
chSysLock();
cnt = POLLING_INTERVAL;
chVTSetI(&tmr, MS2ST(POLLING_DELAY), tmrfunc, p);
chSysUnlock();
}
/**
* @brief Polling monitor start.
*
* @param[in] sdcp pointer to the @p SDCDriver object
*
* @notapi
*/
static void tmr_init(SDCDriver *sdcp) {
chEvtInit(&inserted_event);
chEvtInit(&removed_event);
chSysLock();
cnt = SDC_POLLING_INTERVAL;
chVTSetI(&tmr, MS2ST(SDC_POLLING_DELAY), tmrfunc, sdcp);
chSysUnlock();
}
/**
* @brief Initializes an instance.
*
* @param[out] mmcp pointer to the @p MMCDriver object
* @param[in] spip pointer to the SPI driver to be used as interface
* @param[in] lscfg low speed configuration for the SPI driver
* @param[in] hscfg high speed configuration for the SPI driver
* @param[in] is_protected function that returns the card write protection
* setting
* @param[in] is_inserted function that returns the card insertion sensor
* status
*
* @init
*/
void mmcObjectInit(MMCDriver *mmcp) {
mmcp->vmt = &mmc_vmt;
mmcp->state = MMC_STOP;
mmcp->config = NULL;
mmcp->block_addresses = FALSE;
chEvtInit(&mmcp->inserted_event);
chEvtInit(&mmcp->removed_event);
}
/**
* @brief Polling monitor start.
*
* @param[in] p pointer to an object implementing @p BaseBlockDevice
*
* @notapi
*/
void sdc_tmr_init(void *p) {
chEvtInit(&sdc_inserted_event);
chEvtInit(&sdc_removed_event);
chEvtInit(&sdc_halt_event);
chEvtInit(&sdc_start_event);
chSysLock();
sdc_debounce_count = sdc_polling_interval;
chVTSetI(&sdc_tmr, MS2ST(sdc_polling_delay), sdc_tmrfunc, p);
chSysUnlock();
}
/*
* Application entry point.
*/
int main(void) {
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
chEvtInit(&eventImuIrq);
chEvtInit(&eventMagnIrq);
chEvtInit(&eventImuRead);
chEvtInit(&eventMagnRead);
chEvtInit(&eventEKFDone);
palSetPadMode(GPIOB, 3, PAL_MODE_OUTPUT_PUSHPULL); // BLUE
palSetPadMode(GPIOB, 4, PAL_MODE_OUTPUT_PUSHPULL); // GREEN
palSetPadMode(GPIOB, 5, PAL_MODE_OUTPUT_PUSHPULL); // RED
chThdCreateStatic(waThreadLed, sizeof(waThreadLed), NORMALPRIO, ThreadLed, NULL );
I2CInitLocal();
configInit();
mavlinkInit();
initSensors();
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE);
TIM_TimeBaseStructure.TIM_Period = 0xFFFFFFFF;
TIM_TimeBaseStructure.TIM_Prescaler = 84 - 1;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM5, &TIM_TimeBaseStructure);
TIM_Cmd(TIM5, ENABLE);
startEstimation();
startSensors();
radioInit();
motorsInit();
extStart(&EXTD1, &extcfg);
extChannelEnable(&EXTD1, 0);
extChannelEnable(&EXTD1, 1);
chEvtBroadcastFlags(&eventEKFDone, EVT_EKF_DONE);
while (TRUE) {
chThdSleepMilliseconds(1000);
}
}
/**
* @brief Initializes an instance.
*
* @param[in] mmcp pointer to the @p MMCDriver object
* @param[in] spip pointer to the SPI driver to be used as interface
* @param[in] lscfg low speed configuration for the SPI driver
* @param[in] hscfg high speed configuration for the SPI driver
* @param[in] is_protected function that returns the card write protection
* setting
* @param[in] is_inserted function that returns the card insertion sensor
* status
*/
void mmcObjectInit(MMCDriver *mmcp, SPIDriver *spip,
const SPIConfig *lscfg, const SPIConfig *hscfg,
mmcquery_t is_protected, mmcquery_t is_inserted) {
mmcp->mmc_state = MMC_STOP;
mmcp->mmc_config = NULL;
mmcp->mmc_spip = spip;
mmcp->mmc_lscfg = lscfg;
mmcp->mmc_hscfg = hscfg;
mmcp->mmc_is_protected = is_protected;
mmcp->mmc_is_inserted = is_inserted;
chEvtInit(&mmcp->mmc_inserted_event);
chEvtInit(&mmcp->mmc_removed_event);
}
/**
* @brief Initializes an instance.
*
* @param[out] mmcp pointer to the @p MMCDriver object
* @param[in] spip pointer to the SPI driver to be used as interface
* @param[in] lscfg low speed configuration for the SPI driver
* @param[in] hscfg high speed configuration for the SPI driver
* @param[in] is_protected function that returns the card write protection
* setting
* @param[in] is_inserted function that returns the card insertion sensor
* status
*
* @init
*/
void mmcObjectInit(MMCDriver *mmcp, SPIDriver *spip,
const SPIConfig *lscfg, const SPIConfig *hscfg,
mmcquery_t is_protected, mmcquery_t is_inserted) {
mmcp->state = MMC_STOP;
mmcp->config = NULL;
mmcp->spip = spip;
mmcp->lscfg = lscfg;
mmcp->hscfg = hscfg;
mmcp->is_protected = is_protected;
mmcp->is_inserted = is_inserted;
mmcp->block_addresses = FALSE;
chEvtInit(&mmcp->inserted_event);
chEvtInit(&mmcp->removed_event);
}
/**
* @brief Initializes the standard part of a @p CANDriver structure.
*
* @param[out] canp pointer to the @p CANDriver object
*
* @init
*/
void canObjectInit(CANDriver *canp) {
canp->state = CAN_STOP;
canp->config = NULL;
chSemInit(&canp->txsem, 0);
chSemInit(&canp->rxsem, 0);
chEvtInit(&canp->rxfull_event);
chEvtInit(&canp->txempty_event);
chEvtInit(&canp->error_event);
canp->status = 0;
#if CAN_USE_SLEEP_MODE
chEvtInit(&canp->sleep_event);
chEvtInit(&canp->wakeup_event);
#endif /* CAN_USE_SLEEP_MODE */
}
bool_t chibios_logInit(const bool_t binaryFile)
{
nvicSetSystemHandlerPriority(HANDLER_PENDSV,
CORTEX_PRIORITY_MASK(15));
if (sdLogInit (NULL) != SDLOG_OK)
goto error;
if (sdLogOpenLog (&pprzLogFile, PPRZ_LOG_DIR, PPRZ_LOG_NAME) != SDLOG_OK)
goto error;
#if LOG_PROCESS_STATE
if (sdLogOpenLog (&processLogFile, PROCESS_LOG_NAME) != SDLOG_OK)
goto error;
#endif
if (sdLoglaunchThread (binaryFile) != SDLOG_OK)
goto error;
chEvtInit (&powerOutageSource);
launchBatterySurveyThread ();
return TRUE;
error:
return FALSE;
}
void Infrared_t::RxInit() {
chEvtInit(&IEvtSrcIrRx);
// GPIO
PinSetupOut(IR_RX_PWR_GPIO, IR_RX_PWR_PIN, omPushPull); // }
PinSet(IR_RX_PWR_GPIO, IR_RX_PWR_PIN); // } Power
PinSetupIn(IR_RX_IN_GPIO, IR_RX_IN_PIN, pudNone); // Input
// ==== Timer ====
RxTimer.Init();
RxTimer.Enable();
RxTimer.SetTopValue(0xFFFF); // Maximum
RxTimer.SetupPrescaler(1000000); // Input Freq: 1 MHz => one tick = 1 uS
//RxTimer.Disable();
// ==== Input queue ====
chMBInit(&imailbox, IRxBuf, IR_RXBUF_SZ);
// ==== Receiving thread ====
chThdCreateStatic(waIRRxThread, sizeof(waIRRxThread), NORMALPRIO, IRRxThread, NULL);
// ==== IRQ ==== PC5
rccEnableAPB2(RCC_APB2ENR_SYSCFGEN, FALSE); // Enable sys cfg controller
SYSCFG->EXTICR[1] &= 0xFFFFFF0F; // EXTI5 is connected to PortC
SYSCFG->EXTICR[1] |= 0x00000020; // EXTI5 is connected to PortC
// Configure EXTI line
EXTI->IMR |= IR_IRQ_MASK; // Interrupt mode enabled
EXTI->EMR &= ~IR_IRQ_MASK; // Event mode disabled
RxIrqWaitFalling();
EXTI->PR = IR_IRQ_MASK; // Clean irq flag
nvicEnableVector(EXTI9_5_IRQn, CORTEX_PRIORITY_MASK(IRQ_PRIO_HIGH));
}
int motor_init(void)
{
_watchdog_id = watchdog_create(WATCHDOG_TIMEOUT_MSEC);
if (_watchdog_id < 0) {
return _watchdog_id;
}
int ret = motor_rtctl_init();
if (ret) {
return ret;
}
chMtxInit(&_mutex);
chEvtInit(&_setpoint_update_event);
configure();
init_filters();
if (_state.input_voltage < MIN_VALID_INPUT_VOLTAGE || _state.input_voltage > MAX_VALID_INPUT_VOLTAGE) {
lowsyslog("Motor: Invalid input voltage: %f\n", _state.input_voltage);
return -1;
}
ret = rpmctl_init();
if (ret) {
return ret;
}
motor_rtctl_stop();
assert_always(chThdCreateStatic(_wa_control_thread, sizeof(_wa_control_thread),
HIGHPRIO, control_thread, NULL));
return 0;
}
static void mpu9150_init(I2CDriver* i2cptr) {
mpu9150_reg_data rdata;
chEvtInit(&mpu9150_data_event);
mpu9150_reset(i2cptr);
rdata = MPU9150_PM1_X_GYRO_CLOCKREF & (~(MPU9150_PM1_SLEEP)); // make sure device is 'awake'
mpu9150_write_pm1(i2cptr, rdata);
rdata = 16; // 2 ms sample period.
mpu9150_write_gyro_sample_rate_div(i2cptr, rdata);
rdata = MPU9150_I2C_BYPASS | MPU9150_INT_LEVEL | MPU9150_LATCH_INT_EN;
mpu9150_write_pin_cfg(i2cptr, rdata);
rdata = MPU9150_A_HPF_RESET | MPU9150_A_SCALE_pm16g;
mpu9150_write_accel_config(i2cptr, rdata);
rdata = MPU9150_G_SCALE_pm2000;
mpu9150_write_gyro_config(i2cptr, rdata);
rdata = MPU9150_INT_EN_DATA_RD_EN;
mpu9150_write_int_enable(i2cptr, rdata);
}
/**
* @brief Initializes a generic full duplex driver object.
* @details The HW dependent part of the initialization has to be performed
* outside, usually in the hardware initialization code.
*
* @param[out] bdup pointer to a @p BulkUSBDriver structure
*
* @init
*/
void bduObjectInit(BulkUSBDriver *bdup) {
bdup->vmt = &vmt;
chEvtInit(&bdup->event);
bdup->state = BDU_STOP;
chIQInit(&bdup->iqueue, bdup->ib, BULK_USB_BUFFERS_SIZE, inotify, bdup);
chOQInit(&bdup->oqueue, bdup->ob, BULK_USB_BUFFERS_SIZE, onotify, bdup);
}
/**
* @brief Initialize the standard part of a @p MACDriver structure.
*
* @param[in] macp pointer to the @p MACDriver object
*/
void macObjectInit(MACDriver *macp) {
chSemInit(&macp->md_tdsem, 0);
chSemInit(&macp->md_rdsem, 0);
#if CH_USE_EVENTS
chEvtInit(&macp->md_rdevent);
#endif
}
void mpl3115a2_start(I2CDriver* i2c) {
uint8_t i = 0;
mpl3115a2_driver.i2c_errors = 0;
mpl3115a2_driver.i2c_instance = i2c;
for(i=0; i<MPL3115A2_MAX_TX_BUFFER; ++i) {
mpl3115a2_driver.txbuf[i] = 0;
}
for(i=0; i<MPL3115A2_MAX_RX_BUFFER; ++i) {
mpl3115a2_driver.rxbuf[i] = 0xa5;
}
mpl3115a2_current_read.mpl_pressure = 0xa5a5a5a5;
mpl3115a2_current_read.mpl_temperature = 0xa5a5a5a5;
chEvtInit(&mpl3115a2_data_event);
chEvtInit(&mpl3115a2_int_event);
}
/**
* @brief Initializes a generic full duplex driver object.
* @details The HW dependent part of the initialization has to be performed
* outside, usually in the hardware initialization code.
*
* @param[out] sdp pointer to a @p SerialDriver structure
* @param[in] inotify pointer to a callback function that is invoked when
* some data is read from the Queue. The value can be
* @p NULL.
* @param[in] onotify pointer to a callback function that is invoked when
* some data is written in the Queue. The value can be
* @p NULL.
*
* @init
*/
void sdObjectInit(SerialDriver *sdp, qnotify_t inotify, qnotify_t onotify) {
sdp->vmt = &vmt;
chEvtInit(&sdp->event);
sdp->state = SD_STOP;
chIQInit(&sdp->iqueue, sdp->ib, SERIAL_BUFFERS_SIZE, inotify, sdp);
chOQInit(&sdp->oqueue, sdp->ob, SERIAL_BUFFERS_SIZE, onotify, sdp);
}
/**
* @brief Initializes a generic full duplex driver object.
* @details The HW dependent part of the initialization has to be performed
* outside, usually in the hardware initialization code.
*
* @param[out] sdup pointer to a @p SerialUSBDriver structure
*
* @init
*/
void sduObjectInit(SerialUSBDriver *sdup) {
sdup->vmt = &vmt;
chEvtInit(&sdup->event);
sdup->flags = CHN_NO_ERROR;
sdup->state = SDU_STOP;
chIQInit(&sdup->iqueue, sdup->ib, SERIAL_USB_BUFFERS_SIZE, inotify, sdup);
chOQInit(&sdup->oqueue, sdup->ob, SERIAL_USB_BUFFERS_SIZE, onotify, sdup);
}
/**
* @brief Initialize the standard part of a @p MACDriver structure.
*
* @param[out] macp pointer to the @p MACDriver object
*
* @init
*/
void macObjectInit(MACDriver *macp) {
macp->state = MAC_STOP;
macp->config = NULL;
chSemInit(&macp->tdsem, 0);
chSemInit(&macp->rdsem, 0);
#if MAC_USE_EVENTS
chEvtInit(&macp->rdevent);
#endif
}
void rtcInit(uint32_t time)
{
RCC->APB1ENR |= RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN; // Enable PWR and RTC perif
PWR->CR |= PWR_CR_DBP; // enable access to RTC, BDC registers
#ifdef EXT32768
RCC->BDCR |= RCC_BDCR_LSEON;
while( (RCC->BDCR & RCC_BDCR_LSERDY) == 0 ) ; // Wait for LSERDY = 1 (LSE is ready)
#else
RCC->CSR |= RCC_CSR_LSION;
while( (RCC->CSR & RCC_CSR_LSIRDY) == 0 ) ; // Wait for LSIRDY = 1 (iternal 40khz rtc oscillator ready)
#endif
RCC->BDCR |= RCC_BDCR_RTCEN | RCC_BDCR_RTCSEL_0;
while( (RTC->CRL & RTC_CRL_RTOFF) == 0 ) ; // Poll RTOFF, wait until its value goes to ‘1’
RTC->CRL |= RTC_CRL_CNF;
RTC->PRLH = 0;
RTC->PRLL = 32768-1;
if(time)
{
RTC->CNTL = time & 0xFFFF;
RTC->CNTH = time >> 16;
RTC->ALRL = 0xFFFF;
RTC->ALRH = 0xFFFF;
}
RTC->CRH = RTC_CRH_SECIE;
RTC->CRL &= ~RTC_CRL_CNF;
while( (RTC->CRL & RTC_CRL_RTOFF) == 0 ) ; // Poll RTOFF, wait until its value goes to ‘1’ to check the end of the write operation.
PWR->CR &= ~PWR_CR_DBP; // disable access to RTC registers
// Init OS depended functions
chEvtInit(&rtcEvtSecond);
chEvtInit(&rtcEvtAlarm);
// Enable interrupt
NVICEnableVector(RTC_IRQn, 0xC0);
}
void PillInit() {
PillDeinit();
PinSetupOut(PERIPH_PWR_GPIO, PERIPH_PWR_PIN, omPushPull); // Power
PinSet(PERIPH_PWR_GPIO, PERIPH_PWR_PIN);
chThdSleepMilliseconds(1); // Allow power to rise
i2c.Init(PILL_I2C, PILL_I2C_GPIO, PILL_SCL_PIN, PILL_SDA_PIN, PILL_I2C_BITRATE_HZ, PILL_DMATX, PILL_DMARX);
// Firmware
chEvtInit(&IEvtPillChange);
// Pills
for(uint8_t i=0; i<PILL_CNT; i++) Pill[i].Init(i);
// Thread
chThdCreateStatic(waPillThread, sizeof(waPillThread), NORMALPRIO, PillThread, NULL);
}
void cc1101_t::Init() {
// ==== GPIO ====
PinSetupOut(GPIOA, CC_CS, omPushPull);
PinSetupAlterFuncOutput(GPIOA, CC_SCK, omPushPull);
PinSetupAlterFuncOutput(GPIOA, CC_MISO, omPushPull);
PinSetupAlterFuncOutput(GPIOA, CC_MOSI, omPushPull);
PinSetupIn(GPIOA, CC_GDO0, pudNone);
PinSetupIn(GPIOA, CC_GDO2, pudNone);
CsHi();
// ==== SPI ==== MSB first, master, ClkLowIdle, FirstEdge, Baudrate=f/2
SpiSetup(CC_SPI, boMSB, cpolIdleLow, cphaFirstEdge, sbFdiv2);
SpiEnable(CC_SPI);
// ==== Init CC ====
CReset();
FlushRxFIFO();
RfConfig();
chEvtInit(&IEvtSrcRx);
chEvtInit(&IEvtSrcTx);
State = ccIdle;
// ==== IRQ ====
RCC->APB2ENR |= RCC_APB2ENR_AFIOEN; // Enable AFIO clock
uint8_t tmp = CC_GDO0 / 4; // Indx of EXTICR register
uint8_t Shift = (CC_GDO0 & 0x03) * 4;
AFIO->EXTICR[tmp] &= ~((uint32_t)0b1111 << Shift); // Clear bits and leave clear to select GPIOA
tmp = 1<<CC_GDO0; // IRQ mask
// Configure EXTI line
EXTI->IMR |= tmp; // Interrupt mode enabled
EXTI->EMR &= ~tmp; // Event mode disabled
EXTI->RTSR &= ~tmp; // Rising trigger disabled
EXTI->FTSR |= tmp; // Falling trigger enabled
EXTI->PR = tmp; // Clean irq flag
nvicEnableVector(EXTI4_IRQn, CORTEX_PRIORITY_MASK(IRQ_PRIO_MEDIUM));
}
/**
* @brief Buzzer driver initialization.
*/
void buzzInit(void) {
chEvtInit(&BuzzerSilentEventSource);
/*
* Switches P0.12 and P0.13 to MAT1.0 and MAT1.1 functions.
* Enables Timer1 clock.
*/
PINSEL0 &= 0xF0FFFFFF;
PINSEL0 |= 0x0A000000;
PCONP = (PCONP & PCALL) | PCTIM1;
/*
* Timer setup.
*/
TC *tc = T1Base;
StopCounter(tc);
tc->TC_CTCR = 0; /* Clock source is PCLK. */
tc->TC_PR = 0; /* Prescaler disabled. */
tc->TC_MCR = 2; /* Clear TC on match MR0. */
}
static void evt1_execute(void) {
EventListener el1, el2;
/*
* Testing chEvtRegisterMask() and chEvtUnregister().
*/
chEvtInit(&es1);
chEvtRegisterMask(&es1, &el1, 1);
chEvtRegisterMask(&es1, &el2, 2);
test_assert(1, chEvtIsListeningI(&es1), "no listener");
chEvtUnregister(&es1, &el1);
test_assert(2, chEvtIsListeningI(&es1), "no listener");
chEvtUnregister(&es1, &el2);
test_assert(3, !chEvtIsListeningI(&es1), "stuck listener");
/*
* Testing chEvtDispatch().
*/
chEvtDispatch(evhndl, 7);
test_assert_sequence(4, "ABC");
}
static msg_t
vexAudioTask( void *arg )
{
uint32_t tmpCounter;
(void)arg;
chRegSetThreadName("audio");
chEvtInit(&sound_done);
while(!chThdShouldTerminate())
{
if(VSL_Counter > 0)
{
tmpCounter = VSL_Counter;
VSL_Counter = 0;
// wait for semaphore timeout or other thread reseting the semaphore
chSemWaitTimeout( &vslSem, tmpCounter );
chSysLock();
if( chEvtIsListeningI(&sound_done) )
chEvtBroadcastI(&sound_done);
chSysUnlock();
if( VSL_Counter == 0 )
{
if( !vexAudioPlayNextChipTone() )
VSL_Deinit();
}
}
else
chSemWait( &vslSem );
}
return (msg_t)0;
}
/*!
* Initialize event for wakup button on olimex board.
*/
void extdetail_init() {
chEvtInit(&extdetail_wkup_event);
chEvtInit(&extdetail_launch_detect_event);
}
/*------------------------------------------------------------------------*
* chibios_rt::EvtSource *
*------------------------------------------------------------------------*/
EvtSource::EvtSource(void) {
chEvtInit(&ev_source);
}
int main(void) {
static Thread *shelltp = NULL;
static const evhandler_t evhndl[] = {
InsertHandler,
RemoveHandler,
packetReceivedHandler
};
struct EventListener el0, el1, el2;
chEvtRegister(&packet_event, &el2, 0);
chEvtInit(&packet_event);
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Initializes a serial-over-USB CDC driver.
*/
sduObjectInit(&SDU1);
sduStart(&SDU1, &serusbcfg);
/*
* Activates the USB driver and then the USB bus pull-up on D+.
* Note, a delay is inserted in order to not have to disconnect the cable
* after a reset.
*/
usbDisconnectBus(serusbcfg.usbp);
chThdSleepMilliseconds(1000);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
/*
* Shell manager initialization.
*/
shellInit();
/*
* Activates the serial driver 6 and SDC driver 1 using default
* configuration.
*/
sdStart(&SD6, NULL);
sdcStart(&SDCD1, NULL);
/*
* Activates the card insertion monitor.
*/
tmr_init(&SDCD1);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Creates the LWIP threads (it changes priority internally).
*/
chThdCreateStatic(wa_lwip_thread, LWIP_THREAD_STACK_SIZE, NORMALPRIO + 2,
lwip_thread, NULL);
/*
* Creates the HTTP thread (it changes priority internally).
*/
/*
chThdCreateStatic(wa_http_server, sizeof(wa_http_server), NORMALPRIO + 1,
http_server, NULL);
*/
WORKING_AREA(wa_udp_receive_server, PWM_REC_STACK_SIZE);
chThdCreateStatic(wa_udp_receive_server, sizeof(wa_udp_receive_server), NORMALPRIO +1,
udp_receive_server_init, NULL);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and listen for events.
*/
chEvtRegister(&inserted_event, &el0, 0);
chEvtRegister(&removed_event, &el1, 1);
while (TRUE) {
if (!shelltp && (SDU1.config->usbp->state == USB_ACTIVE))
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
else if (chThdTerminated(shelltp)) {
chThdRelease(shelltp); /* Recovers memory of the previous shell. */
shelltp = NULL; /* Triggers spawning of a new shell. */
}
if (palReadPad(GPIOA, GPIOA_BUTTON_WKUP) != 0) {
}
chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500)));
}
}
/*------------------------------------------------------------------------*
* chibios_rt::Event *
*------------------------------------------------------------------------*/
Event::Event(void) {
chEvtInit(&event);
}
/*!
* Initialize event for wakup button on olimex board.
*/
void extdetail_init() {
chEvtInit(&extdetail_wkup_event);
}