void ETH_IRQ_Handler(void) { portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE; if( ETH_GetDMAFlagStatus(ETH_DMA_FLAG_AIS) == SET) { vTracePrintF(xTraceOpenLabel("ETH IRQ"), "AIS received"); ETH_DMAClearITPendingBit(ETH_DMA_IT_AIS); if(ETH_GetDMAFlagStatus(ETH_DMA_IT_RBU) == SET) { vTracePrintF(xTraceOpenLabel("ETH IRQ"), "RBU received"); ETH_DMAClearITPendingBit(ETH_DMA_IT_RBU); } if(ETH_GetDMAFlagStatus(ETH_DMA_IT_RPS) == SET) { vTracePrintF(xTraceOpenLabel("ETH IRQ"), "RPS received"); ETH_DMAClearITPendingBit(ETH_DMA_IT_RPS); } if(ETH_GetDMAFlagStatus(ETH_DMA_IT_RO) == SET) { vTracePrintF(xTraceOpenLabel("ETH IRQ"), "RO received"); ETH_DMAClearITPendingBit(ETH_DMA_IT_RO); } if(ETH_GetDMAFlagStatus(ETH_DMA_IT_FBE) == SET) { vTracePrintF(xTraceOpenLabel("ETH IRQ"), "FBE received"); ETH_DMAClearITPendingBit(ETH_DMA_IT_FBE); } } if( ETH_GetDMAFlagStatus(ETH_DMA_FLAG_NIS) == SET) { /* Frame received */ if ( ETH_GetDMAFlagStatus(ETH_DMA_FLAG_R) == SET) { //vTracePrintF(xTraceOpenLabel("ETH IRQ"), "R received"); /* Give the semaphore to wakeup LwIP task (ethernetif_input)*/ xSemaphoreGiveFromISR( s_xSemaphore, &xHigherPriorityTaskWoken ); /* Clear the interrupt flags. */ /* Clear the Eth DMA Rx IT pending bits */ ETH_DMAClearITPendingBit(ETH_DMA_IT_R); ETH_DMAClearITPendingBit(ETH_DMA_IT_NIS); } } /* Switch tasks if necessary. */ if( xHigherPriorityTaskWoken != pdFALSE ) { portEND_SWITCHING_ISR( xHigherPriorityTaskWoken ); } }
int main( void ) { /* Initialise the trace recorder and create the label used to post user events to the trace recording on each tick interrupt. */ vTraceInitTraceData(); xTickTraceUserEvent = xTraceOpenLabel( "tick" ); /* Start the trace recording - the recording is written to a file if configASSERT() is called. */ printf( "\r\nTrace started. Hit a key to dump trace file to disk.\r\n" ); uiTraceStart(); /* The mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting is described at the top of this file. */ #if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 ) { main_blinky(); } #else { main_full(); } #endif return 0; }
int main( void ) { /* This demo uses heap_5.c, so start by defining some heap regions. This is only done to provide an example as this demo could easily create one large heap region instead of multiple smaller heap regions - in which case heap_4.c would be the more appropriate choice. No initialisation is required when heap_4.c is used. */ prvInitialiseHeap(); /* Initialise the trace recorder and create the label used to post user events to the trace recording on each tick interrupt. */ vTraceInitTraceData(); xTickTraceUserEvent = xTraceOpenLabel( "tick" ); /* Start the trace recording - the recording is written to a file if configASSERT() is called. */ printf( "\r\nTrace started. Hit a key to dump trace file to disk (does not work from Eclipse console).\r\n" ); fflush( stdout ); uiTraceStart(); /* The mainCREATE_SIMPLE_BLINKY_DEMO_ONLY setting is described at the top of this file. */ #if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 ) { main_blinky(); } #else { main_full(); } #endif return 0; }
int main(void) { /* This demo uses heap_5.c, so start by defining some heap regions. This is only done to provide an example as this demo could easily create one large heap region instead of multiple smaller heap regions */ prvInitialiseHeap(); /* Initialise the trace recorder and create the label used to post user events to the trace recording on each tick interrupt. */ vTraceInitTraceData(); xTickTraceUserEvent = xTraceOpenLabel("tick"); vSemaphoreCreateBinary(xSemaphore); xQueue = xQueueCreate(4, sizeof(struct Message*)); /* Create the task, storing the handle. */ xTaskCreate((pdTASK_CODE)matrix_task, (signed char *)"Matrix", 1000, NULL, 3, &matrix_handle); xTaskCreate((pdTASK_CODE)reader_task, (signed char *)"Reader", 1000, NULL, 3, &reader_handle); //This starts the real-time scheduler vTaskStartScheduler(); for (;; ); return 0; }
int main( void ) { const uint32_t ulLongTime_ms = 250UL; /* Initialise the trace recorder and create the label used to post user events to the trace recording on each tick interrupt. */ vTraceInitTraceData(); xTickTraceUserEvent = xTraceOpenLabel( "tick" ); /* Create the queue used to pass messages from the queue send task to the queue receive task. */ xQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( unsigned long ) ); /* Give the queue a name for the FreeRTOS+Trace log. */ vTraceSetQueueName( xQueue, "DemoQ" ); /* Start the two tasks as described in the comments at the top of this file. */ xTaskCreate( prvQueueReceiveTask, /* The function that implements the task. */ "Rx", /* The text name assigned to the task - for debug only as it is not used by the kernel. */ configMINIMAL_STACK_SIZE, /* The size of the stack to allocate to the task. Not actually used as a stack in the Win32 simulator port. */ NULL, /* The parameter passed to the task - not used in this example. */ mainQUEUE_RECEIVE_TASK_PRIORITY, /* The priority assigned to the task. */ NULL ); /* The task handle is not required, so NULL is passed. */ xTaskCreate( prvQueueSendTask, "TX", configMINIMAL_STACK_SIZE, NULL, mainQUEUE_SEND_TASK_PRIORITY, NULL ); /* Create the task that handles the CLI on a UDP port. The port number is set using the configUDP_CLI_PORT_NUMBER setting in FreeRTOSConfig.h. */ xTaskCreate( vUDPCommandInterpreterTask, "CLI", configMINIMAL_STACK_SIZE, NULL, mainUDP_CLI_TASK_PRIORITY, NULL ); /* Register commands with the FreeRTOS+CLI command interpreter. */ vRegisterCLICommands(); /* Start the tasks and timer running. */ vTaskStartScheduler(); /* If all is well, the scheduler will now be running, and the following line will never be reached. If the following line does execute, then there was insufficient FreeRTOS heap memory available for the idle and/or timer tasks to be created. See the memory management section on the FreeRTOS web site for more details (this is standard text that is not not really applicable to the Win32 simulator port). */ for( ;; ) { Sleep( ulLongTime_ms ); } }
int main(void) { /* This demo uses heap_5.c, so start by defining some heap regions. This is only done to provide an example as this demo could easily create one large heap region instead of multiple smaller heap regions */ prvInitialiseHeap(); /* Initialise the trace recorder and create the label used to post user events to the trace recording on each tick interrupt. */ vTraceInitTraceData(); xTickTraceUserEvent = xTraceOpenLabel("tick"); //This starts the real-time scheduler vTaskStartScheduler(); for (;; ); return 0; }
void Communications(void * pvParameters){ msg.Payload = msgBuff; vSemaphoreCreateBinary(DataSmphr); if (DataSmphr==NULL){ while(1); } qUART_Register_RBR_Callback(UART_GROUNDCOMM, UART_Rx_Handler); qUART_EnableRx(UART_GROUNDCOMM); comms_trcLabel = xTraceOpenLabel("Comms task"); for (;;){ if (pdTRUE == xSemaphoreTake(DataSmphr,500/portTICK_RATE_MS)){ vTracePrintF(comms_trcLabel,"Got joystick package"); switch (msg.Type){ case MSG_TYPE_CONTROL: memcpy(&quadrotor.joystick,msg.Payload,10); case MSG_TYPE_DEBUG: break; case MSG_TYPE_SYSTEM: switch (msg.Payload[0]) { case COMMAND_READ: commandRead(&msg.Payload[1]); break; case COMMAND_WRITE: commandWrite(&msg.Payload[1]); break; default: break; } break; default: break; } }else{ // Timeout to get a new joystick commands, values to 0 vTracePrintF(comms_trcLabel,"Joystick package timeout"); memset(&quadrotor.joystick,0,sizeof(quadrotor.joystick)); } } }
static void prvZeroCopyEchoClientTask( void *pvParameters ) { xSocket_t xSocket; struct freertos_sockaddr xEchoServerAddress; static char cTxString[ 40 ]; int32_t lLoopCount = 0UL; volatile uint32_t ulRxCount = 0UL, ulTxCount = 0UL; uint32_t xAddressLength = sizeof( xEchoServerAddress ); int32_t lReturned; uint8_t *pucUDPPayloadBuffer; const int32_t lMaxLoopCount = 50; const char * const pcStringToSend = "Zero copy message number"; /* The buffer is large enough to hold the string, a number, and the string terminator. */ const size_t xBufferLength = strlen( pcStringToSend ) + 15; #if ipconfigINCLUDE_EXAMPLE_FREERTOS_PLUS_TRACE_CALLS == 1 { /* When the trace recorder code is included user events are generated to mark the sending and receiving of the echoed data (only in the zero copy task). */ xZeroCopySendEvent = xTraceOpenLabel( "ZeroCopyTx" ); xZeroCopyReceiveEvent = xTraceOpenLabel( "ZeroCopyRx" ); } #endif /* ipconfigINCLUDE_EXAMPLE_FREERTOS_PLUS_TRACE_CALLS */ /* Remove compiler warning about unused parameters. */ ( void ) pvParameters; /* Delay for a little while to ensure the task is out of synch with the other echo task implemented above. */ vTaskDelay( echoLOOP_DELAY >> 1 ); /* Echo requests are sent to the echo server. The address of the echo server is configured by the constants configECHO_SERVER_ADDR0 to configECHO_SERVER_ADDR3 in FreeRTOSConfig.h. */ xEchoServerAddress.sin_port = FreeRTOS_htons( echoECHO_PORT ); xEchoServerAddress.sin_addr = FreeRTOS_inet_addr_quick( configECHO_SERVER_ADDR0, configECHO_SERVER_ADDR1, configECHO_SERVER_ADDR2, configECHO_SERVER_ADDR3 ); for( ;; ) { /* Create a socket. */ xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP ); configASSERT( xSocket != FREERTOS_INVALID_SOCKET ); /* Set a time out so a missing reply does not cause the task to block indefinitely. */ FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) ); /* Send a number of echo requests. */ for( lLoopCount = 0; lLoopCount < lMaxLoopCount; lLoopCount++ ) { /* This task is going to send using the zero copy interface. The data being sent is therefore written directly into a buffer that is passed by reference into the FreeRTOS_sendto() function. First obtain a buffer of adequate size from the IP stack. Although a max delay is used, the actual delay will be capped to ipconfigMAX_SEND_BLOCK_TIME_TICKS, hence the test to ensure a buffer was actually obtained. */ pucUDPPayloadBuffer = ( uint8_t * ) FreeRTOS_GetUDPPayloadBuffer( xBufferLength, portMAX_DELAY ); if( pucUDPPayloadBuffer != NULL ) { /* A buffer was successfully obtained. Create the string that is sent to the echo server. Note the string is written directly into the buffer obtained from the IP stack. */ sprintf( ( char * ) pucUDPPayloadBuffer, "%s %u\r\n", "Zero copy message number", ( unsigned int ) ulTxCount ); /* Also copy the string into a local buffer so it can be compared with the string that is later received back from the echo server. */ strcpy( cTxString, ( char * ) pucUDPPayloadBuffer ); /* Pass the buffer into the send function. ulFlags has the FREERTOS_ZERO_COPY bit set so the IP stack will take control of the buffer, rather than copy data out of the buffer. */ echoMARK_SEND_IN_TRACE_BUFFER( xZeroCopySendEvent ); lReturned = FreeRTOS_sendto( xSocket, /* The socket being sent to. */ ( void * ) pucUDPPayloadBuffer, /* The buffer being passed into the IP stack. */ strlen( cTxString ) + 1, /* The length of the data being sent. Plus 1 to ensure the null terminator is part of the data. */ FREERTOS_ZERO_COPY, /* ulFlags with the zero copy bit is set. */ &xEchoServerAddress, /* Where the data is being sent. */ sizeof( xEchoServerAddress ) ); if( lReturned == 0 ) { /* The send operation failed, so this task is still responsible for the buffer obtained from the IP stack. To ensure the buffer is not lost it must either be used again, or, as in this case, returned to the IP stack using FreeRTOS_ReleaseUDPPayloadBuffer(). pucUDPPayloadBuffer can be safely re-used to receive from the socket below once the buffer has been returned to the stack. */ FreeRTOS_ReleaseUDPPayloadBuffer( ( void * ) pucUDPPayloadBuffer ); } else { /* The send was successful so the IP stack is now managing the buffer pointed to by pucUDPPayloadBuffer, and the IP stack will return the buffer once it has been sent. pucUDPPayloadBuffer can be safely re-used to receive from the socket below. */ } /* Keep a count of how many echo requests have been transmitted so it can be compared to the number of echo replies received. It would be expected to loose at least one to an ARP message the first time the connection is created. */ ulTxCount++; /* Receive data on the socket. ulFlags has the zero copy bit set (FREERTOS_ZERO_COPY) indicating to the stack that a reference to the received data should be passed out to this task using the second parameter to the FreeRTOS_recvfrom() call. When this is done the IP stack is no longer responsible for releasing the buffer, and the task *must* return the buffer to the stack when it is no longer needed. By default the receive block time is portMAX_DELAY. */ echoMARK_SEND_IN_TRACE_BUFFER( xZeroCopyReceiveEvent ); lReturned = FreeRTOS_recvfrom( xSocket, /* The socket to receive from. */ ( void * ) &pucUDPPayloadBuffer, /* pucUDPPayloadBuffer will be set to point to the buffer that already contains the received data. */ 0, /* Ignored because the zero copy interface is being used. */ FREERTOS_ZERO_COPY, /* ulFlags with the FREERTOS_ZERO_COPY bit set. */ &xEchoServerAddress, /* The address from which the data was sent. */ &xAddressLength ); if( lReturned > 0 ) { /* Compare the string sent to the echo server with the string received back from the echo server. */ if( strcmp( ( char * ) pucUDPPayloadBuffer, cTxString ) == 0 ) { /* The strings matched. */ ulRxCount++; } /* The buffer that contains the data passed out of the stack *must* be returned to the stack. */ FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayloadBuffer ); } } } /* Pause for a short while to ensure the network is not too congested. */ vTaskDelay( echoLOOP_DELAY ); /* Close this socket before looping back to create another. */ FreeRTOS_closesocket( xSocket ); } }