static msg_t Thread1(void *arg) {
(void)arg;
chRegSetThreadName("blinker1");
while (TRUE) {
palClearPad(GPIOC, GPIOC_LED4);
chThdSleepMilliseconds(500);
palSetPad(GPIOC, GPIOC_LED4);
chThdSleepMilliseconds(500);
}
return RDY_OK;
}
void backlight_set(uint8_t level) {
printf("backlight_set(%d)\n", level);
#ifdef BACKLIGHT_ENABLE
if (level == 0) {
// Turn backlight off
palSetPad(GPIOB, 8);
} else {
// Turn backlight on
palClearPad(GPIOB, 8);
}
#endif
}
static msg_t Thread1(void *arg) {
(void)arg;
chRegSetThreadName("blinker");
while (TRUE) {
palClearPad(BL_PORT, BL_PIN);
chThdSleepMilliseconds(30);
palSetPad(BL_PORT, BL_PIN);
chThdSleepMilliseconds(30);
}
return 0;
}
static THD_FUNCTION(Thread1, arg) {
(void)arg;
chRegSetThreadName("Blinker");
while (true) {
palClearPad(IOPORT5, PORTE_LED);
chThdSleepMilliseconds(1000);
palSetPad(IOPORT5, PORTE_LED);
chThdSleepMilliseconds(100);
}
}
static void extcb(EXTDriver *extp, expchannel_t channel) {
(void)extp;
(void)channel;
if (PWR->CSR & PWR_CSR_PVDO){ /* voltage lover than threshold */
palClearPad(GPIOB, GPIOB_LED_B); /* switch off LED*/
}
else{
palSetPad(GPIOB, GPIOB_LED_B); /* switch on LED*/
}
}
/*
* This callback is invoked when a character is received but the application
* was not ready to receive it, the character is passed as parameter.
*/
static void rxchar(UARTDriver *uartp, uint16_t c) {
(void)uartp;
(void)c;
/* Flashing the LED each time a character is received.*/
palSetPad(GPIOD, GPIOD_LED4);
chSysLockFromIsr();
if (chVTIsArmedI(&vt2))
chVTResetI(&vt2);
chVTSetI(&vt2, MS2ST(200), ledoff, NULL);
chSysUnlockFromIsr();
}
static msg_t Thread1(void *arg) {
(void)arg;
chRegSetThreadName("blinker");
while (TRUE) {
systime_t time = serusbcfg.usbp->state == USB_ACTIVE ? 250 : 500;
palClearPad(GPIOC, GPIOC_LED1);
chThdSleepMilliseconds(time);
palSetPad(GPIOC, GPIOC_LED1);
chThdSleepMilliseconds(time);
}
}
/* Triggered when the button is pressed or released. The LED4 is set to ON.*/
static void extcb1(EXTDriver *extp, expchannel_t channel) {
static virtual_timer_t vt4;
(void)extp;
(void)channel;
palSetPad(GPIOB, GPIOB_LED4);
chSysLockFromISR();
chVTResetI(&vt4);
/* LED4 set to OFF after 200mS.*/
chVTDoSetI(&vt4, MS2ST(200), led4off, NULL);
chSysUnlockFromISR();
}
static msg_t Thread1(void *p) {
(void)p;
chRegSetThreadName("blinker");
while (TRUE) {
palSetPad(IOPORT2, PIOB_LCD_BL);
chThdSleepMilliseconds(100);
palClearPad(IOPORT2, PIOB_LCD_BL);
chThdSleepMilliseconds(900);
}
return 0;
}
void panic(const char *err)
{
kfly_error = err;
while (1)
{
palClearPad(GPIOC, GPIOC_LED_ERR);
chThdSleepMilliseconds(200);
palSetPad(GPIOC, GPIOC_LED_ERR);
chThdSleepMilliseconds(200);
}
}
static THD_FUNCTION(blinkerThread, arg) {
(void)arg;
chRegSetThreadName("blinkerThread");
while(true) {
systime_t time = USB_DRIVER.state == USB_ACTIVE ? 250 : 500;
palClearPad(LED_GPIO, LED_PIN);
chThdSleepMilliseconds(time);
palSetPad(LED_GPIO, LED_PIN);
chThdSleepMilliseconds(time);
}
}
static msg_t Thread1(void *arg) {
(void)arg;
chRegSetThreadName("blinker");
while (TRUE) {
palSetPad(GPIOE, GPIOE_LED10_RED);
chThdSleepMilliseconds(500);
palClearPad(GPIOE, GPIOE_LED10_RED);
chThdSleepMilliseconds(500);
}
return 0;
}
static THD_FUNCTION(Thread1, arg) {
(void)arg;
chRegSetThreadName("blinker");
while (true) {
palSetPad(GPIOC, GPIOC_LED);
chThdSleepMilliseconds(500);
palClearPad(GPIOC, GPIOC_LED);
chThdSleepMilliseconds(500);
}
}
static msg_t Thread2(void *arg) {
(void)arg;
chRegSetThreadName("blinker2");
while (TRUE) {
palClearPad(IOPORT1, PA_LEDUSB);
chThdSleepMilliseconds(200);
palSetPad(IOPORT1, PA_LEDUSB);
chThdSleepMilliseconds(300);
}
return 0;
}
static THD_FUNCTION(Thread1, arg) {
(void)arg;
chRegSetThreadName("blinker");
while (true) {
systime_t time = serusbcfg.usbp->state == USB_ACTIVE ? 250 : 500;
palClearPad(GPIOA, GPIOA_LED_BLUE);
chThdSleepMilliseconds(time);
palSetPad(GPIOA, GPIOA_LED_BLUE);
chThdSleepMilliseconds(time);
}
}
int main(void)
{
static const evhandler_t evhndl[] = {InsertHandler, RemoveHandler};
struct EventListener el0, el1;
// os init
halInit();
chSysInit();
// setup LED pads
palSetPadMode(GPIOD, 12, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
palClearPad(GPIOD, 12); // green LED
palSetPadMode(GPIOD, 15, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
palClearPad(GPIOD, 15); // blue LED
// setup pads to USART2 function (connect these pads through RS232 transceiver with PC, terminal emu needs 38400 baud)
sdStart(&SD2, NULL);
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7) | PAL_STM32_OSPEED_HIGHEST); // TX
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7)); // RX
// setup pads to SPI1 function (connect these pads to your SD card accordingly)
palSetPadMode(GPIOC, 4, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST); // NSS
palSetPadMode(GPIOA, 5, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_HIGHEST); // SCK
palSetPadMode(GPIOA, 6, PAL_MODE_ALTERNATE(5)); // MISO
palSetPadMode(GPIOA, 7, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_HIGHEST); // MOSI
palSetPad(GPIOC, 4); // set NSS high
// initialize MMC driver
mmcObjectInit(&MMCD1, &SPID1, &ls_spicfg, &hs_spicfg, mmc_is_protected, mmc_is_inserted);
mmcStart(&MMCD1, NULL);
// ChibiOS has no I2S support yet;
// codec.c initializes everything necessary
// except the I2S TX DMA interrupt vector (because it would
// conflict with the ChibiOS kernel)
// we can make ChibiOS call our own handler by letting
// it create the DMA stream for SPI3
dmaStreamAllocate(SPID3.dmatx,
STM32_SPI_SPI3_IRQ_PRIORITY,
(stm32_dmaisr_t)I2SDmaTxInterrupt,
&SPID3);
// blink thread; also checks the user button
chThdCreateStatic(waBlinkThread, sizeof(waBlinkThread), NORMALPRIO, BlinkThread, NULL);
chEvtRegister(&MMCD1.inserted_event, &el0, 0);
chEvtRegister(&MMCD1.removed_event, &el1, 1);
while(TRUE)
{
chEvtDispatch(evhndl, chEvtWaitOne(ALL_EVENTS));
}
}
static THD_FUNCTION(blinkerThread,arg) {
UNUSED(arg);
while(TRUE){
while (isLogging) {
palSetPad(GPIOE, GPIOE_LED10_RED);
chThdSleepMilliseconds(500);
palClearPad(GPIOE, GPIOE_LED10_RED);
chThdSleepMilliseconds(500);
}
chThdSleepMilliseconds(1);
}
return 0;
}
static THD_FUNCTION(ThreadLED, arg)
{
(void)arg;
chRegSetThreadName("HeartBeat");
while (true) {
palSetPad(GPIOG, GPIOG_LED3_GREEN);
chThdSleepMilliseconds(100);
palClearPad(GPIOG, GPIOG_LED3_GREEN);
chThdSleepMilliseconds(1000);
}
}
/* Triggered when the button is pressed or released. The LED4 is set to ON.*/
static void extcb1(EXTDriver *extp, expchannel_t channel) {
static VirtualTimer vt4;
(void)extp;
(void)channel;
palSetPad(GPIOC, GPIOC_LED4);
chSysLockFromIsr();
if (chVTIsArmedI(&vt4))
chVTResetI(&vt4);
/* LED4 set to OFF after 200mS.*/
chVTSetI(&vt4, MS2ST(200), led4off, NULL);
chSysUnlockFromIsr();
}
static THD_FUNCTION(Thread2, arg){
(void)arg;
chRegSetThreadName("trigger-thread");
systime_t time = chVTGetSystemTimeX();
while(true){
time += MS2ST(500);
palSetPad(TRIGGER_PORT, TRIGGER_PIN);
chThdSleepMicroseconds(10);
palClearPad(TRIGGER_PORT, TRIGGER_PIN);
chThdSleepUntil(time);
}
}
uint32_t layer_state_set_kb(uint32_t state) {
palClearPad(GPIOB, 8);
palClearPad(GPIOB, 9);
state = layer_state_set_user(state);
uint8_t layer = biton32(state);
switch (layer) {
case 3:
palSetPad(GPIOB, 9);
break;
case 4:
palSetPad(GPIOB, 8);
break;
case 6:
palSetPad(GPIOB, 9);
palSetPad(GPIOB, 8);
break;
default:
break;
}
return state;
}
static msg_t Thread1(void *arg) {
(void)arg;
chRegSetThreadName("blinker");
while (TRUE) {
palClearPad(GPIOD, GPIOD_LED6);
chThdSleepMilliseconds(blinkspeed);
palSetPad(GPIOD, GPIOD_LED6);
chThdSleepMilliseconds(blinkspeed);
}
return 0;
}
static THD_FUNCTION(BlinkThread, arg) {
(void)arg;
uint8_t i;
// while(TRUE) {
for(i=0; i<5; i++) {
palSetPad(TEENSY_PIN13_IOPORT, TEENSY_PIN13);
chThdSleepMilliseconds(700);
palClearPad(TEENSY_PIN13_IOPORT, TEENSY_PIN13);
chThdSleepMilliseconds(700);
}
jump_to_bootloader();
}
bool bus_power(bool enable)
{
if (enable) {
if (bus_voltage_get() > 0.5 && palReadPad(GPIOB, GPIOB_V_BUS_ENABLE) == 0) {
return false;
}
palSetPad(GPIOB, GPIOB_V_BUS_ENABLE);
} else {
led_clear(CAN1_PWR_LED);
palClearPad(GPIOB, GPIOB_V_BUS_ENABLE);
}
return true;
}
void statusLedPulse(int led, systime_t duration)
{
chSysLock();
switch(led)
{
case 1:
if (chVTIsArmedI(&vt1))
chVTResetI(&vt1);
else
palSetPad(IOPORT2, GPIOB_LED1);
chVTSetI(&vt1, duration, ledoff_1, NULL);
break;
case 2:
if (chVTIsArmedI(&vt2))
chVTResetI(&vt2);
else
palSetPad(IOPORT2, GPIOB_LED2);
chVTSetI(&vt2, duration, ledoff_2, NULL);
break;
}
chSysUnlock();
}
/**
* @brief Internal thread initialization function that sets up SSI I/O and data structures
*/
static void ssi_init(void)
{
// Initialize timer and I/O
palSetPadMode(SSI_SIGNAL_PORT, SSI_CLK_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palSetPad(SSI_SIGNAL_PORT, SSI_CLK_PIN);
palSetPadMode(SSI_SIGNAL_PORT, SSI_DATA_PIN, PAL_MODE_INPUT);
palSetPadMode(SSI_CTL_PORT, SSI_TXEN_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(SSI_CTL_PORT, SSI_NRXEN_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(SSI_CTL_PORT, SSI_PWREN_PIN, PAL_MODE_OUTPUT_PUSHPULL);
SSI_TXEN_ON(); // Turn on RS-422 transmitter
SSI_RXEN_ON(); // Turn on RS-422 receiver
ssi_encoder_power(ENCODER_ON); // Turn on encoder power
}
msg_t pyro_continuity_thread(void *arg) {
(void)arg;
m2status_pyro_status(STATUS_WAIT);
chRegSetThreadName("Pyros");
while(TRUE) {
if(pyro_continuities()) {
m2status_pyro_status(STATUS_OK);
palSetPad(GPIOA, GPIOA_LED_PYROS);
chThdSleepMilliseconds(10);
palClearPad(GPIOA, GPIOA_LED_PYROS);
chThdSleepMilliseconds(990);
} else {
/* TODO: report sadness up the chain */
m2status_pyro_status(STATUS_ERR);
palSetPad(GPIOA, GPIOA_LED_PYROS);
chThdSleepMilliseconds(100);
palClearPad(GPIOA, GPIOA_LED_PYROS);
chThdSleepMilliseconds(100);
}
}
}
static msg_t heartBeat (void*Arg)
{
palSetPad (GPIOB, 8);
palClearPad (GPIOB, 7);
printf ("\n\rHello world!\n\r");
while (true)
{
palTogglePad (GPIOB, 8);
palTogglePad (GPIOB, 7);
chThdSleepMilliseconds (250);
}
}
static uint32_t encabsQuery( void )
{
static uint32_t val;
val = 0;
static int16_t i;
palClearPad( ENCABS_CLK_PORT, ENCABS_CLK_PIN );
for ( i=0; i<delayFrontTicks; i++ )
delay();
for ( i=(encabsBits-1); i>=0; i-- )
{
palSetPad( ENCABS_CLK_PORT, ENCABS_CLK_PIN );
delay();
if ( palReadPad( ENCABS_DATA_PORT, ENCABS_DATA_PIN ) )
val += (1<<i);
palClearPad( ENCABS_CLK_PORT, ENCABS_CLK_PIN );
delay();
}
for ( i=0; i<delayBackTicks; i++ )
delay();
palSetPad( ENCABS_CLK_PORT, ENCABS_CLK_PIN );
return val;
}
static msg_t Thread2(void *arg) {
(void)arg;
chRegSetThreadName("green blinker");
while (TRUE) {
palSetPad(IOPORT6, P6_O_GREEN_LED);
chThdSleepMilliseconds(1500);
palClearPad(IOPORT6, P6_O_GREEN_LED);
chThdSleepMilliseconds(1500);
}
return 0;
}
