/** * @brief Toggle the Board_LED0 * @param <i>arg0</i> Determines the sleep period of the task * @param <i>arg1</i> unused * @return Void */ Void heartBeatFxn(UArg arg0, UArg arg1) { while (1) { Task_sleep((UInt)arg0); GPIO_toggle(Board_LED0); GPIO_toggle(Board_LED1); } }
Void Task_IDLE(UArg arg0, UArg arg1) { System_printf("\nTask_IDLE"); for (;;) { printf("_-"); fflush(stdout); GPIO_toggle(Board_LED0); GPIO_toggle(Board_LED1); Task_sleep(200); //One Tick is 1ms } }
Void Task_GPIO(UArg arg0, UArg arg1) { System_printf("\nTask_GPIO"); for (;;) { GPIO_toggle(EK_TM4C1294XL_Mk_DO_PN4); Task_sleep(200); //One Tick is 1ms } }
int sim800_open(){ UART_Params_init(&uartParams); uartParams.writeDataMode = UART_DATA_BINARY; uartParams.readDataMode = UART_DATA_BINARY; uartParams.readReturnMode = UART_RETURN_FULL; uartParams.readTimeout = SIM800_READ_TIMEOUT; uartParams.readEcho = UART_ECHO_OFF; uartParams.baudRate = SIM800_BAUD_RATE; uart = UART_open(Board_UART2_COMM, &uartParams); if (uart == NULL) { //debug GPIO_toggle(Board_LED_GREEN); Task_sleep(300); GPIO_toggle(Board_LED_GREEN); return 0; }else{ return 1; } }
//called periodically Void cron_quick_clock(UArg arg){ // flash led GPIO_toggle(Board_LED_GREEN); // use red led for user inputs /* MAVLINK HEARTBEAT */ // Initialize the message buffer static COMM_FRAME frame; mavlink_heartbeat_t hb=comm_get_mavlink_heartbeat(); // Pack the message mavlink_msg_heartbeat_encode(mavlink_system.sysid, mavlink_system.compid, &(frame.mavlink_message), &hb); comm_mavlink_broadcast(&frame); //send heartbeat for all available channel slots }
/* * ======== heartBeatFxn ======== * Toggle the Board_LED0. The Task_sleep is determined by arg0 which * is configured for the heartBeat Task instance. */ Void heartBeatFxn(UArg arg0, UArg arg1) { int i = 0; while (1) { Task_sleep(100); GPIO_toggle(Board_LED0); int minutes = i/(1000*60); buff1[15] = i%10 + '0'; buff1[14] = '.'; buff1[13] = (i%(60*1000))%10 + '0'; buff1[12] = (i%(60*1000)/10)%10 + '0'; //minutes buff1[11] = minutes%10 + '0'; buff1[10] = (minutes/10)%10 + '0'; i++; } }
Void clk1Fxn(UArg arg0) { GPIO_toggle(Board_LED1); }
Void clk0Fxn(UArg arg0) { GPIO_toggle(Board_LED0); }
void led_toggle(micromouse_gpio_name_t color){ GPIO_toggle(color); };
//must be called from within a task - this function will block! //returns 1 if modem responds with OK int hm10_begin(){ memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer)); UART_Params_init(&uartParams); uartParams.writeDataMode = UART_DATA_BINARY; uartParams.readMode = UART_MODE_BLOCKING; uartParams.readTimeout = HM10_READ_TIMEOUT; uartParams.readDataMode = UART_DATA_BINARY; uartParams.readReturnMode = UART_RETURN_FULL; uartParams.readEcho = UART_ECHO_OFF; uartParams.baudRate = HM10_BAUD_RATE; uart = UART_open(Board_UART2_COMM, &uartParams); if (uart == NULL) { //debug GPIO_toggle(Board_LED_GREEN); Task_sleep(300); GPIO_toggle(Board_LED_GREEN); return 0; } else { Task_sleep(1000); UART_write(uart, hm10_at_wakestring, strlen(hm10_at_wakestring)); UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer)); serial_printf(cli_stdout, "%s\n", hm10_rxBuffer); memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer)); UART_write(uart, hm10_at_pwrm1, strlen(hm10_at_pwrm1)); UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer)); serial_printf(cli_stdout, "%s\n", hm10_rxBuffer); memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer)); Task_sleep(1000); UART_write(uart, hm10_at_clear, strlen(hm10_at_clear)); UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer)); serial_printf(cli_stdout, "%s\n", hm10_rxBuffer); memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer)); Task_sleep(500); UART_write(uart, hm10_at_imme1, strlen(hm10_at_imme1)); UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer)); serial_printf(cli_stdout, "%s\n", hm10_rxBuffer); memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer)); Task_sleep(1000); UART_write(uart, hm10_at_name, strlen(hm10_at_name)); UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer)); serial_printf(cli_stdout, "%s\n", hm10_rxBuffer); memset(&hm10_rxBuffer, 0, sizeof(hm10_rxBuffer)); Task_sleep(1000); UART_write(uart, hm10_at, strlen(hm10_at)); UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer)); serial_printf(cli_stdout, "%s\n", hm10_rxBuffer); if(!strcmp("OK", hm10_rxBuffer)){ UART_write(uart, hm10_at_start, strlen(hm10_at_start)); hm10_end(); // Close UART port to configure Text mode to callback @ newline + CR uartParams.writeDataMode = UART_DATA_BINARY; /* Experimental: use callback mode such that the comm task is not blocked * while waiting for incoming commands. * * Note: think about using void UART_readCancel ( UART_Handle handle ) * WARNING: It is STRONGLY discouraged to call UART_read from its own callback function (UART_MODE_CALLBACK). */ uartParams.readMode = UART_MODE_CALLBACK; uartParams.readCallback = hm10_read_callback; uartParams.readTimeout = UART_WAIT_FOREVER; //HM10_READ_TIMEOUT; uartParams.readDataMode = UART_DATA_TEXT; uartParams.readReturnMode = UART_RETURN_NEWLINE; uart = UART_open(Board_UART2_COMM, &uartParams); if (uart == NULL) { //debug GPIO_toggle(Board_LED_GREEN); Task_sleep(300); GPIO_toggle(Board_LED_GREEN); return 0; } else { hm10_initialised = 1; // directly be receptive for commands hm10_callback = 0; UART_read(uart, hm10_rxBuffer, sizeof(hm10_rxBuffer)); return 1; //modem can now communicate with us } } else { return 0; } } }
/********************************************************************* * @fn OADTarget_imgBlockWrite * * @brief Process the Image Block Write. * * @param connHandle - connection message was received on * @param pValue - pointer to data to be written * * @return status */ bStatus_t OADTarget_imgBlockWrite(uint16_t connHandle, uint8_t *pValue) { volatile uint16_t blkNum; blkNum = BUILD_UINT16(pValue[0], pValue[1]); // First block of OAD which included image header and CRC and CRC shadow // values. Do a sanity check on the received image header if (blkNum == 0) { img_hdr_t ImgHdr; uint16_t blkTot; blkTot = BUILD_UINT16(pValue[8], pValue[9]) / (OAD_BLOCK_SIZE / HAL_FLASH_WORD_SIZE); // Read out running image's header. uint8_t *flashAddr = (uint8_t *)(APP_IMAGE_START + OAD_IMG_HDR_OSET); memcpy(&ImgHdr,flashAddr,sizeof(img_hdr_t)); // Note: if additional customer criteria was checked in the Image // Identification step, it may be important to check again here. if ((oadBlkNum != blkNum) || (oadBlkTot != blkTot) ) { // Cancel download OADTarget_rejectImage(connHandle, &ImgHdr); // NB! This is meaningless for a WriteNoResp operation return (ATT_ERR_WRITE_NOT_PERMITTED); } #ifdef POWER_SAVING Power_setConstraint(Power_SB_DISALLOW); #endif } // Check that this is the expected block number. if (oadBlkNum == blkNum && flashOk) { uint32_t addr; // Calculate address to write as (start of OAD range) + (offset) addr = APP_IMAGE_START + oadBlkNum * OAD_BLOCK_SIZE; // If address starts a new page, erase that page first. if ((addr % HAL_FLASH_PAGE_SIZE) == 0) { flashOk = extFlashErase(addr, HAL_FLASH_PAGE_SIZE); } // Write a 16 byte block to Flash. if (flashOk) { flashOk = extFlashWrite(addr, OAD_BLOCK_SIZE, pValue+2); // Increment received block count. if (flashOk) oadBlkNum++; } // Toggle Green LED for every 8th block if ( (oadBlkNum % 8) == 0) { GPIO_toggle(Board_LED2); } } else { img_hdr_t ImgHdr; // Toggle RED LED and sound buzzer when overflow GPIO_toggle(Board_LED1); GPIO_toggle(Board_BUZZER); #ifdef POWER_SAVING Power_releaseConstraint(Power_SB_DISALLOW); #endif // Cancel download ImgHdr.len = 0; // Don't care content OADTarget_rejectImage(connHandle, &ImgHdr); } // Check if the OAD Image is complete. if (oadBlkNum == oadBlkTot) { extFlashClose(); // Run CRC check on new image. if (checkDL()) { HAL_SYSTEM_RESET(); } else { GPIO_toggle(Board_LED1); } #ifdef POWER_SAVING Power_releaseConstraint(Power_SB_DISALLOW); #endif } else { // Request the next OAD Image block. OADTarget_getNextBlockReq(connHandle, oadBlkNum); } return (SUCCESS); }
void main(void) { CPU_Handle myCpu; PLL_Handle myPll; WDOG_Handle myWDog; // Initialize all the handles needed for this application myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj)); myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj)); myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj)); myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj)); myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj)); myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj)); myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj)); myPwm2 = PWM_init((void *)PWM_ePWM2_BASE_ADDR, sizeof(PWM_Obj)); myPwm3 = PWM_init((void *)PWM_ePWM3_BASE_ADDR, sizeof(PWM_Obj)); myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj)); // Perform basic system initialization WDOG_disable(myWDog); CLK_enableAdcClock(myClk); (*Device_cal)(); CLK_disableAdcClock(myClk); //Select the internal oscillator 1 as the clock source CLK_setOscSrc(myClk, CLK_OscSrc_Internal); // Setup the PLL for x10 /2 which will yield 50Mhz = 10Mhz * 10 / 2 PLL_setup(myPll, PLL_Multiplier_10, PLL_DivideSelect_ClkIn_by_2); // Disable the PIE and all interrupts PIE_disable(myPie); PIE_disableAllInts(myPie); CPU_disableGlobalInts(myCpu); CPU_clearIntFlags(myCpu); // Setup a debug vector table and enable the PIE PIE_setDebugIntVectorTable(myPie); PIE_enable(myPie); // Register interrupt handlers in the PIE vector table PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_1, (intVec_t)&EPwm1_timer_isr); PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_2, (intVec_t)&EPwm2_timer_isr); PIE_registerPieIntHandler(myPie, PIE_GroupNumber_3, PIE_SubGroupNumber_3, (intVec_t)&EPwm3_timer_isr); // Initialize the EPwm Timers used in this example InitEPwmTimer(); #ifdef _FLASH // Copy time critical code and Flash setup code to RAM // This includes the following ISR functions: EPwm1_timer_isr(), EPwm2_timer_isr() // and FLASH_setup(); // The RamfuncsLoadStart, RamfuncsLoadSize, and RamfuncsRunStart // symbols are created by the linker. Refer to the F2280270.cmd file. memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize); // Call Flash Initialization to setup flash waitstates // This function must reside in RAM FLASH_setup(myFlash); #endif // end #ifdef _FLASH // Initalize counters: EPwm1TimerIntCount = 0; EPwm2TimerIntCount = 0; EPwm3TimerIntCount = 0; LoopCount = 0; // Enable CPU INT3 which is connected to EPwm1-3 INT: CPU_enableInt(myCpu, CPU_IntNumber_3); // Enable EPwm INTn in the PIE: Group 3 interrupt 1-3. PIE_enablePwmInt(myPie, PWM_Number_1); PIE_enablePwmInt(myPie, PWM_Number_2); PIE_enablePwmInt(myPie, PWM_Number_3); // Enable global Interrupts and higher priority real-time debug events CPU_enableGlobalInts(myCpu); CPU_enableDebugInt(myCpu); // Configure GPIO so it can toggle in the idle loop GPIO_setMode(myGpio, GPIO_Number_34, GPIO_34_Mode_GeneralPurpose); GPIO_setDirection(myGpio, GPIO_Number_34, GPIO_Direction_Output); for(;;) { // This loop will be interrupted, so the overall // delay between pin toggles will be longer. DELAY_US(DELAY); LoopCount++; // Toggle GPIO GPIO_toggle(myGpio, GPIO_Number_34); } }