int main(void) { coord_t width, height; font_t font1, font2, font3, font4; const char *msg; halInit(); chSysInit(); /* Initialize and clear the display */ gdispInit(); gdispClear(Black); // Get the screen size width = gdispGetWidth(); height = gdispGetHeight(); // Get the fonts we want to use font1 = gdispOpenFont("UI2"); font2 = gdispOpenFont("UI2 Double"); font3 = gdispOpenFont("UI2 Narrow"); font4 = gdispOpenFont("LargeNumbers"); // Display large numbers on the right (measuring the string) msg = "123456"; gdispDrawString(width-gdispGetStringWidth(msg, font4)-3, 3, msg, font4, Green); // Display the font name under it. msg = gdispGetFontName(font4); gdispDrawString(width-gdispGetStringWidth(msg, font1)-3, 20, msg, font1, Green); // Demonstrate our other fonts gdispDrawString(10, 10, "Writing with Font 'UI2'", font1, Yellow); gdispFillString(10, 35, "Writing with Font 'UI2 Double'", font2, Red, White); gdispDrawStringBox(0, 50, width, 40, "Writing with Font 'UI2 Narrow'", font3, Red, justifyCenter); gdispFillStringBox(0, 90, width, 40, "Filled Centered", font3, Pink, Gray, justifyCenter); // Clean up the fonts gdispCloseFont(font1); gdispCloseFont(font2); gdispCloseFont(font3); gdispCloseFont(font4); // Wait forever while(TRUE) { chThdSleepMilliseconds(500); } }
/* * Application entry point. */ int main(void) { unsigned i; /* * 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(); /* * SPI1 I/O pins setup. */ 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. */ palSetPad(GPIOB, 12); /* * Prepare transmit pattern. */ for (i = 0; i < sizeof(txbuf); i++) txbuf[i] = (uint8_t)i; /* * Starting the transmitter and receiver threads. */ chThdCreateStatic(spi_thread_1_wa, sizeof(spi_thread_1_wa), NORMALPRIO + 1, spi_thread_1, NULL); chThdCreateStatic(spi_thread_2_wa, sizeof(spi_thread_2_wa), NORMALPRIO + 1, spi_thread_2, NULL); /* * Normal main() thread activity, in this demo it does nothing. */ while (TRUE) { chThdSleepMilliseconds(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(); chSysInit(); /* * Starting DAC1 driver, setting up the output pins as analog as suggested * by the Reference Manual. */ palSetPadMode(GPIOA, 4, PAL_MODE_INPUT_ANALOG); palSetPadMode(GPIOA, 5, PAL_MODE_INPUT_ANALOG); dacStart(&DACD1, &dac1cfg1); /* * Starting GPT6 driver, it is used for triggering the DAC. */ gptStart(&GPTD6, &gpt6cfg1); /* * Starting a continuous conversion. * Note, the buffer size is divided by two because two elements are fetched * for each transfer. */ dacStartConversion(&DACD1, &dacgrpcfg1, (dacsample_t *)dac_buffer, DAC_BUFFER_SIZE / 2U); gptStartContinuous(&GPTD6, 2U); /* * Normal main() thread activity, if the button is pressed then the DAC * transfer is stopped. */ while (true) { if (palReadPad(GPIOA, GPIOA_BUTTON)) { gptStopTimer(&GPTD6); dacStopConversion(&DACD1); } chThdSleepMilliseconds(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(); chSysInit(); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Activates the ADC1 driver, the temperature sensor and the VBat * measurement. */ adcStart(&ADCD1, NULL); adcSTM32Calibrate(&ADCD1); adcSTM32EnableTSVREFE(); adcSTM32EnableVBATE(); /* * Linear conversion. */ adcConvert(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH); chThdSleepMilliseconds(1000); /* * Starts an ADC continuous conversion. */ adcStartConversion(&ADCD1, &adcgrpcfg2, samples2, ADC_GRP2_BUF_DEPTH); /* * Normal main() thread activity, in this demo it does nothing. */ while (TRUE) { if (palReadPad(GPIOA, GPIOA_WKUP_BUTTON)) { adcStopConversion(&ADCD1); } chThdSleepMilliseconds(500); } }
int main(void) { Thread *shelltp = NULL; short timeout = 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(); // Init the serial port associated with the console vexConsoleInit(); // init VEX vexCortexInit(); // wait for good spi comms while( vexSpiGetOnlineStatus() == 0 ) { // wait for a while chThdSleepMilliseconds(100); // dump after 5 seconds if(timeout++ == 50) break; } // Shell manager initialization. shellInit(); // spin in loop monitoring the shell 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. */ } 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(); /* * Activates the serial driver 1 using the driver default configuration. */ sdStart(&SD1, NULL); /* * 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 + 1, lwip_thread, NULL); /* * Creates the HTTP thread (it changes priority internally). */ chThdCreateStatic(wa_http_server, sizeof(wa_http_server), NORMALPRIO + 1, http_server, NULL); /* * Normal main() thread activity. */ while (TRUE) { chThdSleepMilliseconds(500); if (!palReadPad(IOPORT2, PIOB_SW1)) sdWrite(&SD1, (uint8_t *)"Hello World!\r\n", 14); if (!palReadPad(IOPORT2, PIOB_SW2)) TestThread(&SD1); } 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(); /* * Starting the I2C driver 2. */ i2cStart(&I2CD2, &i2cconfig); /* * Starting the blinker thread. */ chThdCreateStatic(blinker_wa, sizeof(blinker_wa), NORMALPRIO-1, blinker, NULL); /* * Normal main() thread activity, in this demo it does nothing. */ while (TRUE) { unsigned i; msg_t msg; static const uint8_t cmd[] = {0, 0}; uint8_t data[16]; msg = i2cMasterTransmitTimeout(&I2CD2, 0x52, cmd, sizeof(cmd), data, sizeof(data), TIME_INFINITE); msg = msg; if (msg != RDY_OK) chSysHalt(); for (i = 0; i < 256; i++) { msg = i2cMasterReceiveTimeout(&I2CD2, 0x52, data, sizeof(data), TIME_INFINITE); if (msg != RDY_OK) chSysHalt(); } chThdSleepMilliseconds(500); } return 0; }
int main(void) { halInit(); chSysInit(); debugInit(); PRINT("Main is running",0); chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); mp45dt02Init(); while(1) { chThdSleep(S2ST(1)); } }
/* * 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(); /* * Activates the USB driver and then the USB bus pull-up on D+. */ sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(100); 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. */ } chThdSleepMilliseconds(1000); } }
int main( void ) { halInit(); moduleInit(); printf("\r\n****************************************************\r\n"); printf("Zigbee Network Explorer\r\n"); debugConsoleIsr = &handleDebugConsoleInterrupt; HAL_ENABLE_INTERRUPTS(); clearLeds(); /* Now the network is running - wait for any received messages from the ZM */ #ifdef VERBOSE_MESSAGE_DISPLAY printAfIncomingMsgHeaderNames(); #endif stateMachine(); }
int main(void) { // ==== Init Vcore & clock system ==== SetupVCore(vcore1V5); // Clk.SetMSI4MHz(); Clk.SetupFlashLatency(16); Clk.SwitchToHSI(); Clk.UpdateFreqValues(); // Init OS halInit(); chSysInit(); App.InitThread(); // ==== Init hardware ==== Uart.Init(115200, UART_GPIO, UART_TX_PIN);//, UART_GPIO, UART_RX_PIN); Uart.Printf("\r%S %S\r", APP_NAME , BUILD_TIME); Clk.PrintFreqs(); Effects.Init(); if(Radio.Init() == OK) { // Effects.AllTogetherSmoothly(clGreen, 45); // chEvtWaitAny(EVT_LEDS_DONE); // Effects.AllTogetherSmoothly(clBlack, 45); // chEvtWaitAny(EVT_LEDS_DONE); } else { Effects.AllTogetherNow(clRed); chThdSleepMilliseconds(180); Effects.AllTogetherNow(clBlack); chThdSleepMilliseconds(180); Effects.AllTogetherNow(clRed); chThdSleepMilliseconds(180); Effects.AllTogetherNow(clBlack); chThdSleepMilliseconds(180); Effects.AllTogetherNow(clRed); chThdSleepMilliseconds(180); Effects.AllTogetherNow(clBlack); } // Effects.ChunkRunningRandom(clGreen, 2, 180); Effects.ChunkRunningRandom(clYellow, 2, 0); // Main cycle App.ITask(); }
/* * 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(); /* * Activates the serial driver 6 using the driver default configuration. */ sdStart(&SD6, NULL); /* * Initializes the SDIO drivers. */ sdcStart(&SDCD1, &sdccfg); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Normal main() thread activity, in this demo it does nothing. */ while (true) { if (!shelltp) 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. */ } chThdSleepMilliseconds(1000); } }
int main(void) { halInit(); chibios_rt::System::Init(); chRegSetThreadName("Main"); chThdSleepMilliseconds(1000); //init wireless module new Wireless; chThdSetPriority(NORMALPRIO - 1); while (TRUE) { delay_process::Play(); chThdSleepMilliseconds(1); } }
int main () { halInit(); chSysInit(); static const I2CConfig i2cconfig = { I2C_FAST_MODE_PLUS, 2000000 }; i2cStart(&I2CD1, &i2cconfig); init_OLED(); // launch the blinker background thread chThdCreateStatic(waBlinkTh, sizeof(waBlinkTh), NORMALPRIO, BlinkTh, NULL); chThdSleepMilliseconds(1000); clearDisplay(); printBigDigit(1, 0, 0); chThdSleepMilliseconds(250); printBigDigit(2, 0, 3); chThdSleepMilliseconds(250); printBigDigit(3, 0, 6); chThdSleepMilliseconds(250); printBigDigit(4, 0, 9); chThdSleepMilliseconds(250); printBigDigit(5, 0, 12); chThdSleepMilliseconds(250); printBigDigit(6, 4, 0); chThdSleepMilliseconds(250); printBigDigit(7, 4, 3); chThdSleepMilliseconds(250); printBigDigit(8, 4, 6); chThdSleepMilliseconds(250); printBigDigit(9, 4, 9); chThdSleepMilliseconds(250); printBigDigit(0, 4, 12); chThdSleepMilliseconds(1000); // display some changing text on the display static char buf[17]; for (int y = 0; ; ++y) { chThdSleepMilliseconds(500); for (int x = 0; x < 16; ++x) buf[x] = ' ' + x + y % 80; sendStrXY(buf, y % 8, 0); } return 0; }
int main(void) { halInit(); chSysInit(); hw_init_gpio(); ledpwm_init(); mcpwm_init(); comm_init(); app_init(); // Threads chThdCreateStatic(periodic_thread_wa, sizeof(periodic_thread_wa), NORMALPRIO, periodic_thread, NULL); chThdCreateStatic(sample_send_thread_wa, sizeof(sample_send_thread_wa), NORMALPRIO, sample_send_thread, NULL); chThdCreateStatic(timer_thread_wa, sizeof(timer_thread_wa), NORMALPRIO, timer_thread, NULL); for(;;) { chThdSleepMilliseconds(100); } }
int main (void) { halInit(); chSysInit(); sdStart (&SD2, NULL); pwmStart (&PWMD3, &pwmCfg); adcStart (&ADCD1, &adcGrpCfg); palSetPadMode (GPIOA, 6, PAL_MODE_STM32_ALTERNATE_PUSHPULL); palSetPadMode (GPIOA, 7, PAL_MODE_STM32_ALTERNATE_PUSHPULL); palSetPadMode (GPIOB, 0, PAL_MODE_STM32_ALTERNATE_PUSHPULL); palSetPadMode (GPIOB, 1, PAL_MODE_STM32_ALTERNATE_PUSHPULL); palSetPadMode (GPIOC, 2, PAL_MODE_INPUT_ANALOG); chThdCreateStatic (heartWrkArea, sizeof (heartWrkArea), NORMALPRIO, heartBeat, NULL); chThdCreateStatic (sensorWrkArea, sizeof (sensorWrkArea), NORMALPRIO, sensorRead, NULL); }
int main(void) { color_t color = Black; uint16_t pen = 0; halInit(); chSysInit(); gdispInit(); ginputGetMouse(0); gdispSetOrientation(GDISP_ROTATE_90); drawScreen(); while (TRUE) { ginputGetMouseStatus(0, &ev); if (!(ev.current_buttons & GINPUT_MOUSE_BTN_LEFT)) 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); } } }
/* * 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 6 using the driver default configuration. */ sdStart(&SD6, NULL); /* * 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 + 1, lwip_thread, NULL); /* * Creates the HTTP thread (it changes priority internally). */ chThdCreateStatic(wa_http_server, sizeof(wa_http_server), NORMALPRIO + 1, http_server, NULL); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and check the button state. */ while (TRUE) { if (palReadPad(GPIOC, GPIOC_SWITCH_TAMPER) == 0) TestThread(&SD6); chThdSleepMilliseconds(500); } }
int main (void) { u8 returnValue; u32 seed; interactive = 1; halInit(); ST_RadioGetRandomNumbers((u16 *)&seed, 2); halCommonSeedRandom(seed); uartInit(115200, 8, PARITY_NONE, 1); INTERRUPTS_ON(); /* Initialize radio (analog section, digital baseband and MAC). Leave radio powered up in non-promiscuous rx mode */ returnValue = ST_RadioInit(ST_RADIO_POWER_MODE_RX_ON); assert(returnValue==ST_SUCCESS); TIMER_Init(); printf("Bootloader demo application\r\n"); responsePrintf("{&N API call... &t2x}\r\n", "halGetResetInfo", "resetInfo", 0); txBufferInit(FALSE); rxBufferInit(); blInit(NULL, transmitByte, receiveByte); ST_RadioSetPanId(IAP_BOOTLOADER_PAN_ID); ST_RadioSetChannel(IAP_BOOTLOADER_DEFAULT_CHANNEL); commandReaderInit(); while(1) { // Process input and print prompt if it returns TRUE. if (processCmdInput(interactive)) { if (interactive) { printf(">"); } TIMER_Tick(); } } }
/* * 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(); /* * Activates the serial driver 2 using the driver default configuration. */ sdStart(&SD1, NULL); 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) { shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); } else if(chThdTerminatedX(shelltp)) { chThdRelease(shelltp); shelltp = NULL; } chThdSleepMilliseconds(1000); } }
int main(void) { halInit(); chSysInit(); chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO - 1, Thread1, NULL); uint8_t my_addr, other_addr; if (true) { my_addr = 0x42; other_addr = 0x43; } else { my_addr = 0x43; other_addr = 0x42; } palSetPadMode(GPIOD, 5, PAL_MODE_ALTERNATE(7)); palSetPadMode(GPIOD, 6, PAL_MODE_ALTERNATE(7) + PAL_STM32_PUPDR_PULLUP); sdStart(&SD2, NULL); // PD5 TX, PD6 RX sdStart(&SD3, NULL); // connected to stlink sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(100); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); chThdSleepMilliseconds(100); net_init(my_addr); // interface 0, USB chThdCreateStatic(net_rx0_thd_wa, sizeof(net_rx0_thd_wa), NORMALPRIO - 1, net_rx0_thd, &SDU1); // interface 1 UART connection to other node chThdCreateStatic(net_rx1_thd_wa, sizeof(net_rx1_thd_wa), NORMALPRIO - 1, net_rx1_thd, &SD2); net_route_add(&net_node, other_addr, 0xff, 1, 0); int i = 0; while (true) { chprintf((BaseSequentialStream *)&SD3, "node %x, counting %d\n", my_addr, i++); chThdSleepMilliseconds(500); } }
/* * Application entry point. */ int main(void) { uint8_t i; /* * 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 SD1 and SPI1 drivers. */ sdStart(&SD1, NULL); /* Default: 38400,8,N,1. */ spiStart(&SPID1, &spicfg); /* * Creates the blinker threads. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, NULL); /* * Normal main() thread activity, in this demo it updates the 7-segments * display on the LPCXpresso main board using the SPI driver. */ i = 0; while (TRUE) { if (!palReadPad(GPIO0, GPIO0_SW3)) TestThread(&SD1); spiSelect(&SPID1); spiSend(&SPID1, 1, &digits[i]); /* Non polled method. */ spiUnselect(&SPID1); chThdSleepMilliseconds(500); spiSelect(&SPID1); spiPolledExchange(&SPID1, digits[i | 0x10]); /* Polled method. */ spiUnselect(&SPID1); chThdSleepMilliseconds(500); i = (i + 1) & 15; } }
/* * Application entry point. */ int main(void) { halInit(); chSysInit(); /* * Serial port initialization. */ sdStart(&SD1, NULL); chprintf((BaseSequentialStream *)&SD1, "Main (SD1 started)\r\n"); /* *Semaphore Initialization */ chSemInit(&mySemaphore, 1); /* * Set mode of PINES */ palSetPadMode(GPIO0_PORT, GPIO0_PAD, PAL_MODE_INPUT); //Input T1 palSetPadMode(GPIO1_PORT, GPIO1_PAD, PAL_MODE_INPUT); //Input T2 palSetPadMode(GPIO4_PORT, GPIO4_PAD, PAL_MODE_INPUT); //Input T3 palSetPadMode(GPIO17_PORT, GPIO17_PAD, PAL_MODE_INPUT); //Input T4 palSetPadMode(GPIO18_PORT, GPIO18_PAD, PAL_MODE_OUTPUT); //Output T1 palSetPadMode(GPIO22_PORT, GPIO22_PAD, PAL_MODE_OUTPUT); //Output T2 palSetPadMode(GPIO23_PORT, GPIO23_PAD, PAL_MODE_OUTPUT); //Output T3 palSetPadMode(GPIO24_PORT, GPIO24_PAD, PAL_MODE_OUTPUT); //Output T4 /* * Creates the blinker thread. */ chThdCreateStatic(waTh1, sizeof(waTh1), NORMALPRIO, Th1, NULL); chThdCreateStatic(waTh2, sizeof(waTh2), NORMALPRIO, Th2, NULL); chThdCreateStatic(waTh3, sizeof(waTh3), NORMALPRIO, Th3, NULL); chThdCreateStatic(waTh4, sizeof(waTh4), NORMALPRIO, Th4, NULL); /* * Events servicing loop. */ chThdWait(chThdSelf()); 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(); palSetPadMode(IOPORT3, BOARD_LED1, PAL_MODE_OUTPUT_PUSHPULL); palClearPad(IOPORT3, BOARD_LED1); /* * 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); /* * Starts the LED blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); while (true) { if (SDU1.config->usbp->state == USB_ACTIVE) { chnWrite(&SDU1, (const uint8_t *)"Hello from Arduino Leonardo!\r\n", 30); } chThdSleepMilliseconds(2113); } }
/* * 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(); /* * Shell manager initialization. */ shellInit(); /* * Activates the serial driver 6 using the driver default configuration. */ sdStart(&SD6, NULL); /* * Initializes the SDIO drivers. */ sdcStart(&SDCD1, &sdccfg); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Normal main() thread activity, spawning shells. */ while (true) { thread_t *shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE, "shell", NORMALPRIO + 1, shellThread, (void *)&shell_cfg1); chThdWait(shelltp); /* Waiting termination. */ chThdSleepMilliseconds(1000); } }
int main(void) { halInit(); chSysInit(); thread_t *tp; /*analog input*/ palSetPadMode(GPIOA, 6, PAL_MODE_INPUT_ANALOG); // this is 10th channel /*analog output*/ palSetPadMode(GPIOA, 4, PAL_MODE_INPUT_ANALOG); tp = chThdCreateStatic(analogReadWA, sizeof(analogReadWA), HIGHPRIO, adctodac, NULL); chThdWait(tp); return 0; }
void __late_init(void) { reset(); /* * 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(); /* After this call, scheduler, systick, heap, etc. are available. */ /* By doing chSysInit() here, it runs before C++ constructors, which may * require the heap. */ chSysInit(); }
/* * 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(); static GPTConfig gpt2cfg = { 2000, /* timer clock.*/ gpt2cb /* Timer callback.*/ }; DDRB |= _BV(DDB7); sdStart(&SD1, NULL); gptStart(&GPTD1,&gpt2cfg); gptStartContinuous(&GPTD1, 500); while(1){ chprintf(&SD1,"OCR1A: %d, TCCR1B, %x, period %d, counter: %d , TCNT1 %d\n",OCR1A,TCCR1B,GPTD1.period,GPTD1.counter,TCNT1); chThdSleepMilliseconds(100); } }
int MAIN(MAIN_FUNCTION_PARAMETERS) { // Initialize the HAL and enable interrupts. halInit(); INTERRUPTS_ON(); SERIAL_INIT(); PRINT_RESET_INFORMATION(); #ifdef EMBER_AF_PLUGIN_FREE_RTOS emberPluginRtosInitAndRunConnectTask(); #else initAndRunMainLoop(); #endif 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(); /* * GPIOI1 is programmed as output (board LED). */ palClearLine(LINE_ARD_D13); palSetLineMode(LINE_ARD_D13, PAL_MODE_OUTPUT_PUSHPULL); /* * 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(&USBD2); chThdSleepMilliseconds(1500); usbStart(&USBD2, &usbcfg); usbConnectBus(&USBD2); /* * Starting threads. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); chThdCreateStatic(waWriter, sizeof(waWriter), NORMALPRIO, Writer, NULL); chThdCreateStatic(waReader, sizeof(waReader), NORMALPRIO, Reader, NULL); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and check the button state. */ while (true) { chThdSleepMilliseconds(1000); } }