static err_t low_level_output(struct netif *netif, struct pbuf *p)
{
static xSemaphoreHandle xTxSemaphore = NULL;
struct pbuf *q;
u32_t l = 0;
if( xTxSemaphore == NULL )
{
vSemaphoreCreateBinary( xTxSemaphore );
}
#if ETH_PAD_SIZE
pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
#endif
/* Access to the EMAC is guarded using a semaphore. */
if( xSemaphoreTake( xTxSemaphore, netifGUARD_BLOCK_TIME ) )
{
for(q = p; q != NULL; q = q->next) {
/* Send the data from the pbuf to the interface, one pbuf at a
time. The size of the data in each pbuf is kept in the ->len
variable. */
memcpy(&TxBuff[l], (u8_t*)q->payload, q->len);
l += q->len;
}
ENET_TxPkt(0, l);
#if ETH_PAD_SIZE
pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
#endif
#if LINK_STATS
lwip_stats.link.xmit++;
#endif /* LINK_STATS */
xSemaphoreGive( xTxSemaphore );
}
return ERR_OK;
}
void STBT_Init(COM_TypeDef SerialCOM)
{
USART_InitTypeDef USART_InitStruct;
BT_State=Active_Command_mode;
BTCOM=SerialCOM;
USART_InitStruct.USART_BaudRate=115200;
USART_InitStruct.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
USART_InitStruct.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
USART_InitStruct.USART_Parity=USART_Parity_No;
USART_InitStruct.USART_StopBits=USART_StopBits_1;
USART_InitStruct.USART_WordLength=USART_WordLength_8b;
CU_COMInit(SerialCOM,&USART_InitStruct);
vSemaphoreCreateBinary(BT_UART_sem);
BT_UART_RX_Queue = xQueueCreate( 100, sizeof( uint8_t ) );
xTaskCreate(STBT_Task, "BlueTooth", 5*configMINIMAL_STACK_SIZE, NULL, 9, NULL);
}
struct pios_semaphore *PIOS_Semaphore_Create(void)
{
struct pios_semaphore *sema = PIOS_malloc(sizeof(struct pios_semaphore));
if (sema == NULL)
return NULL;
/*
* The initial state of a binary semaphore is "given".
* FreeRTOS executes a "give" upon creation.
*/
#if defined(PIOS_INCLUDE_FREERTOS)
vSemaphoreCreateBinary(sema->sema_handle);
#else
sema->sema_count = 1;
#endif
return sema;
}
int main( void )
{
/* Setup the peripheral bus to be the same as the PLL output. */
VPBDIV = mainBUS_CLK_FULL;
/* Create the queue used to pass message to vPrintTask. */
xPrintQueue = xQueueCreate( mainQUEUE_SIZE, sizeof( char * ) );
/* Create the semaphore used to wake vButtonHandlerTask(). */
vSemaphoreCreateBinary( xButtonSemaphore );
xSemaphoreTake( xButtonSemaphore, 0 );
/* Start the standard demo tasks. */
vStartIntegerMathTasks( tskIDLE_PRIORITY );
vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
vStartDynamicPriorityTasks();
vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );
#if configUSE_PREEMPTION == 1
{
/* The timing of console output when not using the preemptive
scheduler causes the block time tests to detect a timing problem. */
vCreateBlockTimeTasks();
}
#endif
vStartRecursiveMutexTasks();
/* Start the tasks defined within this file. */
xTaskCreate( vLEDTask, "LED", configMINIMAL_STACK_SIZE, NULL, mainLED_TASK_PRIORITY, NULL );
xTaskCreate( vCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );
xTaskCreate( vPrintTask, "Print", configMINIMAL_STACK_SIZE, NULL, mainPRINT_TASK_PRIORITY, NULL );
xTaskCreate( vButtonHandlerTask, "Button", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );
/* Start the scheduler. */
vTaskStartScheduler();
/* The scheduler should now be running, so we will only ever reach here if we
ran out of heap space. */
return 0;
}
int main(void)
{
//Start the HW
initHardware();
ciaaWriteOutput(3,0);
// Create a semaphore
vSemaphoreCreateBinary(xSemaphore);
xSemaphoreTake(xSemaphore,0);
//Create task to read the button
xTaskCreate(taskReadButton, (const char *)"taskReadButton", configMINIMAL_STACK_SIZE*2, 0, tskIDLE_PRIORITY+1, 0);
//Create task to blick the led
xTaskCreate(taskBlickLed, (const char *)"taskReadButton", configMINIMAL_STACK_SIZE*2, 0, tskIDLE_PRIORITY+1, 0);
//Start the Scheduler
vTaskStartScheduler();
while (1) {
}
}
void SHT10Init(void) {
GPIO_InitTypeDef GPIO_InitStructure;
if (__semaphore != NULL) {
return;
}
vSemaphoreCreateBinary(__semaphore);
GPIO_InitStructure.GPIO_Pin = CLK_GPIO_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
GPIO_Init(CLK_GPIO_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = DAT_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
GPIO_Init(DAT_GPIO_PORT, &GPIO_InitStructure);
__clkSetLow();
__clkDataLow();
}
int main()
{
init_rs232();
enable_rs232_interrupts();
enable_rs232();
fs_init();
fio_init();
//register_fs(&ramfs_r);
register_devfs();
register_ramfs();
fs_mount(NULL, RAMFS_TYPE, NULL);
// register_romfs("romfs", &_sromfs);
// register_ramfs("ramfs");
/* Create the queue used by the serial task. Messages for write to
* the RS232. */
vSemaphoreCreateBinary(serial_tx_wait_sem);
/* Add for serial input
* Reference: www.freertos.org/a00116.html */
serial_rx_queue = xQueueCreate(1, sizeof(char));
/* Create a task to output text read from romfs. */
xTaskCreate(command_prompt,
"CLI",
512 /* stack size */, NULL, tskIDLE_PRIORITY + 2, NULL);
#if 0
/* Create a task to record system log. */
xTaskCreate(system_logger,
(signed portCHAR *) "Logger",
1024 /* stack size */, NULL, tskIDLE_PRIORITY + 1, NULL);
#endif
/* Start running the tasks. */
vTaskStartScheduler();
return 0;
}
portBASE_TYPE xNetworkInterfaceInitialise( void )
{
EMAC_CFG_Type Emac_Config;
PINSEL_CFG_Type xPinConfig;
portBASE_TYPE xStatus, xReturn;
extern uint8_t ucMACAddress[ 6 ];
/* Enable Ethernet Pins */
boardCONFIGURE_ENET_PINS( xPinConfig );
Emac_Config.Mode = EMAC_MODE_AUTO;
Emac_Config.pbEMAC_Addr = ucMACAddress;
xStatus = EMAC_Init( &Emac_Config );
LPC_EMAC->IntEnable &= ~( EMAC_INT_TX_DONE );
if( xStatus != ERROR )
{
vSemaphoreCreateBinary( xEMACRxEventSemaphore );
configASSERT( xEMACRxEventSemaphore );
/* The handler task is created at the highest possible priority to
ensure the interrupt handler can return directly to it. */
xTaskCreate( prvEMACHandlerTask, ( const signed char * const ) "EMAC", configMINIMAL_STACK_SIZE, NULL, configMAX_PRIORITIES - 1, NULL );
/* Enable the interrupt and set its priority to the minimum
interrupt priority. */
NVIC_SetPriority( ENET_IRQn, configMAC_INTERRUPT_PRIORITY );
NVIC_EnableIRQ( ENET_IRQn );
xReturn = pdPASS;
}
else
{
xReturn = pdFAIL;
}
configASSERT( xStatus != ERROR );
return xReturn;
}
static void low_level_init( struct netif *pnetif )
{
// set MAC hardware address length
pnetif->hwaddr_len = ETHARP_HWADDR_LEN;
// set MAC hardware address
//MACStrToBin( DEFAULT_MAC_ADDR, pnetif->hwaddr );
pnetif->hwaddr[ 0 ] = 0x00;
pnetif->hwaddr[ 1 ] = 0x04;
pnetif->hwaddr[ 2 ] = 0xa3;
pnetif->hwaddr[ 3 ] = 0x00;
pnetif->hwaddr[ 4 ] = 0x00;
pnetif->hwaddr[ 5 ] = 0x02;
// maximum transfer unit
pnetif->mtu = netifMTU;
// device capabilities.
// don't set NETIF_FLAG_ETHARP if this device is not an ethernet one
pnetif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
// Do whatever else is needed to initialize interface.
if ( s_xSemaphore == NULL )
{
vSemaphoreCreateBinary( s_xSemaphore );
xSemaphoreTake( s_xSemaphore, 0);
}
// Initialise the MAC.
enc28j60_MACInit( pnetif );
pnetif->flags |= NETIF_FLAG_LINK_UP;
// Create the task that handles the EMAC.
sys_thread_new( ( signed portCHAR *)"eth",
ethernetif_input,
(void *)pnetif,
netifINTERFACE_TASK_STACK_SIZE,
netifINTERFACE_TASK_PRIORITY );
}
//---------------------------------------------------------------------------------------------
static void setup_debug_port_peri(void)
{
USART_InitTypeDef USART_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
txchars_queue = xQueueCreate(100, sizeof(signed char));
vSemaphoreCreateBinary(xRxCompleteSemaphore);
xSemaphoreTake(xRxCompleteSemaphore, 0);
/* Enable USART1 clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);
/* Configure USART1 Rx (PA10) as input floating */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure USART1 Tx (PA9) as alternate function push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
/* Configure the USARTx */
USART_Init(USART1, &USART_InitStructure);
NVIC_EnableIRQ(USART1_IRQn);
/* Enable the USARTx */
USART_Cmd(USART1, ENABLE);
}
/**
* Initialize the UAVTalk library
* \param[in] connection UAVTalkConnection to be used
* \param[in] outputStream Function pointer that is called to send a data buffer
* \return 0 Success
* \return -1 Failure
*/
UAVTalkConnection UAVTalkInitialize(UAVTalkOutputStream outputStream)
{
// allocate object
UAVTalkConnectionData * connection = pvPortMalloc(sizeof(UAVTalkConnectionData));
if (!connection) return 0;
connection->canari = UAVTALK_CANARI;
connection->iproc.rxPacketLength = 0;
connection->iproc.state = UAVTALK_STATE_SYNC;
connection->outStream = outputStream;
connection->lock = xSemaphoreCreateRecursiveMutex();
connection->transLock = xSemaphoreCreateRecursiveMutex();
// allocate buffers
connection->rxBuffer = pvPortMalloc(UAVTALK_MAX_PACKET_LENGTH);
if (!connection->rxBuffer) return 0;
connection->txBuffer = pvPortMalloc(UAVTALK_MAX_PACKET_LENGTH);
if (!connection->txBuffer) return 0;
vSemaphoreCreateBinary(connection->respSema);
xSemaphoreTake(connection->respSema, 0); // reset to zero
UAVTalkResetStats( (UAVTalkConnection) connection );
return (UAVTalkConnection) connection;
}
int sv_init(uint32_t initial_timeout) {
/* Init list semaphore */
vSemaphoreCreateBinary(sv_sem);
if (sv_sem == NULL) {
printf("Failed to create supervisor semaphore\r\n");
return -1;
}
/* Set maximum timeout */
interval = initial_timeout;
/* Start task */
if (xTaskCreate(&sv_task, (signed char *)"SV", 1024, NULL, configMAX_PRIORITIES - 1, NULL) != pdPASS) {
printf("Failed to create supervisor task\r\n");
return -1;
}
return 0;
}
static void prvSetupEMACInterrupt( void )
{
/* Create the semaphore used to trigger the EMAC task. */
vSemaphoreCreateBinary( xSemaphore );
if( xSemaphore )
{
/* We start by 'taking' the semaphore so the ISR can 'give' it when the
first interrupt occurs. */
xSemaphoreTake( xSemaphore, emacNO_DELAY );
portENTER_CRITICAL();
{
/* We want to interrupt on Rx and Tx events. */
AT91C_BASE_EMAC->EMAC_IER = AT91C_EMAC_RCOMP | AT91C_EMAC_TCOMP;
/* Enable the interrupts in the AIC. */
AT91F_AIC_ConfigureIt( AT91C_ID_EMAC, emacINTERRUPT_LEVEL, AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL, ( void (*)( void ) ) vEMACISR_Wrapper );
AT91C_BASE_AIC->AIC_IECR = 0x1 << AT91C_ID_EMAC;
}
portEXIT_CRITICAL();
}
}
//---------------------------------------------------------------------------------------------
static void setup_uart(struct UartPort *port)
{
port->cache_tx.queue = xQueueCreate(port->cache_tx.queue_length, sizeof(uint8_t));
port->cache_rx.queue = xQueueCreate(port->cache_rx.queue_length, sizeof(uint8_t));
vSemaphoreCreateBinary(port->sem);
xSemaphoreTake(port->sem, 0);
RCC_APB1PeriphClockCmd(port->peri->periph, ENABLE);
setup_uart_port(&port->peri->tx, &port->peri->rx);
setup_uart_setting(port->peri, port->setting);
/* Enable USART2 Receive and Transmit interrupts */
USART_ITConfig(port->peri->uart, USART_IT_RXNE, ENABLE);
USART_ITConfig(port->peri->uart, USART_IT_TXE, DISABLE);
NVIC_EnableIRQ(port->peri->irq);
/* Enable the USARTx */
USART_Cmd(port->peri->uart, ENABLE);
}
void FreeRTOS_Configuration(void)
{
// Create semaphore
vSemaphoreCreateBinary(dataSemaphore);
// Semaphore not created
while(dataSemaphore == NULL);
xSemaphoreTake(dataSemaphore, 0);
// Task Creations
xTaskCreate(vTaskDetectEmergency, NULL, 100, NULL, (tskIDLE_PRIORITY + 5), NULL);
xTaskCreate(vTaskRefreshSensorData, NULL, 100, NULL, (tskIDLE_PRIORITY + 4), NULL);
xTaskCreate(vTaskCalculateOrientation, NULL, 100, NULL, (tskIDLE_PRIORITY + 3), NULL);
//xTaskCreate(vTaskUpdatePid, NULL, 100, NULL, (tskIDLE_PRIORITY + 2), NULL);
xTaskCreate(vTaskLogDebugInfo, NULL, 100, NULL, (tskIDLE_PRIORITY + 1), NULL);
xTaskCreate(vTaskRLED, NULL, 100, NULL, tskIDLE_PRIORITY, NULL);
xTaskCreate(vTaskGLED, NULL, 100, NULL, tskIDLE_PRIORITY, NULL);
}
void vCDCCommandConsoleStart( uint16_t usStackSize, unsigned portBASE_TYPE uxPriority )
{
/* Create the semaphores and mutexes used by the CDC to task interface. */
xCDCMutex = xSemaphoreCreateMutex();
vSemaphoreCreateBinary( xNewDataSemaphore );
configASSERT( xCDCMutex );
configASSERT( xNewDataSemaphore );
/* Add the semaphore and mutex to the queue registry for viewing in the
kernel aware state viewer. */
vQueueAddToRegistry( xCDCMutex, "CDCMu" );
vQueueAddToRegistry( xNewDataSemaphore, "CDCDat" );
/* Create that task that handles the console itself. */
xTaskCreate( prvCDCCommandConsoleTask, /* The task that implements the command console. */
"CDCCmd", /* Text name assigned to the task. This is just to assist debugging. The kernel does not use this name itself. */
usStackSize, /* The size of the stack allocated to the task. */
NULL, /* The parameter is not used, so NULL is passed. */
uxPriority, /* The priority allocated to the task. */
NULL ); /* A handle is not required, so just pass NULL. */
}
void init_threshold_control(void)
{
xTaskHandle task;
threshold_queue = xQueueCreate(1, sizeof(struct threshold));
if (threshold_queue == NULL)
panic("xQueueCreate failed");
vSemaphoreCreateBinary(threshold_sem);
if (threshold_sem == NULL)
panic("vSemaphoreCreateBinary failed");
xTaskCreate(threshold_control_task, "threshold_control", configMINIMAL_STACK_SIZE,
NULL, tskIDLE_PRIORITY+1, &task);
// initialise ps2 (keyboard) device, register keyboard irq
alt_up_ps2_dev *ps2_device = alt_up_ps2_open_dev(PS2_NAME);
if (ps2_device == NULL)
panic("unable to open ps2 device");
alt_up_ps2_clear_fifo (ps2_device);
alt_irq_register(PS2_IRQ, ps2_device, do_keyboard_irq);
// register the PS/2 interrupt
IOWR_8DIRECT(PS2_BASE,4,1);
}
int main( void )
{
LPC_IOCON->PIO0_7 = 0x30; // configure PIO0_7 as an input with hysteresis
LPC_GPIO0->IS &= ~(1<<7); // edge trigger
LPC_GPIO0->IBE &= ~(1<<7); // control based on IEV register
LPC_GPIO0->IEV &= ~(1<<7); // falling edge
LPC_GPIO0->IE |= (1<<7); // enable interrupt
LPC_GPIO0->DIR |= (1<<6); /* Set up P0.7 as output */
LPC_GPIO0->DATA &= ~(1<<6); /* Turn off LED2 on LPCXpresso board */
init_lcd();
//--------- Lab edit begin ---------
vSemaphoreCreateBinary(ButtonSemaphore);
/* Create one of the three tasks. */
xTaskCreate( vTaskLEDBlinker1, /* Pointer to the function that implements the task. */
(const signed portCHAR *)"Blinker 1", /* Text name for the task. This is to facilitate debugging only. */
configMINIMAL_STACK_SIZE, /* Stack depth in words. */
NULL, /* We are not using the task parameter. */
3, /* This task will run at priority 3. */
NULL ); /* We are not using the task handle. */
/* Create the other tasks in exactly the same way. */
xTaskCreate( vTaskDebuggerHeartbeat, (const signed portCHAR *)"Heartbeat", configMINIMAL_STACK_SIZE, NULL, 3, NULL);
xTaskCreate( vTaskLcdDisplay, (const signed portCHAR *)"Display", configMINIMAL_STACK_SIZE, NULL, 3, NULL);
NVIC_SetPriority( EINT0_IRQn, 0);
NVIC_EnableIRQ( EINT0_IRQn );
/* Start the scheduler so our tasks start executing. */
vTaskStartScheduler();
/* If all is well we will never reach here as the scheduler will now be
running. If we do reach here then it is likely that there was insufficient
heap available for the idle task to be created. */
for( ;; );
return 0;
}
//===============================================================================================
//*----------------------------------------------------------------------------
//* \fn AT91F_TWI_Open
//* \brief Initializes TWI device
//*----------------------------------------------------------------------------
void AT91F_TWI_Init(void)
{
TWI_QUEUE = xQueueCreate( 1, sizeof( unsigned int ) );
TWI_NACK_Error = ErrorCreate("TWI Nack");
TWI_TMO_Error = ErrorCreate("TWI TimeOut");
TWI_SEM_Error = ErrorCreate("TWI Access");
TWI_WriteData_Error = ErrorCreate("TWI Write");
TWI_OVRE_Error = ErrorCreate("TWI OVRE");
vSemaphoreCreateBinary( TWI_Semaphore );
while( TWI_QUEUE == 0 ) ; // Queue was not created and must not be used.
portENTER_CRITICAL();
{
// Configure TWI in master mode
AT91F_TWI_Configure (AT91C_BASE_TWI);
// Configure TWI PIOs
AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, AT91C_PA1_TWCK );
AT91F_PIO_CfgOpendrain(AT91C_BASE_PIOA, // PIO controller base address
((unsigned int) AT91C_PA1_TWCK ) |
((unsigned int) AT91C_PA0_TWD ) );
AT91F_TWI_CfgPIO();
// Configure PMC by enabling TWI clock
AT91F_TWI_CfgPMC ();
// AT91F_PMC_EnablePeriphClock ( AT91C_BASE_PMC, 1<<AT91C_ID_TWI ) ;
// Set TWI Clock Waveform Generator Register
AT91F_SetTwiClock();
AT91F_AIC_ConfigureIt ( AT91C_BASE_AIC,
AT91C_ID_TWI,
TWI_INTERRUPT_LEVEL,
AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE,
( void (*)( void ) )AT91_TWI_ISR_ENTRY);
AT91F_AIC_EnableIt (AT91C_BASE_AIC, AT91C_ID_TWI);
TWI_TransferStatus = FREE;
}
portEXIT_CRITICAL();
}
TaskToken ActivateTask(TaskID enTaskID,
portCHAR *pcTaskName,
TASK_TYPE enTaskType,
unsigned portBASE_TYPE uxPriority,
unsigned portSHORT usStackSize,
pdTASK_CODE pvTaskFunction)
{
TaskToken taskToken = NULL;
//catch NO task name input
if (pcTaskName == NULL) return NULL;
taskENTER_CRITICAL();
{
//detect task already exist
if (TaskTokens[enTaskID].pcTaskName == NULL)
{
//create task
xTaskCreate(pvTaskFunction, (signed portCHAR *)pcTaskName, usStackSize, NULL, uxPriority, &TaskHandles[enTaskID]);
//store task profile in array
TaskTokens[enTaskID].pcTaskName = pcTaskName;
TaskTokens[enTaskID].enTaskType = enTaskType;
TaskTokens[enTaskID].enTaskID = enTaskID;
//create semaphore for task
vSemaphoreCreateBinary(TaskSemphrs[enTaskID]);
//exhaust task semaphore
xSemaphoreTake(TaskSemphrs[enTaskID], NO_BLOCK);
taskToken = &TaskTokens[enTaskID];
}
}
taskEXIT_CRITICAL();
//return pointer to task profile
return taskToken;
}
int ff_cre_syncobj ( /* !=0:Function succeeded, ==0:Could not create due to any error */
BYTE vol, /* Corresponding logical drive being processed */
_SYNC_t *sobj /* Pointer to return the created sync object */
)
{
int ret;
//
// *sobj = CreateMutex(NULL, FALSE, NULL); /* Win32 */
// ret = (int)(*sobj != INVALID_HANDLE_VALUE);
// *sobj = SyncObjects[vol]; /* uITRON (give a static created sync object) */
// ret = 1; /* The initial value of the semaphore must be 1. */
// *sobj = OSMutexCreate(0, &err); /* uC/OS-II */
// ret = (int)(err == OS_NO_ERR);
vSemaphoreCreateBinary( (*sobj) ); /* FreeRTOS */
ret = (int)(*sobj != NULL);
return ret;
}
int main(void) {
prvSetupHardware();
vSemaphoreCreateBinary(sem);
xSemaphoreTake(sem, portMAX_DELAY);
xTaskCreate(task_pwm, (signed char * ) "task_pwm", configMINIMAL_STACK_SIZE,
NULL, (tskIDLE_PRIORITY + 1UL), (xTaskHandle *) NULL);
xTaskCreate(task_pwm_alt, (signed char * ) "task_pwm_alt",
configMINIMAL_STACK_SIZE, NULL, (tskIDLE_PRIORITY + 1UL),
(xTaskHandle *) NULL);
xTaskCreate(task_control, (signed char * ) "task_control",
configMINIMAL_STACK_SIZE, NULL, (tskIDLE_PRIORITY + 1UL),
(xTaskHandle *) NULL);
vTaskStartScheduler();
return 1;
}
void phy_init(xSemaphoreHandle spi_m, phy_rx_callback_t callback,
uint8_t channel, enum phy_tx_power power) {
// Store the SPI mutex
spi_mutex = spi_m;
// Store the callback
rx_cb = callback;
// Store the channel
radio_channel = channel;
// Store the TX power
switch (power) {
case PHY_TX_0dBm:
radio_power = CC1101_868MHz_TX_0dBm;
break;
case PHY_TX_m5dBm:
radio_power = CC1101_868MHz_TX_m6dBm; // No exact match so using the nearest
break;
case PHY_TX_m10dBm:
radio_power = CC1101_868MHz_TX_m10dBm;
break;
case PHY_TX_m20dBm:
radio_power = CC1101_868MHz_TX_m20dBm;
break;
default:
radio_power = CC1101_868MHz_TX_0dBm;
break;
}
// Initialize the semaphore
vSemaphoreCreateBinary(rx_sem);
// Set initial state
state = IDLE;
// Create the task
xTaskCreate(cc1101_task, (const signed char*) "phy_cc1101", configMINIMAL_STACK_SIZE, NULL, configMAX_PRIORITIES-1, NULL);
}
/** Create a new semaphore
* @param sem pointer to the semaphore to create
* @param count initial count of the semaphore
* @return ERR_OK if successful, another err_t otherwise */
err_t sys_sem_new(sys_sem_t *sem, u8_t count)
{
err_t ercd = ERR_MEM;
vSemaphoreCreateBinary((*sem));
if (sys_sem_valid(sem)) {
if (count == 0) {
if (xSemaphoreTake(*sem, 1) == pdPASS) {
ercd = ERR_OK;
SYS_STATS_INC_USED(sem);
}
} else {
ercd = ERR_OK;
SYS_STATS_INC_USED(sem);
}
} else {
SYS_STATS_INC(sem.err);
}
return ercd;
}
/**
* \brief Initialize the GMAC driver.
*
* \param p_gmac Pointer to the GMAC instance.
* \param p_gmac_dev Pointer to the GMAC device instance.
* \param p_opt GMAC configure options.
*/
void gmac_dev_init(Gmac* p_gmac, gmac_device_t* p_gmac_dev,
gmac_options_t* p_opt)
{
/* Disable TX & RX and more */
gmac_network_control(p_gmac, 0);
gmac_disable_interrupt(p_gmac, ~0u);
gmac_clear_statistics(p_gmac);
/* Clear all status bits in the receive status register. */
gmac_clear_rx_status(p_gmac, GMAC_RSR_RXOVR | GMAC_RSR_REC | GMAC_RSR_BNA
| GMAC_RSR_HNO);
/* Clear all status bits in the transmit status register */
gmac_clear_tx_status(p_gmac, GMAC_TSR_UBR | GMAC_TSR_COL | GMAC_TSR_RLE
| GMAC_TSR_TXGO | GMAC_TSR_TFC | GMAC_TSR_TXCOMP | GMAC_TSR_HRESP );
/* Enable the copy of data into the buffers
ignore broadcasts, and not copy FCS. */
gmac_set_config(p_gmac, gmac_get_config(p_gmac) |
GMAC_NCFGR_FD | GMAC_NCFGR_DBW(0) | GMAC_NCFGR_MAXFS |
GMAC_NCFGR_RFCS | GMAC_NCFGR_PEN);
gmac_enable_copy_all(p_gmac, p_opt->uc_copy_all_frame);
gmac_disable_broadcast(p_gmac, p_opt->uc_no_boardcast);
gmac_init_queue(p_gmac, p_gmac_dev);
gmac_set_address(p_gmac, 0, p_opt->uc_mac_addr);
#ifdef FREERTOS_USED
/* Asynchronous operation requires a notification semaphore. First,
* create the semaphore. */
vSemaphoreCreateBinary(netif_notification_semaphore);
vQueueAddToRegistry(netif_notification_semaphore, "GMAC Sem");
/* Then set the semaphore into the correct initial state. */
xSemaphoreTake(netif_notification_semaphore, 0);
#endif
}
// Creates and returns a new semaphore. The "count" argument specifies
// the initial state of the semaphore. TBD finish and test
sys_sem_t
sys_sem_new(u8_t count)
{
xSemaphoreHandle xSemaphore;
portENTER_CRITICAL();
vSemaphoreCreateBinary( xSemaphore );
if(count == 0) // Means it can't be taken
{
xSemaphoreTake(xSemaphore,1);
}
portEXIT_CRITICAL();
if( xSemaphore == NULL )
{
return NULL; // TBD need assert
}
else
{
return xSemaphore;
}
}
int main( void )
{
trace_printf("--------\n");
trace_printf("FreeRTOS\n");
trace_printf("--------\n");
MboxQueue = xQueueCreate( 32, sizeof( unsigned int* ) );
vSemaphoreCreateBinary(InitDoneSemaphore);
xSemaphoreTake(InitDoneSemaphore, portMAX_DELAY);
xTaskCreate(IpcTask, "IpcTask", 100, NULL, 2, NULL);
xTaskCreate(RdaemonTask, "RdaemonTask", 100, NULL, 2, NULL);
/* Start the scheduler. */
vTaskStartScheduler();
while(1);
return 0;
}
int main(void)
{
SystemInit(); /* Initialize the controller */
UART_Init(38400); /* Initialize the Uart module */
LPC_GPIO2->FIODIR = 0xffffffffu;
vSemaphoreCreateBinary(Sem_A); /* Create binary semaphore */
if(Sem_A != NULL)
{
UART_Printf("\n\r\n\nSemaphore successfully created, Creating low priority task");
xTaskCreate( My_LPT, ( signed char * )"LowTask", configMINIMAL_STACK_SIZE, NULL, 1, &LPT_Handle );
vTaskStartScheduler();
}
else
UART_Printf("\n\rFailed to create Semaphore");
while(1);
return 0;
}
int i2c_init() {
volatile AT91PS_TWI pTWI = AT91C_BASE_TWI;
pTWI->TWI_CR = AT91C_TWI_SWRST;
pTWI->TWI_CR &= ~(AT91C_TWI_SWRST);
uint32_t s;
s = pTWI->TWI_SR;
TRACE_I2C("TWI_SR %x\r\n", s);
s = pTWI->TWI_SR;
TRACE_I2C("TWI_SR %x\r\n", s);
pTWI->TWI_CWGR = 0x048585; //I2C clk cca 9kHz
//i2c_mutex = xSemaphoreCreateMutex();
i2c_mutex = MUTEX_CREATE();
if(i2c_mutex == NULL) {
panic("i2c_init");
}
#if I2C_IRQ
vSemaphoreCreateBinary(i2c_semaphore);
xSemaphoreTake(i2c_semaphore, -1);
// Initialize the interrupts
pTWI->TWI_IDR = 0xffffffff;
unsigned int mask = 0x1 << AT91C_ID_TWI;
// Disable the interrupt controller & register our interrupt handler
AT91C_BASE_AIC->AIC_IDCR = mask ;
AT91C_BASE_AIC->AIC_SVR[ AT91C_ID_TWI ] = (unsigned int)i2c_Isr_Wrapper;
AT91C_BASE_AIC->AIC_SMR[ AT91C_ID_TWI ] = AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL | IRQ_I2C_PRI;
AT91C_BASE_AIC->AIC_ICCR = mask;
AT91C_BASE_AIC->AIC_IECR = mask;
#endif
return 0;
}
void prvDataReceiveTask( void *pvParameters )
{
uint8_t m,n;
pvParameters = pvParameters;
PumpsInit();
vSemaphoreCreateBinary( xSerialSemaphore );
if(xSerialSemaphore == 0)
{
while(1);
}
for(n=0;n<8;n++)
NewSpeed[n] = 0;
PumpsSetSpeed(1, NewSpeed[0]);
for(;;)
{
if( xSemaphoreTake( xSerialSemaphore, portMAX_DELAY ) == pdTRUE )
{
if (InLength == 16)
{
for (n = 0; n < 8; n++)
{
m = (InBuff+3) & 0x3;
NewSpeed[n] = InputPayload[m][2 * n];
NewSpeed[n] += (((uint16_t) (InputPayload[m][2* n + 1])) << 8);
}
PumpsSetSpeed(1, NewSpeed[0]);
PumpsSetSpeed(2, NewSpeed[1]);
PumpsSetSpeed(3, NewSpeed[2]);
PumpsSetSpeed(4, NewSpeed[3]);
PumpsSetSpeed(5, NewSpeed[4]);
PumpsSetSpeed(6, NewSpeed[5]);
PumpsSetSpeed(7, NewSpeed[6]);
PumpsSetSpeed(8, NewSpeed[7]);
GPIOToggle(LED_PORT,LED_RED_BIT);
}
}
}
}