/**
* @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);
}
}
