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();
/*
*
* 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+.
*
*/
usbDisconnectBus(serusbcfg.usbp);
chThdSleepMilliseconds(500);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
/*
*
* Start I2C and set up sensors
*
*/
i2cStart(&I2CD2, &i2cfg2);
/* Initialize Accelerometer and Gyroscope */
if (MPU6050Init(&mpu6050cfg) != MSG_OK)
panic("MPU6050 init failed"); /* Initialization failed */
/* Initialize Magnetometer */
if (HMC5983Init(&hmc5983cfg) != MSG_OK)
panic("HMC5983 init failed"); /* Initialization failed */
/* Initialize Barometer */
/* TODO: Add barometer code */
/* Initialize sensor readout */
if (SensorReadInit(&mpu6050cfg, &hmc5983cfg,
&mpu6050cal, &hmc5983cal) != MSG_OK)
panic("Sensor Read init failed"); /* Initialization failed */
/*
*
* Start the external interrupts
*
*/
extStart(&EXTD1, &extcfg);
/*
*
* Initialize the RC Outputs
*
*/
if (RCOutputInit(&rcoutputcfg) != MSG_OK)
panic("RC output init failed"); /* Initialization failed */
/*
*
* Start RC Inputs
*
*/
eicuInit();
eicuStart(&EICUD9, &rcinputcfg);
eicuEnable(&EICUD9);
/*
*
* Start test thread
*
*/
chThdCreateStatic( waThreadTestEvents,
sizeof(waThreadTestEvents),
HIGHPRIO,
ThreadTestEvents,
NULL);
while(1)
{
chThdSleepMilliseconds(100);
if (isUSBActive() == true)
chprintf((BaseSequentialStream *)&SDU1, "Input width: %u\r\n", ic_test);
}
}
/*
* 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();
/*
* Initializes the PWM driver 2 and ICU driver 3.
* GPIOA8 is the PWM output.
* GPIOC6 is the ICU input.
* The two pins have to be externally connected together.
*/
pwmStart(&PWMD1, &pwmcfg);
palSetPadMode(GPIOA, 8, PAL_MODE_ALTERNATE(1));
icuStart(&ICUD3, &icucfg);
palSetPadMode(GPIOC, 6, PAL_MODE_ALTERNATE(2));
icuEnable(&ICUD3);
chThdSleepMilliseconds(2000);
/*
* Starts the PWM channel 0 using 75% duty cycle.
*/
pwmEnableChannel(&PWMD1, 0, PWM_PERCENTAGE_TO_WIDTH(&PWMD1, 7500));
chThdSleepMilliseconds(5000);
/*
* Changes the PWM channel 0 to 50% duty cycle.
*/
pwmEnableChannel(&PWMD1, 0, PWM_PERCENTAGE_TO_WIDTH(&PWMD1, 5000));
chThdSleepMilliseconds(5000);
/*
* Changes the PWM channel 0 to 25% duty cycle.
*/
pwmEnableChannel(&PWMD1, 0, PWM_PERCENTAGE_TO_WIDTH(&PWMD1, 2500));
chThdSleepMilliseconds(5000);
/*
* Changes PWM period to half second the duty cycle becomes 50%
* implicitly.
*/
pwmChangePeriod(&PWMD1, 5000);
chThdSleepMilliseconds(5000);
/*
* Disables channel 0 and stops the drivers.
*/
pwmDisableChannel(&PWMD1, 0);
pwmStop(&PWMD1);
icuDisable(&ICUD3);
icuStop(&ICUD3);
palClearPad(GPIOD, GPIOD_LED4);
palClearPad(GPIOD, GPIOD_LED5);
/*
* Normal main() thread activity, in this demo it does nothing.
*/
while (TRUE) {
chThdSleepMilliseconds(500);
}
return 0;
}
//-----------------------------------------------------------------------------
int
kuroBoxInit(void)
{
halInit();
chSysInit();
PWR->CSR &= ~PWR_CSR_EWUP;
kbg_setLED1(1);
kbg_setLED2(1);
kbg_setLED3(1);
// Serial
kuroBoxSerialInit(NULL, NULL);
// start the SPI bus, just use the LCD's SPI config since
// it's shared with the eeprom
spiStart(&SPID1, &lcd_cfg.spicfg);
memset(lcd_buffer, 0, sizeof(lcd_buffer));
st7565Start(&ST7565D1, &lcd_cfg, &SPID1, lcd_buffer);
// EEPROM
spiEepromStart(&spiEepromD1, &eeprom_cfg, &SPID1);
// SDIO
sdcStart(&SDCD1, &sdio_cfg);
// just blink to indicate we haven't crashed
#ifdef HAVE_BLINK_THREAD
blinkerThread = chThdCreateStatic(waBlinker, sizeof(waBlinker), NORMALPRIO, thBlinker, NULL);
#endif // HAVE_BLINK_THREAD
// read config goes here
// @TODO: add config reading from eeprom
// ADC to monitor voltage levels.
// start all the ADC stuff!
kuroBoxADCInit();
// init the screen, this will spawn a thread to keep it updated
kuroBoxScreenInit();
// LTC's, interrupt driven, very quick now
// Note, this module must be init'd after the screen
kuroBoxTimeInit();
// the actual logging thread
kuroBoxWriterInit();
// this turns on Layer 1 power, this turns on the mosfets controlling the
// VCC rail. After this, we can start GPS, VectorNav and altimeter
kbg_setL1PowerOn();
// wait for it to stabilise, poweron devices, and let them start before continuing
chThdSleepMilliseconds(500);
// gps uart
kuroBoxGPSInit(&SD6);
VND1.spip = &SPID2;
VND1.gpdp = &GPTD14;
kuroBoxVectorNavInit(&VND1, NULL); // use the defaults
// start I2C here, since it's a shared bus
i2cStart(&I2CD2, &i2cfg2);
// and the altimeter, also spawns a thread.
kuroBoxAltimeterInit();
// init the menu structure, and thread, if needed
kuroBoxMenuInit();
// set initial button state, AFTER menus!
kuroBoxButtonsInit();
// read all configs from bksram and load them up thoughout the system
kuroBoxConfigInit();
// Feature "A" - just a test feature that sends updates over serial
kuroBoxExternalDisplayInit();
// indicate we're ready
chprintf(DEBG, "%s\n\r\n\r", BOARD_NAME);
chThdSleepMilliseconds(50);
kbg_setLED1(0);
kbg_setLED2(0);
kbg_setLED3(0);
// all external interrupts, all the system should now be ready for it
extStart(&EXTD1, &extcfg);
return KB_OK;
}
/*
* Application entry point.
*/
int main(void) {
static const evhandler_t evhndl[] = {
InsertHandler,
RemoveHandler,
ShellHandler
};
event_listener_t el0, el1, el2;
/*
* 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(1500);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
/*
* Shell manager initialization.
*/
shellInit();
/*
* Activates the card insertion monitor.
*/
tmr_init(&SDCD1);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Normal main() thread activity, handling SD card events and shell
* start/exit.
*/
chEvtRegister(&inserted_event, &el0, 0);
chEvtRegister(&removed_event, &el1, 1);
chEvtRegister(&shell_terminated, &el2, 2);
while (true) {
if (!shelltp && (SDU1.config->usbp->state == USB_ACTIVE)) {
shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE,
"shell", NORMALPRIO + 1,
shellThread, (void *)&shell_cfg1);
}
chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500)));
}
}
/*
* Application entry point.
*/
int main(void) {
color_t color = Black;
uint16_t pen = 0;
Thread *shelltp = NULL;
/*
* 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();
gdispInit();
ginputGetMouse(0);
gdispSetOrientation(GDISP_ROTATE_90);
drawScreen();
/*
* 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();
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state.
*/
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. */
}
ginputGetMouseStatus(0, &ev);
if (!(ev.current_buttons & GINPUT_MOUSE_BTN_LEFT))
{
chThdSleepMicroseconds(500); // Senza questo sleep l'USB non parte
continue;
}
/* inside color box ? */
if(ev.y >= OFFSET && ev.y <= COLOR_SIZE) {
if(GET_COLOR(0)) color = Black;
else if(GET_COLOR(1)) color = Red;
else if(GET_COLOR(2)) color = Yellow;
else if(GET_COLOR(3)) color = Green;
else if(GET_COLOR(4)) color = Blue;
else if(GET_COLOR(5)) color = White;
/* inside pen box ? */
} else if(ev.x >= OFFSET && ev.x <= PEN_SIZE) {
if(GET_PEN(1)) pen = 0;
else if(GET_PEN(2)) pen = 1;
else if(GET_PEN(3)) pen = 2;
else if(GET_PEN(4)) pen = 3;
else if(GET_PEN(5)) pen = 4;
/* inside drawing area ? */
} else if(DRAW_AREA(ev.x, ev.y)) {
if(pen == 0)
gdispDrawPixel(ev.x, ev.y, color);
else
gdispFillCircle(ev.x, ev.y, pen, color);
}
}
}
/*------------------------------------------------------------------------*
* chibios_rt::System *
*------------------------------------------------------------------------*/
void System::Init(void) {
chSysInit();
}
/*
* Application entry point.
*/
int main(void) {
thread_t *shelltp1 = NULL;
thread_t *shelltp2 = NULL;
/*
* 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, &serusbcfg1);
sduObjectInit(&SDU2);
sduStart(&SDU2, &serusbcfg2);
/*
* 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(serusbcfg1.usbp);
chThdSleepMilliseconds(1500);
usbStart(serusbcfg1.usbp, &usbcfg);
usbConnectBus(serusbcfg1.usbp);
/*
* Shell manager initialization.
*/
shellInit();
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state.
*/
while (true) {
if (!shelltp1 && (SDU1.config->usbp->state == USB_ACTIVE))
shelltp1 = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
else if (chThdTerminatedX(shelltp1)) {
chThdRelease(shelltp1); /* Recovers memory of the previous shell. */
shelltp1 = NULL; /* Triggers spawning of a new shell. */
}
if (!shelltp2 && (SDU2.config->usbp->state == USB_ACTIVE))
shelltp2 = shellCreate(&shell_cfg2, SHELL_WA_SIZE, NORMALPRIO);
else if (chThdTerminatedX(shelltp2)) {
chThdRelease(shelltp2); /* Recovers memory of the previous shell. */
shelltp2 = NULL; /* Triggers spawning of a new shell. */
}
chThdSleepMilliseconds(1000);
}
}
/* Main thread
*/
int main(void) {
/* ChibiOS/RT init */
halInit();
chSysInit();
#ifdef STM32F303xC
EEPROM_init();
#endif
// TESTING
// chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/* Init USB */
init_usb_driver(&USB_DRIVER);
/* init printf */
init_printf(NULL,sendchar_pf);
#ifdef MIDI_ENABLE
setup_midi();
#endif
#ifdef SERIAL_LINK_ENABLE
init_serial_link();
#endif
#ifdef VISUALIZER_ENABLE
visualizer_init();
#endif
host_driver_t* driver = NULL;
/* Wait until the USB or serial link is active */
while (true) {
if(USB_DRIVER.state == USB_ACTIVE) {
driver = &chibios_driver;
break;
}
#ifdef SERIAL_LINK_ENABLE
if(is_serial_link_connected()) {
driver = get_serial_link_driver();
break;
}
serial_link_update();
#endif
wait_ms(50);
}
/* Do need to wait here!
* Otherwise the next print might start a transfer on console EP
* before the USB is completely ready, which sometimes causes
* HardFaults.
*/
wait_ms(50);
print("USB configured.\n");
/* init TMK modules */
keyboard_init();
host_set_driver(driver);
#ifdef SLEEP_LED_ENABLE
sleep_led_init();
#endif
print("Keyboard start.\n");
/* Main loop */
while(true) {
if(USB_DRIVER.state == USB_SUSPENDED) {
print("[s]");
#ifdef VISUALIZER_ENABLE
visualizer_suspend();
#endif
while(USB_DRIVER.state == USB_SUSPENDED) {
/* Do this in the suspended state */
#ifdef SERIAL_LINK_ENABLE
serial_link_update();
#endif
suspend_power_down(); // on AVR this deep sleeps for 15ms
/* Remote wakeup */
if(suspend_wakeup_condition()) {
usbWakeupHost(&USB_DRIVER);
}
}
/* Woken up */
// variables has been already cleared by the wakeup hook
send_keyboard_report();
#ifdef MOUSEKEY_ENABLE
mousekey_send();
#endif /* MOUSEKEY_ENABLE */
#ifdef VISUALIZER_ENABLE
visualizer_resume();
#endif
}
keyboard_task();
#ifdef CONSOLE_ENABLE
console_task();
#endif
#ifdef VIRTSER_ENABLE
virtser_task();
#endif
#ifdef RAW_HID_ENABLE
raw_hid_task();
#endif
}
}
THD_TABLE_END
#define RK_AS_MATRIX_SCANNER_THD( scanner, id, name, config ) \
THD_TABLE_ENTRY( id ## WA, name, scanner ## F, config )
/*
* Application entry point.
*/
int main(void) {
/* Disable watchdog if enabled by bootloader/fuses */
MCUSR &= ~(1 << WDRF);
wdt_disable();
/* Disable clock division */
clock_prescale_set(clock_div_1);
/* Global interrupt enable: */
sei();
// Matrix with layout from RAM:
DEFINE_SCANNER( scanner, matrix, false );
rkas_init( &scanner );
rkas_init_a( &scanner );
// Matrix with layout from progmem:
DEFINE_SCANNER( scanner_P, matrix_P, true );
rkas_init( &scanner_P );
rkas_init_a( &scanner_P );
// Matrix with layout from RAM, but loaded from EEPROM:
RkASMatrix matrix_E;
rkas_load_from_eeprom( &matrix_E, NULL );
DEFINE_SCANNER( scanner_E, matrix_E, false );
rkas_init( &scanner_E );
rkas_init_a( &scanner_E );
// KBDMatrixScanner scanner;
// scanner_a( &scanner, matrix );
// scanner_a( &scanner, matrix_P );
/*
* 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();
/* This is now the idle thread loop, you may perform here a low priority
task but you must never try to sleep or wait in this loop. Note that
this tasks runs at the lowest priority level so any instruction added
here will be executed after all other tasks have been started.*/
while (true) {
}
}
/*
* Application entry point.
*/
int main(void) {
Thread *shelltp0 = NULL;
Thread *shelltp2 = NULL;
unsigned int i = 0;
/*
* 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);
// Activate all serial drivers.
sdStart(&SD1, NULL);
sdStart(&SD2, NULL);
sdStart(&SD3, NULL);
sdStart(&SD4, NULL);
sdStart(&SD5, NULL);
sdStart(&SD6, NULL);
// Activates the UART driver 1, PA9(TX) and PA10(RX) are routed to USART1.
palSetPadMode(GPIOB, 6, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOB, 7, PAL_MODE_ALTERNATE(7));
// Activates the UART driver 2, PA2(TX) and PA3(RX) are routed to USART2.
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7));
// Activates the UART driver 3, PB10(TX) and PB11(RX) are routed to USART3.
palSetPadMode(GPIOB, 10, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOB, 11, PAL_MODE_ALTERNATE(7));
// Activates the UART driver 4, PC10(TX) and PC11(RX) are routed to UART4.
palSetPadMode(GPIOC, 10, PAL_MODE_ALTERNATE(8));
palSetPadMode(GPIOC, 11, PAL_MODE_ALTERNATE(8));
// Activates the UART driver 5, PC12(TX) and PD2(RX) are routed to UART5.
palSetPadMode(GPIOC, 12, PAL_MODE_ALTERNATE(8));
palSetPadMode(GPIOD, 2, PAL_MODE_ALTERNATE(8));
// Activates the UART driver 6, PC6(TX) and PC7(RX) are routed to USART6.
palSetPadMode(GPIOC, 6, PAL_MODE_ALTERNATE(8));
palSetPadMode(GPIOC, 7, PAL_MODE_ALTERNATE(8));
/*
* 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(250);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
shellCreate(&shell_cfg2, SHELL_WA_SIZE, NORMALPRIO);
shellCreate(&shell_cfg3, SHELL_WA_SIZE, NORMALPRIO);
shellCreate(&shell_cfg4, SHELL_WA_SIZE, NORMALPRIO);
shellCreate(&shell_cfg5, SHELL_WA_SIZE, NORMALPRIO);
shellCreate(&shell_cfg6, SHELL_WA_SIZE, NORMALPRIO);
/*
* Normal main() thread activity, in this demo it just performs
* a shell respawn upon its termination.
*/
while (true) {
if (!shelltp0) {
if (SDU1.config->usbp->state == USB_ACTIVE) {
/* Spawns a new shell.*/
shelltp0 = shellCreate(&shell_cfg0, SHELL_WA_SIZE, NORMALPRIO);
}
} else {
/* If the previous shell exited.*/
if (chThdTerminated(shelltp0)) {
/* Recovers memory of the previous shell.*/
chThdRelease(shelltp0);
shelltp0 = NULL;
}
}
chThdSleepMilliseconds(1000);
}
}
int main(void) {
static const evhandler_t evhndl_main[] = {
extdetail_WKUP_button_handler
};
struct EventListener el0;
/*
* 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();
extdetail_init();
palSetPad(GPIOC, GPIOC_LED);
/*!
* GPIO Pins for generating pulses at data input detect and data output send.
* Used for measuring latency timing of data
*
* \sa board.h
*/
palClearPad( TIMEOUTPUT_PORT, TIMEOUTPUT_PIN);
palSetPadMode(TIMEOUTPUT_PORT, TIMEOUTPUT_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palSetPad( TIMEINPUT_PORT, TIMEINPUT_PIN);
palSetPadMode(TIMEINPUT_PORT, TIMEINPUT_PIN, PAL_MODE_OUTPUT_PUSHPULL );
/*
* I2C2 I/O pins setup
*/
palSetPadMode(si_i2c_connections.i2c_sda_port , si_i2c_connections.i2c_sda_pad,
PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_OSPEED_HIGHEST |PAL_STM32_PUDR_FLOATING );
palSetPadMode(si_i2c_connections.i2c_scl_port, si_i2c_connections.i2c_scl_pad,
PAL_MODE_ALTERNATE(4) | PAL_STM32_OSPEED_HIGHEST | PAL_STM32_PUDR_FLOATING);
palSetPad(si_i2c_connections.i2c_scl_port, si_i2c_connections.i2c_scl_pad );
static const ShellCommand commands[] = {
{"mem", cmd_mem},
{"threads", cmd_threads},
{NULL, NULL}
};
usbSerialShellStart(commands);
mpu9150_start(&I2CD2);
i2cStart(mpu9150_driver.i2c_instance, &si_i2c_config);
mpu9150_init(mpu9150_driver.i2c_instance);
/* Administrative threads */
chThdCreateStatic(waThread_blinker, sizeof(waThread_blinker), NORMALPRIO, Thread_blinker, NULL);
chThdCreateStatic(waThread_indwatchdog, sizeof(waThread_indwatchdog), NORMALPRIO, Thread_indwatchdog, NULL);
/* MAC */
/*!
* Use a locally administered MAC address second LSbit of MSB of MAC should be 1
* Use unicast address LSbit of MSB of MAC should be 0
*/
data_udp_init();
chThdCreateStatic(wa_lwip_thread , sizeof(wa_lwip_thread) , NORMALPRIO + 2, lwip_thread , SENSOR_LWIP);
chThdCreateStatic(wa_data_udp_send_thread , sizeof(wa_data_udp_send_thread) , NORMALPRIO , data_udp_send_thread , NULL);
/* i2c MPU9150 */
chThdCreateStatic(waThread_mpu9150_int, sizeof(waThread_mpu9150_int) , NORMALPRIO , Thread_mpu9150_int, NULL);
/* SPI ADIS */
//chThdCreateStatic(waThread_adis_dio1, sizeof(waThread_adis_dio1), NORMALPRIO, Thread_adis_dio1, NULL);
//chThdCreateStatic(waThread_adis_newdata, sizeof(waThread_adis_newdata), NORMALPRIO, Thread_adis_newdata, NULL);
/*! Activates the EXT driver 1. */
extStart(&EXTD1, &extcfg);
chEvtRegister(&extdetail_wkup_event, &el0, 0);
while (TRUE) {
chEvtDispatch(evhndl_main, chEvtWaitOneTimeout((eventmask_t)1, MS2ST(500)));
}
}
/*===========================================================================*/
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();
/*
* kruciální řádek protože pokud se to zapne bez debugru tak je tam
* jenom bordel a když se to pak srovnává s NULL tak se to cely
* vymrdá a skoči do unhandled exception
*/
uint8_t i;
for (i = 0 ; i< 60 ; i++)
logic_pointery[i] = NULL;
//test_logic_fill();
chThdSleepMilliseconds(100);
/*
* Activates the USB driver and then the USB bus pull-up on D+.
*/
usb_user_init();
/*
* Shell manager initialization.
*/
shellInit();
/*
* Init tft display ssd1289 and gui
*/
gui_init();
/**
* @brief start the whole bad thing
*/
logic_init();
/*
* start external interrupt system
*/
extStart(&EXTD1, &extcfg);
/*
* start wah thread
*/
wah_init();
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state.
*/
EventListener el;
chEvtRegister(&event_touch, &el, TOUCH_PUSH);
#ifdef I2C_TEST
i2c_test();
#endif
gui_thread();
while(TRUE);
}
/*
* Application entry point.
*/
int main(void) {
static const evhandler_t evhndl[] = {
InsertHandler,
RemoveHandler
};
Thread *shelltp = NULL;
struct EventListener el0, el1;
/*
* 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();
/*
* Activates the serial driver 2 using the driver default configuration.
*/
sdStart(&SD2, NULL);
/*
* Shell manager initialization.
*/
shellInit();
/*
* Initializes the MMC driver to work with SPI2.
*/
palSetPadMode(IOPORT2, GPIOB_SPI2NSS, PAL_MODE_OUTPUT_PUSHPULL);
palSetPad(IOPORT2, GPIOB_SPI2NSS);
mmcObjectInit(&MMCD1);
mmcStart(&MMCD1, &mmccfg);
/*
* Activates the card insertion monitor.
*/
tmr_init(&MMCD1);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, 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)
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. */
}
chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500)));
}
return 0;
}
/*
* 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();
#if defined(F042)
/* This is needed to remap the USB pins PA11,PA12 onto the default PA9,PA10
* so that the USB works. After halInit (which changes that register).
* This also means that USART1 can't be used, as it is on PA9,PA10.
*/
SYSCFG->CFGR1 |= SYSCFG_CFGR1_PA11_PA12_RMP;
#endif /* F042 */
chSysInit();
/*
* Setup button pad
*/
palSetPadMode(BUTTON_GPIO, BUTTON_PIN, BUTTON_MODE);
/*
* Create the blinker thread.
*/
chThdCreateStatic(waBlinkThr, sizeof(waBlinkThr), NORMALPRIO, BlinkThr, NULL);
/*
* Setup things for wiegand
*/
wieg_init();
/*
* Initializes a serial-over-USB CDC driver.
*/
sduObjectInit(&OUTPUT_CHANNEL);
sduStart(&OUTPUT_CHANNEL, &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);
led_blink = 1;
/*
* Shell manager initialization.
*/
shellInit();
/*
* The main loop.
*/
/*
while(true) {
if((palReadPad(BUTTON_GPIO, BUTTON_PIN) == BUTTON_ACTIVE) && (OUTPUT_CHANNEL.config->usbp->state == USB_ACTIVE)) {
// sdWrite(&OUTPUT_CHANNEL, (uint8_t *)"hello world\r\n", 13);
// chprintf((BaseSequentialStream *)&OUTPUT_CHANNEL, "Hello world\r\n");
chnPutTimeout(&OUTPUT_CHANNEL, 'W', TIME_IMMEDIATE);
// wieg_send(wieg_test_buf, 26);
led_blink = 1;
chThdSleepMilliseconds(200);
// chnWrite((BaseChannel *)&OUTPUT_CHANNEL, (uint8_t *)"Hello, world\r\n", 14);
}
msg_t charbuf;
charbuf = chnGetTimeout(&OUTPUT_CHANNEL, TIME_IMMEDIATE);
if(charbuf != Q_TIMEOUT) {
switch(charbuf) {
default:
chprintf((BaseSequentialStream *)&OUTPUT_CHANNEL, "Haloooo\r\n");
break;
}
// chnPutTimeout(&OUTPUT_CHANNEL, (uint8_t)charbuf, TIME_IMMEDIATE);
// if(charbuf == '\r') {
// chnPutTimeout(&OUTPUT_CHANNEL, '\n', TIME_IMMEDIATE);
// }
}
chThdSleepMilliseconds(50);
}
*/
/*
* Normal main() thread activity, spawning shells.
*/
while (true) {
msg_t c;
if(serusbcfg.usbp->state == USB_ACTIVE) {
c = chnGetTimeout(&OUTPUT_CHANNEL, TIME_IMMEDIATE);
if(c != Q_TIMEOUT) {
switch(c) {
case 'k':
if(unlock_pw_recved==0) {
unlock_pw_recved++;
led_blink = 1;
}
break;
case 'o':
if(unlock_pw_recved==1) {
unlock_pw_recved++;
led_blink = 1;
}
break;
case 'j':
if(unlock_pw_recved==2) {
unlock_pw_recved++;
led_blink = 1;
}
break;
case 'a':
if(unlock_pw_recved==3) {
unlock_pw_recved++;
led_blink = 1;
}
break;
}
}
if(unlock_pw_recved == 4) {
unlock_pw_recved = 0;
thread_t *shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE,
"shell", NORMALPRIO + 1,
shellThread, (void *)&shell_cfg1);
chThdWait(shelltp); /* Waiting termination. */
}
}
chThdSleepMilliseconds(50);
}
}
/*
* 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();
/*
* 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(1500);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO + 1, Thread1, NULL);
/*
* L3GD20 Object Initialization
*/
l3gd20ObjectInit(&L3GD20D1);
/*
* Activates the L3GD20 driver.
*/
l3gd20Start(&L3GD20D1, &l3gd20cfg);
while(!palReadLine(LINE_BUTTON)){
chprintf(chp, "Press BTN to calibrate gyroscope...\r\n");
chThdSleepMilliseconds(150);
#if CHPRINTF_USE_ANSI_CODE
chprintf(chp, "\033[2J\033[1;1H");
#endif
}
chprintf(chp, "Calibrating Gyroscope sampling bias...\r\n");
chprintf(chp, "Keep it in the rest position while red LED is on\r\n");
chThdSleepMilliseconds(3000);
palSetLine(LINE_LED10_RED);
chThdSleepMilliseconds(1000);
gyroscopeSampleBias(&L3GD20D1);
palClearLine(LINE_LED10_RED);
#if CHPRINTF_USE_ANSI_CODE
chprintf(chp, "\033[2J\033[1;1H");
#endif
while (TRUE) {
palToggleLine(LINE_LED10_RED);
gyroscopeReadRaw(&L3GD20D1, rawdata);
for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++)
chprintf(chp, "RAW-%c:%d\r\n", axesID[i], rawdata[i]);
gyroscopeReadCooked(&L3GD20D1, cookeddata);
for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++)
chprintf(chp, "COOKED-%c:%.3f\r\n", axesID[i], cookeddata[i]);
gyroscopeGetTemp(&L3GD20D1, &temperature);
chprintf(chp, "TEMP:%.1f C°\r\n", temperature);
chThdSleepMilliseconds(150);
#if CHPRINTF_USE_ANSI_CODE
chprintf(chp, "\033[2J\033[1;1H");
#endif
}
l3gd20Stop(&L3GD20D1);
}
/*
* Application entry point.
*/
int main(void)
{
enum led_status lstat = LST_INIT;
EventListener el0;
alert_status_t proto_st = ALST_INIT;
alert_status_t bmp085_st = ALST_INIT;
alert_status_t mpu6050_st = ALST_INIT;
alert_status_t hmc5883_st = ALST_INIT;
/*
* 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();
#ifdef BOARD_IMU_AHRF
/* Clear DRDY pad */
palClearPad(GPIOA, GPIOA_DRDY);
/* Activates serial */
sdStart(&SD1, NULL);
sdStart(&SD2, NULL);
/* Activate pwm */
pwmStart(&PWMD1, &pwm1cfg);
/* Activate i2c */
i2cStart(&I2CD1, &i2c1cfg);
/* Activate exti */
extStart(&EXTD1, &extcfg);
#endif /* BOARD_IMU_AHRF */
#ifdef BOARD_CAPTAIN_PRO2
/* Activates serial */
sdStart(&SD3, NULL);
sdStart(&SD4, NULL);
/* Activate pwm */
pwmStart(&PWMD3, &pwm3cfg);
pwmStart(&PWMD4, &pwm4cfg);
pwmStart(&PWMD5, &pwm5cfg);
/* Activate i2c */
i2cStart(&I2CD1, &i2c1cfg);
/* Activate exti */
extStart(&EXTD1, &extcfg);
/* Activate adc */
adcStart(&ADCD1, NULL);
#endif /* BOARD_CAPTAIN_PRO2 */
/* alert subsys */
chEvtInit(&alert_event_source);
chEvtRegister(&alert_event_source, &el0, 0);
/* init devices */
pt_init();
chThdSleepMilliseconds(10); /* power on delay */
#ifdef HAS_DEV_BMP085
bmp085_init();
chThdSleepMilliseconds(50); /* init delay */
#endif
#ifdef HAS_DEV_MS5611
ms5611_init(&ms5611cfg);
chThdSleepMilliseconds(50); /* init delay */
#endif
#ifdef HAS_DEV_MPU6050
mpu6050_init(&mpu6050cfg);
chThdSleepMilliseconds(250); /* give some time for mpu6050 configuration */
#endif
#ifdef HAS_DEV_HMC5883
hmc5883_init(&hmc5883cfg);
#endif
#ifdef HAS_DEV_SERVOPWM
servopwm_init(&servopwmcfg);
#endif
#ifdef HAS_DEV_NTC10K
ntc10k_init();
#endif
#ifdef HAS_DEV_RPM
rpm_init();
#endif
#ifdef BOARD_IMU_AHRF
/* Set DRDY pad */
palSetPad(GPIOA, GPIOA_DRDY);
#endif
while (TRUE) {
eventmask_t msk = chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(100));
if (msk & EVENT_MASK(0)) {
flagsmask_t fl = chEvtGetAndClearFlags(&el0);
if (fl & ALERT_FLAG_PROTO)
proto_st = pt_get_status();
#ifdef HAS_DEV_MPU6050
if (fl & ALERT_FLAG_MPU6050)
mpu6050_st = mpu6050_get_status();
#endif
#ifdef HAS_DEV_HMC5883
if (fl & ALERT_FLAG_HMC5883)
hmc5883_st = hmc5883_get_status();
#endif
#ifdef HAS_DEV_BMP085
if (fl & ALERT_FLAG_BMP085)
bmp085_st = bmp085_get_status();
#endif
#ifdef HAS_DEV_MS5611
if (fl & ALERT_FLAG_BMP085)
bmp085_st = ms5611_get_status();
#endif
pt_set_sens_state(mpu6050_st, hmc5883_st, bmp085_st);
}
if (proto_st == ALST_FAIL || mpu6050_st == ALST_FAIL || hmc5883_st == ALST_FAIL || bmp085_st == ALST_FAIL)
lstat = LST_FAIL;
else if (proto_st == ALST_INIT || mpu6050_st == ALST_INIT || hmc5883_st == ALST_INIT || bmp085_st == ALST_INIT)
lstat = LST_INIT;
else if (proto_st == ALST_NORMAL && mpu6050_st == ALST_NORMAL && hmc5883_st == ALST_NORMAL && bmp085_st == ALST_NORMAL)
lstat = LST_NORMAL;
led_update(lstat);
}
}
/*
* 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.
*/
uint32_t tempR, tempP, tempY;
float Roll,Pitch,Yaw;
halInit();
chSysInit();
i2c_setup();
palSetPadMode(IOPORT1, 8, PAL_MODE_INPUT); // PA8 - RADIO INPUT
palSetPadMode(IOPORT2, 13, PAL_MODE_STM32_ALTERNATE_OPENDRAIN); /* SCK. */
palSetPadMode(IOPORT2, 14, PAL_MODE_STM32_ALTERNATE_PUSHPULL); /* MISO.*/
palSetPadMode(IOPORT2, 15, PAL_MODE_STM32_ALTERNATE_OPENDRAIN); /* MOSI.*/
palSetPadMode(IOPORT2, 12, PAL_MODE_STM32_ALTERNATE_OPENDRAIN);
palSetPadMode(IOPORT3, 11, PAL_MODE_OUTPUT_PUSHPULL);
chMtxInit(&mtx_imu);
chMtxInit(&mutex_motors);
palClearPad(IOPORT3,10);
//palClearPad(IOPORT3,11);
/*
* Activates the USB driver and then the USB bus pull-up on D+.
*/
sduObjectInit(&SDU1);
sduStart(&SDU1, &serusbcfg);
usbConnectBus(serusbcfg.usbp);
//palClearPad(GPIOC, GPIOC_USB_DISC);
icuStart(&ICUD1, &icucfg);
icuEnable(&ICUD1);
chThdSleepSeconds(1);
chThdCreateStatic(waThread1, sizeof(waThread1), HIGHPRIO, Thread1, NULL);
//chThdCreateStatic(waMotorsThread, sizeof(waMotorsThread), NORMALPRIO, MotorsThread, NULL);
spiAcquireBus(&SPID2); /* Acquire ownership of the bus. */
spiStart(&SPID2, &ls_spicfg); /* Setup transfer parameters. */
spiSelect(&SPID2);
KP = 1;
KI = 1;
KD = 0;
while (TRUE) {
while(!(SPID2.spi->SR & SPI_SR_RXNE));
spiReceive(&SPID2,24,rxbuf_16bit);
// Floating point calculation of Roll/Pitch/Yaw inside the microcontroller. Decomment next 6 lines if you want to implement
// the control Law.
tempR = (uint32_t)((rxbuf_16bit[0] << 31) | (rxbuf_16bit[1] << 23) | (rxbuf_16bit[2] << 11) | rxbuf_16bit[3]);
tempP = (uint32_t)((rxbuf_16bit[4] << 31) | (rxbuf_16bit[5] << 23) | (rxbuf_16bit[6] << 11) | rxbuf_16bit[7]);
tempY = (uint32_t)((rxbuf_16bit[8] << 31) | (rxbuf_16bit[9] << 23) | (rxbuf_16bit[10] << 11) | rxbuf_16bit[11]);
Roll = (*(float*)&tempR);
Pitch = (*(float*)&tempP);
Yaw = (*(float*)&tempY);
// CONTROL LAW HERE
//++ (ROLL,PITCH,YAW ERRORS) -----> [CONTROLLER] -----> (MOTORS INPUT)
// PID Control Law
roll_error = 0 - Roll;
pitch_error = 0 - Pitch;
yaw_error = 0 - Yaw;
roll_I = roll_I + roll_error*0.01;
pitch_I = pitch_I + pitch_error*0.01;
roll_D = (roll_error - roll_prev_error)/0.01;
pitch_D = (pitch_error - pitch_prev_error)/0.01;
roll_controller_output = (int8_t)(KP*roll_error + KI*roll_I + KD*roll_D);
pitch_controller_output = (int8_t)(KP*pitch_error + KI*pitch_I + KD*pitch_D);
//roll_controller_output = (int8_t)roll_error;
//pitch_controller_output = (int8_t)pitch_error;
roll_prev_error = roll_error;
pitch_prev_error = pitch_error;
//-------------------------------------------------------------------
blctrl20_set_velocity();
palSetPad(IOPORT3,11);
/* SPI FLOATING POINT TEST PACKET (sending 5.6F)
rxbuf_16bit[0] = 0;
rxbuf_16bit[1] = 129;
rxbuf_16bit[2] = 1638;
rxbuf_16bit[3] = 819;
rxbuf_16bit[4] = 0;
rxbuf_16bit[5] = 129;
rxbuf_16bit[6] = 1638;
rxbuf_16bit[7] = 819;
rxbuf_16bit[8] = 1;
rxbuf_16bit[9] = 129;
rxbuf_16bit[10] = 1638;
rxbuf_16bit[11] = 819;
*/
if(SDU1.config->usbp->state==USB_ACTIVE)
{
// chprintf((BaseChannel *)&SDU1,"S:%6d:%6d:%6d:%6d:%6d:%6d:%6d:%6d:%6d:%6d:%6d:%6d:E\r\n",rxbuf_16bit[0],rxbuf_16bit[1],rxbuf_16bit[2],rxbuf_16bit[3],rxbuf_16bit[4],rxbuf_16bit[5],rxbuf_16bit[6],rxbuf_16bit[7],rxbuf_16bit[8],rxbuf_16bit[9],rxbuf_16bit[10],rxbuf_16bit[11]);
chprintf((BaseChannel *)&SDU1, "S:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:%6D:E\r\n",rxbuf_16bit[0],rxbuf_16bit[1],rxbuf_16bit[2],rxbuf_16bit[3],rxbuf_16bit[4],rxbuf_16bit[5],rxbuf_16bit[6],rxbuf_16bit[7],rxbuf_16bit[8],rxbuf_16bit[9],rxbuf_16bit[10],rxbuf_16bit[11],(int8_t)Roll,(int8_t)Pitch,(int8_t)Yaw,icu_ch[3],icu_ch[4],roll_controller_output,pitch_controller_output,yaw_controller_output);
}
chThdSleepMilliseconds(10);
}
spiUnselect(&SPID2);
spiReleaseBus(&SPID2); /* Ownership release. */
}
int main(void) {
// copy vector table to SRAM1!
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnonnull"
memcpy((char *)0x20000000, (const char)0x00000000, 0x200);
#pragma GCC diagnostic pop
// remap SRAM1 to 0x00000000
SYSCFG->MEMRMP |= 0x03;
halInit();
chSysInit();
sdcard_init();
sysmon_init();
#if ENABLE_SERIAL_DEBUG
// SD2 for serial debug output
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7) | PAL_MODE_INPUT); // RX
palSetPadMode(GPIOA, 2, PAL_MODE_OUTPUT_PUSHPULL); // TX
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); // TX
// 115200 baud
static const SerialConfig sd2Cfg = {115200,
0, 0, 0};
sdStart(&SD2, &sd2Cfg);
chprintf((BaseSequentialStream * )&SD2,"Hello world!\r\n");
#endif
exception_init();
InitPatch0();
InitPConnection();
InitPWM();
// display SPI CS?
palSetPadMode(GPIOC, 1, PAL_MODE_OUTPUT_PUSHPULL);
palSetPad(GPIOC, 1);
chThdSleepMilliseconds(10);
palSetPadMode(SW2_PORT, SW2_PIN, PAL_MODE_INPUT_PULLDOWN);
axoloti_board_init();
codec_init();
if (!palReadPad(SW2_PORT, SW2_PIN)) { // button S2 not pressed
// watchdog_init();
chThdSleepMilliseconds(1);
}
start_dsp_thread();
adc_init();
axoloti_math_init();
midi_init();
#if ((BOARD_AXOLOTI_V03)||(BOARD_AXOLOTI_V05))
axoloti_control_init();
#endif
ui_init();
StartLoadPatchTread();
#if (BOARD_AXOLOTI_V05)
configSDRAM();
//memTest();
#endif
#ifdef ENABLE_USB_HOST
MY_USBH_Init();
#endif
if (!exception_check()) {
// only try booting a patch when no exception is to be reported
#if ((BOARD_AXOLOTI_V03)||(BOARD_AXOLOTI_V05))
sdcard_attemptMountIfUnmounted();
if (fs_ready && !palReadPad(SW2_PORT, SW2_PIN)){
// button S2 not pressed
FRESULT res;
// res = f_stat("/start.bin", NULL);
// if (res == FR_OK) {
LoadPatch("/start.bin");
// }
}
#endif
// if no patch booting or running yet
// try loading from flash
if (patchStatus) {
// patch in flash sector 11
memcpy((uint8_t *)PATCHMAINLOC, (uint8_t *)PATCHFLASHLOC, PATCHFLASHSIZE);
if ((*(uint32_t *)PATCHMAINLOC != 0xFFFFFFFF)
&& (*(uint32_t *)PATCHMAINLOC != 0)) {
if (!palReadPad(SW2_PORT, SW2_PIN)) // button S2 not pressed
StartPatch();
}
}
}
while (1) {
chThdSleepMilliseconds(1000);
}
}
int main(void) {
static Thread *shelltp = NULL;
static const evhandler_t evhndl_main[] = {
extdetail_WKUP_button_handler
};
struct EventListener el0;
/*
* 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();
extdetail_init();
palSetPad(GPIOC, GPIOC_LED);
palSetPad(GPIOA, GPIOA_SPI1_SCK);
palSetPad(GPIOA, GPIOA_SPI1_NSS);
/*
* SPI1 I/O pins setup.
*/
palSetPadMode(adis_connections.spi_sck_port, adis_connections.spi_sck_pad,
PAL_MODE_ALTERNATE(5) |
PAL_STM32_OSPEED_HIGHEST);
palSetPadMode(adis_connections.spi_miso_port, adis_connections.spi_miso_pad,
PAL_MODE_ALTERNATE(5) |
PAL_STM32_OSPEED_HIGHEST| PAL_STM32_PUDR_FLOATING);
palSetPadMode(adis_connections.spi_mosi_port, adis_connections.spi_mosi_pad,
PAL_MODE_ALTERNATE(5) |
PAL_STM32_OSPEED_HIGHEST );
palSetPadMode(adis_connections.spi_cs_port, adis_connections.spi_cs_pad,
PAL_MODE_OUTPUT_PUSHPULL |
PAL_STM32_OSPEED_HIGHEST);
palSetPad(GPIOA, GPIOA_SPI1_SCK);
palSetPad(GPIOA, GPIOA_SPI1_NSS);
/*!
* Initializes a serial-over-USB CDC driver.
*/
sduObjectInit(&SDU_PSAS);
sduStart(&SDU_PSAS, &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);
shellInit();
iwdg_begin();
/*!
* Activates the serial driver 6 and SDC driver 1 using default
* configuration.
*/
sdStart(&SD6, NULL);
spiStart(&SPID1, &adis_spicfg); /* Set transfer parameters. */
chThdSleepMilliseconds(300);
adis_init();
adis_reset();
/*! Activates the EXT driver 1. */
extStart(&EXTD1, &extcfg);
chThdCreateStatic(waThread_blinker, sizeof(waThread_blinker), NORMALPRIO, Thread_blinker, NULL);
chThdCreateStatic(waThread_adis_dio1, sizeof(waThread_adis_dio1), NORMALPRIO, Thread_adis_dio1, NULL);
chThdCreateStatic(waThread_adis_newdata, sizeof(waThread_adis_newdata), NORMALPRIO, Thread_adis_newdata, NULL);
chThdCreateStatic(waThread_indwatchdog, sizeof(waThread_indwatchdog), NORMALPRIO, Thread_indwatchdog, NULL);
chEvtRegister(&extdetail_wkup_event, &el0, 0);
while (TRUE) {
if (!shelltp && (SDU_PSAS.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. */
}
chEvtDispatch(evhndl_main, chEvtWaitOneTimeout((eventmask_t)1, MS2ST(500)));
}
}
/*
* Application entry point.
*/
int main(void) {
unsigned i;
gptcnt_t interval, threshold, worst;
/* Enables FPU exceptions.*/
nvicEnableVector(FPU_IRQn, CORTEX_PRIORITY_MASK(1));
/*
* 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();
/*
* Prepares the Serial driver 2 and GPT drivers 2 and 3.
*/
sdStart(&SD2, NULL); /* Default is 38400-8-N-1.*/
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7));
gptStart(&GPTD2, &gpt2cfg);
gptStart(&GPTD3, &gpt3cfg);
/*
* Initializes the worker threads.
*/
chThdCreateStatic(waWorkerThread, sizeof waWorkerThread,
NORMALPRIO - 20, WorkerThread, NULL);
chThdCreateStatic(waPeriodicThread, sizeof waPeriodicThread,
NORMALPRIO - 10, PeriodicThread, NULL);
/*
* Test procedure.
*/
println("");
println("*** ChibiOS/RT IRQ-STORM-FPU long duration test");
println("***");
print("*** Kernel: ");
println(CH_KERNEL_VERSION);
print("*** Compiled: ");
println(__DATE__ " - " __TIME__);
#ifdef CH_COMPILER_NAME
print("*** Compiler: ");
println(CH_COMPILER_NAME);
#endif
print("*** Architecture: ");
println(CH_ARCHITECTURE_NAME);
#ifdef CH_CORE_VARIANT_NAME
print("*** Core Variant: ");
println(CH_CORE_VARIANT_NAME);
#endif
#ifdef CH_PORT_INFO
print("*** Port Info: ");
println(CH_PORT_INFO);
#endif
#ifdef PLATFORM_NAME
print("*** Platform: ");
println(PLATFORM_NAME);
#endif
#ifdef BOARD_NAME
print("*** Test Board: ");
println(BOARD_NAME);
#endif
println("***");
print("*** System Clock: ");
printn(STM32_SYSCLK);
println("");
print("*** Iterations: ");
printn(ITERATIONS);
println("");
print("*** Randomize: ");
printn(RANDOMIZE);
println("");
println("");
worst = 0;
for (i = 1; i <= ITERATIONS; i++){
print("Iteration ");
printn(i);
println("");
saturated = FALSE;
threshold = 0;
for (interval = 2000; interval >= 10; interval -= interval / 10) {
gptStartContinuous(&GPTD2, interval - 1); /* Slightly out of phase.*/
gptStartContinuous(&GPTD3, interval + 1); /* Slightly out of phase.*/
chThdSleepMilliseconds(1000);
gptStopTimer(&GPTD2);
gptStopTimer(&GPTD3);
if (!saturated)
print(".");
else {
print("#");
if (threshold == 0)
threshold = interval;
}
}
/* Gives the worker threads a chance to empty the mailboxes before next
cycle.*/
chThdSleepMilliseconds(20);
println("");
print("Saturated at ");
printn(threshold);
println(" uS");
println("");
if (threshold > worst)
worst = threshold;
}
gptStopTimer(&GPTD2);
gptStopTimer(&GPTD3);
print("Worst case at ");
printn(worst);
println(" uS");
println("");
println("Test Complete");
/*
* Normal main() thread activity, nothing in this test.
*/
while (TRUE) {
chThdSleepMilliseconds(5000);
}
}
/*
* Application entry point.
*/
int main(void) {
size_t start = 1100;
size_t end = 1150;
volatile int32_t adc_its = 0;
volatile int32_t spi_its = 0;
volatile int32_t uart_its = 0;
volatile int32_t adc_its_idle = 0;
volatile int32_t spi_its_idle = 0;
volatile int32_t uart_its_idle = 0;
volatile uint32_t idle_thread_cnt = 0;
#if EMCNAND_USE_KILL_TEST
size_t kill = 8000;
#endif
/*
* 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();
emcStart(&EMCD1, &emccfg);
#if !STM32_EMC_EMCNAND_USE_FSMC_INT
extStart(&EXTD1, &extcfg);
#endif
emcnandStart(&EMCNANDD1, &nandcfg);
chThdSleepMilliseconds(4000);
chThdCreateStatic(fsmcIdleThreadWA,
sizeof(fsmcIdleThreadWA),
NORMALPRIO - 20,
fsmcIdleThread,
NULL);
nand_wp_release();
dma_storm_adc_start();
dma_storm_uart_start();
dma_storm_spi_start();
T = chVTGetSystemTimeX();
general_test(&EMCNANDD1, start, end, 1);
T = chVTGetSystemTimeX() - T;
adc_its = dma_storm_adc_stop();
uart_its = dma_storm_uart_stop();
spi_its = dma_storm_spi_stop();
chSysLock();
idle_thread_cnt = IdleCnt;
IdleCnt = 0;
chSysUnlock();
dma_storm_adc_start();
dma_storm_uart_start();
dma_storm_spi_start();
chThdSleep(T);
adc_its_idle = dma_storm_adc_stop();
uart_its_idle = dma_storm_uart_stop();
spi_its_idle = dma_storm_spi_stop();
osalDbgCheck(idle_thread_cnt > (IdleCnt / 4));
osalDbgCheck(abs(adc_its - adc_its_idle) < (adc_its_idle / 20));
osalDbgCheck(abs(uart_its - uart_its_idle) < (uart_its_idle / 20));
osalDbgCheck(abs(spi_its - spi_its_idle) < (spi_its_idle / 10));
ecc_test(&EMCNANDD1, end);
#if EMCNAND_USE_KILL_TEST
kill_block(&EMCNANDD1, kill);
#endif
nand_wp_assert();
/*
* Normal main() thread activity, in this demo it does nothing.
*/
while (TRUE) {
chThdSleepMilliseconds(500);
}
}
/**
* @brief Application entry point.
* @details
*/
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();
/* 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.
*/
usbStop(serusbcfg.usbp);
usbDisconnectBus(serusbcfg.usbp);
chThdSleepMilliseconds(500);
usbConnectBus(serusbcfg.usbp);
usbStart(serusbcfg.usbp, &usbcfg);
/* Activates the serial driver 4 using the driver's default configuration. */
sdStart(&SD4, NULL);
/* Activates the I2C driver 2. */
i2cInit();
i2cStart(&I2CD2, &i2cfg_d2);
/* Enables the CRC peripheral clock. */
rccEnableCRC(FALSE);
/* Loads settings from external EEPROM chip. */
if (eepromLoadSettings()) {
g_boardStatus |= EEPROM_24C02_DETECTED;
}
/* Initializes the MPU6050 sensor. */
if (mpu6050Init()) {
g_boardStatus |= MPU6050_LOW_DETECTED;
/* Creates a taken binary semaphore. */
chBSemInit(&bsemNewDataReady, TRUE);
/* Creates the MPU6050 polling thread and attitude calculation thread. */
chThdCreateStatic(waPollMPU6050Thread, sizeof(waPollMPU6050Thread),
NORMALPRIO + 1, PollMPU6050Thread, NULL);
chThdCreateStatic(waAttitudeThread, sizeof(waAttitudeThread),
HIGHPRIO, AttitudeThread, NULL);
/* Starts motor drivers. */
pwmOutputStart();
/* Starts ADC and ICU input drivers. */
mixedInputStart();
}
/* Creates the blinker thread. */
chThdCreateStatic(waBlinkerThread, sizeof(waBlinkerThread),
LOWPRIO, BlinkerThread, NULL);
/* Normal main() thread activity. */
while (TRUE) {
g_chnp = serusbcfg.usbp->state == USB_ACTIVE ? (BaseChannel *)&SDU1 : (BaseChannel *)&SD4;
telemetryReadSerialData();
if (eepromIsDataLeft()) {
eepromContinueSaving();
}
chThdSleepMilliseconds(TELEMETRY_SLEEP_MS);
}
/* This point should never be reached. */
return 0;
}
/*
* 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();
/*
* Initializes the PWM driver 1 and ICU driver 1.
* GPIOD10 is the PWM output.
* GPIOA0 is the ICU input.
* The two pins have to be externally connected together.
*/
icuStart(&ICUD1, &icucfg);
icuEnable(&ICUD1);
/* Sets A0 alternative function.*/
SIU.PCR[0].R = 0b0100010100000100;
pwmStart(&PWMD1, &pwmcfg);
/* Sets D10 alternative function.*/
SIU.PCR[58].R = 0b0100010100000100;
chThdSleepMilliseconds(2000);
/*
* Starts the PWM channel 0 using 75% duty cycle.
*/
pwmEnableChannel(&PWMD1, 0, PWM_PERCENTAGE_TO_WIDTH(&PWMD1, 7500));
chThdSleepMilliseconds(5000);
/*
* Changes the PWM channel 0 to 50% duty cycle.
*/
pwmEnableChannel(&PWMD1, 0, PWM_PERCENTAGE_TO_WIDTH(&PWMD1, 5000));
chThdSleepMilliseconds(5000);
/*
* Changes the PWM channel 0 to 25% duty cycle.
*/
pwmEnableChannel(&PWMD1, 0, PWM_PERCENTAGE_TO_WIDTH(&PWMD1, 2500));
chThdSleepMilliseconds(5000);
/*
* Changes PWM period and the PWM channel 0 to 50% duty cycle.
*/
pwmChangePeriod(&PWMD1, 25000);
pwmEnableChannel(&PWMD1, 0, PWM_PERCENTAGE_TO_WIDTH(&PWMD1, 5000));
chThdSleepMilliseconds(5000);
/*
* Disables channel 0 and stops the drivers.
*/
pwmDisableChannel(&PWMD1, 0);
pwmStop(&PWMD1);
icuDisable(&ICUD1);
icuStop(&ICUD1);
palClearPad(PORT_D, PD_LED3);
palClearPad(PORT_D, PD_LED4);
/*
* Normal main() thread activity, in this demo it does nothing.
*/
while (TRUE) {
chThdSleepMilliseconds(500);
}
return 0;
}
int main(void) {
Thread * pub_tp = NULL;
Thread * sub_tp = NULL;
halInit();
chSysInit();
/*
* Initializes a serial-over-USB CDC driver.
*/
#if USE_USB_SERIAL
sduObjectInit(&SDU1);
sduStart(&SDU1, &serusbcfg);
#endif
/*
* 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.
*/
#if USE_USB_SERIAL
usbDisconnectBus(serusbcfg.usbp);
chThdSleepMilliseconds(500);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
#endif
/* Start the serial driver. */
#if !USE_USB_SERIAL
sdStart(&SD3, NULL);
#endif
for (;;) {
#if USE_USB_SERIAL
if (!pub_tp && (SDU1.config->usbp->state == USB_ACTIVE)) {
#else
if (!pub_tp) {
#endif
pub_tp = chThdCreateFromHeap(NULL, THD_WA_SIZE(2048), NORMALPRIO, rosserial_pub_thread, NULL);
} else if (chThdTerminated(pub_tp)) {
chThdRelease(pub_tp);
pub_tp = NULL;
}
chThdSleepMilliseconds(123);
#if USE_USB_SERIAL
if (!sub_tp && (SDU1.config->usbp->state == USB_ACTIVE)) {
#else
if (!sub_tp) {
#endif
sub_tp = chThdCreateFromHeap(NULL, THD_WA_SIZE(2048), NORMALPRIO, rosserial_sub_thread, NULL);
} else if (chThdTerminated(sub_tp)) {
chThdRelease(sub_tp);
sub_tp = NULL;
}
chThdSleepMilliseconds(500);
}
return CH_SUCCESS;
}
}
/*
* Application entry point.
*/
int main(void) {
thread_t *shelltp = NULL;
/*
* 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();
/*
* Shell manager initialization.
*/
shellInit();
/*
* 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);
/*
* Creating the blinker threads.
*/
chThdCreateStatic(waThread1, sizeof(waThread1),
NORMALPRIO + 10, Thread1, NULL);
chThdCreateStatic(waThread2, sizeof(waThread2),
NORMALPRIO + 10, Thread2, NULL);
/*
* Normal main() thread activity, in this demo it just performs
* a shell respawn upon its termination.
*/
while (true) {
if (!shelltp) {
if (SDU1.config->usbp->state == USB_ACTIVE) {
/* Spawns a new shell.*/
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
}
}
else {
/* If the previous shell exited.*/
if (chThdTerminatedX(shelltp)) {
/* Recovers memory of the previous shell.*/
chThdRelease(shelltp);
shelltp = NULL;
}
}
chThdSleepMilliseconds(500);
}
}
/*
* 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();
/*
* Activates the serial driver 2 and SDC driver 1 using default
* configuration.
*/
sdStart(&SD6, NULL);
BaseSequentialStream *chp = (BaseSequentialStream *)&SD6;
chprintf(chp, "running main()\r\n");
chThdSleepMilliseconds(50);
#if STM32_USB_USE_OTG2
USBDriver *usb_driver = &USBD2;
#else
USBDriver *usb_driver = &USBD1;
#endif
/*
* Activates the card insertion monitor.
*/
init_sd();
chprintf(chp, "done starting SDC\r\n");
const bool_t sdcConnectStatus = sdcConnect(&SDCD1);
if( sdcConnectStatus != CH_SUCCESS ) {
chprintf(chp, "failed to connect to SD Card, sdcConnectStatus = %u\r\n", sdcConnectStatus);
for(;;) {
chThdSleepMilliseconds(3000);
}
}
chprintf(chp, "setting up MSD\r\n");
const usb_msd_driver_state_t msd_driver_state = msdInit(usb_driver, (BaseBlockDevice*)&SDCD1, &UMSD1, USB_MS_DATA_EP, USB_MSD_INTERFACE_NUMBER);
if( msd_driver_state != USB_MSD_DRIVER_OK ) {
chprintf(chp, "Error initing USB MSD, %d %s\r\n", msd_driver_state, usb_msd_driver_state_t_to_str(msd_driver_state));
}
UMSD1.chp = chp;
chprintf(chp, "Initializing SDU1...\r\n");
serusbcfg.usbp = usb_driver;
sduObjectInit(&SDU1);
/*Disconnect the USB Bus*/
usbDisconnectBus(usb_driver);
chThdSleepMilliseconds(200);
/*Start the useful functions*/
sduStart(&SDU1, &serusbcfg);
msdStart(&UMSD1);
usbStart(usb_driver, &msd_usb_config);
/*Connect the USB Bus*/
usbConnectBus(usb_driver);
/*
* Creates the blinker thread.
*/
chprintf(chp, "starting blinker thread\r\n");
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
while (TRUE) {
palTogglePad(GPIOC, GPIOC_LED);
chThdSleepMilliseconds(500);
}
}
/*
* Application entry point.
*/
int main(void) {
Thread *shelltp = NULL;
/*
* 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();
/*
* Shell manager initialization.
*/
shellInit();
/*
* 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);
/*
* Initialise SDRAM, board.h has already configured GPIO correctly (except that ST example uses 50MHz not 100MHz?)
*/
SDRAM_Init();
sdram_bulk_erase();
/*
* Activates the LCD-related drivers.
*/
spiStart(&SPID5, &spi_cfg5);
ili9341Start(&ILI9341D1, &ili9341_cfg);
initialize_lcd();
ltdcStart(<DCD1, <dc_cfg);
/*
* Activates the DMA2D-related drivers.
*/
dma2dStart(&DMA2DD1, &dma2d_cfg);
dma2d_test();
/*
* Creating the blinker threads.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO + 10,
Thread1, NULL);
chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO + 10,
Thread2, NULL);
/*
* Normal main() thread activity, in this demo it just performs
* a shell respawn upon its termination.
*/
while (TRUE) {
if (!shelltp) {
if (SDU1.config->usbp->state == USB_ACTIVE) {
/* Spawns a new shell.*/
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
}
}
else {
/* If the previous shell exited.*/
if (chThdTerminated(shelltp)) {
/* Recovers memory of the previous shell.*/
chThdRelease(shelltp);
shelltp = NULL;
}
}
chThdSleepMilliseconds(500);
}
}
/*
* Application entry point.
*/
int main(void) {
Thread *shelltp = NULL;
/*
* 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();
/*
* Shell manager initialization.
*/
shellInit();
/*
* 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);
/*
* Activates the serial driver 2 using the driver default configuration.
* PA2(TX) and PA3(RX) are routed to USART2.
*/
sdStart(&SD2, NULL);
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7));
/*
* Initializes the SPI driver 1 in order to access the MEMS. The signals
* are already initialized in the board file.
*/
spiStart(&SPID1, &spi1cfg);
/*
* Initializes the SPI driver 2. The SPI2 signals are routed as follow:
* PB12 - NSS.
* PB13 - SCK.
* PB14 - MISO.
* PB15 - MOSI.
*/
spiStart(&SPID2, &spi2cfg);
palSetPad(GPIOB, 12);
palSetPadMode(GPIOB, 12, PAL_MODE_OUTPUT_PUSHPULL |
PAL_STM32_OSPEED_HIGHEST); /* NSS. */
palSetPadMode(GPIOB, 13, PAL_MODE_ALTERNATE(5) |
PAL_STM32_OSPEED_HIGHEST); /* SCK. */
palSetPadMode(GPIOB, 14, PAL_MODE_ALTERNATE(5)); /* MISO. */
palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(5) |
PAL_STM32_OSPEED_HIGHEST); /* MOSI. */
/*
* Initializes the PWM driver 4, routes the TIM4 outputs to the board LEDs.
*/
pwmStart(&PWMD4, &pwmcfg);
palSetPadMode(GPIOD, GPIOD_LED4, PAL_MODE_ALTERNATE(2)); /* Green. */
palSetPadMode(GPIOD, GPIOD_LED3, PAL_MODE_ALTERNATE(2)); /* Orange. */
palSetPadMode(GPIOD, GPIOD_LED5, PAL_MODE_ALTERNATE(2)); /* Red. */
palSetPadMode(GPIOD, GPIOD_LED6, PAL_MODE_ALTERNATE(2)); /* Blue. */
/*
* Creates the example thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1),
NORMALPRIO + 10, Thread1, NULL);
/*
* Normal main() thread activity, in this demo it just performs
* a shell respawn upon its termination.
*/
while (TRUE) {
if (!shelltp) {
if (SDU1.config->usbp->state == USB_ACTIVE) {
/* Spawns a new shell.*/
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
}
}
else {
/* If the previous shell exited.*/
if (chThdTerminated(shelltp)) {
/* Recovers memory of the previous shell.*/
chThdRelease(shelltp);
shelltp = NULL;
}
}
chThdSleepMilliseconds(500);
}
}
/*
* Application entry point.
*/
int main(void) {
unsigned i;
gptcnt_t interval, threshold, worst;
/*
* 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();
/*
* Prepares the Serial driver 2 and GPT drivers 1 and 2.
*/
sdStart(&SD1, NULL); /* Default is 38400-8-N-1.*/
gptStart(&GPTD1, &gpt1cfg);
gptStart(&GPTD2, &gpt2cfg);
/*
* Initializes the mailboxes and creates the worker threads.
*/
for (i = 0; i < NUM_THREADS; i++) {
chMBInit(&mb[i], b[i], MAILBOX_SIZE);
chThdCreateStatic(waWorkerThread[i], sizeof waWorkerThread[i],
NORMALPRIO - 20, WorkerThread, (void *)i);
}
/*
* Test procedure.
*/
println("");
println("*** ChibiOS/RT IRQ-STORM long duration test");
println("***");
print("*** Kernel: ");
println(CH_KERNEL_VERSION);
#ifdef CH_COMPILER_NAME
print("*** Compiler: ");
println(CH_COMPILER_NAME);
#endif
print("*** Architecture: ");
println(CH_ARCHITECTURE_NAME);
#ifdef CH_CORE_VARIANT_NAME
print("*** Core Variant: ");
println(CH_CORE_VARIANT_NAME);
#endif
#ifdef CH_PORT_INFO
print("*** Port Info: ");
println(CH_PORT_INFO);
#endif
#ifdef PLATFORM_NAME
print("*** Platform: ");
println(PLATFORM_NAME);
#endif
#ifdef BOARD_NAME
print("*** Test Board: ");
println(BOARD_NAME);
#endif
println("***");
print("*** System Clock: ");
printn(LPC13xx_SYSCLK);
println("");
print("*** Iterations: ");
printn(ITERATIONS);
println("");
print("*** Randomize: ");
printn(RANDOMIZE);
println("");
print("*** Threads: ");
printn(NUM_THREADS);
println("");
print("*** Mailbox size: ");
printn(MAILBOX_SIZE);
println("");
println("");
worst = 0;
for (i = 1; i <= ITERATIONS; i++){
print("Iteration ");
printn(i);
println("");
saturated = FALSE;
threshold = 0;
for (interval = 2000; interval >= 20; interval -= interval / 10) {
gptStartContinuous(&GPTD1, interval - 1); /* Slightly out of phase.*/
gptStartContinuous(&GPTD2, interval + 1); /* Slightly out of phase.*/
chThdSleepMilliseconds(1000);
gptStopTimer(&GPTD1);
gptStopTimer(&GPTD2);
if (!saturated)
print(".");
else {
print("#");
if (threshold == 0)
threshold = interval;
}
}
/* Gives the worker threads a chance to empty the mailboxes before next
cycle.*/
chThdSleepMilliseconds(20);
println("");
print("Saturated at ");
printn(threshold);
println(" uS");
println("");
if (threshold > worst)
worst = threshold;
}
gptStopTimer(&GPTD1);
gptStopTimer(&GPTD2);
print("Worst case at ");
printn(worst);
println(" uS");
println("");
println("Test Complete");
/*
* Normal main() thread activity, nothing in this test.
*/
while (TRUE) {
chThdSleepMilliseconds(5000);
}
return 0;
}
/*
* Application entry point.
*/
int main(void) {
static thread_t *shelltp = NULL;
static const evhandler_t evhndl[] = {
InsertHandler,
RemoveHandler
};
event_listener_t el0, el1;
/*
* 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(1500);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
/*
* Shell manager initialization.
*/
shellInit();
/*
* Activates the card insertion monitor.
*/
tmr_init(&SDCD1);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, 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 (chThdTerminatedX(shelltp)) {
chThdRelease(shelltp); /* Recovers memory of the previous shell. */
shelltp = NULL; /* Triggers spawning of a new shell. */
}
chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500)));
}
}
