int main(void)
{
init_led();
init_rs232();
enable_rs232_interrupts();
enable_rs232();
//vTaskCompleteInitialise();
vAppInitialise();
vSemaphoreInitialise();
vParameterInitialise();
vInitialiseEventLists(NUMBEROFEVENTS);
xTaskCreate( vR_Servant, "R-Servant", SERVANT_STACK_SIZE, (void *)&pvParameters[NUMBEROFSERVANT-1],tskIDLE_PRIORITY + 1, &xTaskOfHandle[NUMBEROFSERVANT-1]);
portBASE_TYPE i,j;
for( i = 0; i < NUMBEROFTASK; ++i )
{
xTaskCreate( vSensor, "Sensor", SERVANT_STACK_SIZE, (void *)&pvParameters[i*(xConcurrents + 1)],NUMBEROFTASK - i + 1, &xTaskOfHandle[i*(xConcurrents + 1)]);
for( j = 1; j <= xConcurrents; ++j )
{
/* j is the number of concurrent servants in one task*/
xTaskCreate( vServant, "servant", SERVANT_STACK_SIZE, (void *)&pvParameters[i*(xConcurrents + 1) + j],NUMBEROFTASK - i + 1, &xTaskOfHandle[i*(xConcurrents + 1) + j]);
}
}
/* Start running the task. */
vTaskStartScheduler();
return 0;
}
int main()
{
init_rs232();
enable_rs232_interrupts();
enable_rs232();
fs_init();
fio_init();
register_romfs("romfs", &_sromfs);
pwd_hash=hash_djb2((const uint8_t *)&"",-1); // init pwd to /romfs/
/* 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,
(signed portCHAR *) "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;
}
int main()
{
init_rs232();
enable_rs232_interrupts();
enable_rs232();
fs_init();
fio_init();
register_romfs("romfs", &_sromfs);
/* 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,
(signed portCHAR *) "Command Prompt",
512 /* stack size */, NULL, configMAX_PRIORITIES, NULL);
xTaskCreate(semihost_sysinfo,
(signed portCHAR *) "Semihost Sysinfo",
512 /* stack size */, NULL, tskIDLE_PRIORITY + 2, NULL);
/* Start running the tasks. */
vTaskStartScheduler();
return 0;
}
int main()
{
init_rs232();
enable_rs232_interrupts();
enable_rs232();
fs_init();
fio_init();
register_romfs("romfs", &_sromfs);
/* Create the queue used by the serial task. Messages for write to
* the RS232. */
vSemaphoreCreateBinary(serial_tx_wait_sem);
serial_rx_queue = xQueueCreate(1, sizeof(ch));
/*Create a task handle reference to
http://www.freertos.org/a00128.html */
xTaskHandle xHandle;
xTaskCreate(shell_task,
(signed portCHAR *) "Implement shell",
512 /* stack size */, NULL, tskIDLE_PRIORITY + 2, NULL);
/* Start running the tasks. */
vTaskStartScheduler();
return 0;
}
int main()
{
init_led();
init_button();
enable_button_interrupts();
init_rs232();
enable_rs232_interrupts();
enable_rs232();
/* Create the queue used by the serial task. Messages for write to
* the RS232. */
serial_str_queue = xQueueCreate(10, sizeof(serial_str_msg));
vSemaphoreCreateBinary(serial_tx_wait_sem);
serial_rx_queue = xQueueCreate(1, sizeof(serial_ch_msg));
// queue_str_task1 = queue_str_task2 = serial_readwrite_task > rs232_xmit_msg_task
//
//
//
// queue_str_task1 ->
// queue_str_task2 ->
// -> [serial_str_queue] -> rs232_xmit_msg_task
// isr -> [serial_rx_queue] -> serial_readwrite_task:receive_byte
//
// ---------->
//
// rs232_xmit_msg_task:send_byte -> <serial_tx_wait_sem> -> isr(complete)
//
/* Create tasks to queue a string to be written to the RS232 port. */
xTaskCreate(queue_str_task1,
(signed portCHAR *) "Serial Write 1",
512 /* stack size */, NULL,
tskIDLE_PRIORITY + 10, NULL );
xTaskCreate(queue_str_task2,
(signed portCHAR *) "Serial Write 2",
512 /* stack size */, NULL,
tskIDLE_PRIORITY + 10, NULL);
/* Create a task to write messages from the queue to the RS232 port. */
xTaskCreate(rs232_xmit_msg_task,
(signed portCHAR *) "Serial Xmit Str",
512 /* stack size */, NULL,
tskIDLE_PRIORITY + 2, NULL);
/* Create a task to receive characters from the RS232 port and echo
* them back to the RS232 port. */
xTaskCreate(serial_readwrite_task,
(signed portCHAR *) "Serial Read/Write",
512 /* stack size */, NULL,
tskIDLE_PRIORITY + 10, NULL);
/* Start running the tasks. */
vTaskStartScheduler();
return 0;
}
int main(void)
{
init_led();
init_button();
enable_button_interrupts();
init_rs232();
enable_rs232_interrupts();
enable_rs232();
/* Create the queue to hold messages to be written to the RS232. */
serial_str_queue = xQueueCreate( 10, sizeof( serial_str_msg ) );
vSemaphoreCreateBinary(serial_tx_wait_sem);
serial_rx_queue = xQueueCreate( 1, sizeof( serial_ch_msg ) );
/* Create a task to flash the LED. */
xTaskCreate( led_flash_task, ( signed portCHAR * ) "LED Flash", 512 /* stack size */, NULL, tskIDLE_PRIORITY + 5, NULL );
/* Create tasks to queue a string to be written to the RS232 port. */
xTaskCreate( queue_str_task1, ( signed portCHAR * ) "Serial Write 1", 512 /* stack size */, NULL, tskIDLE_PRIORITY + 10, NULL );
xTaskCreate( queue_str_task2, ( signed portCHAR * ) "Serial Write 2", 512 /* stack size */, NULL, tskIDLE_PRIORITY + 10, NULL );
/* Create a task to write messages from the queue to the RS232 port. */
xTaskCreate(rs232_xmit_msg_task, ( signed portCHAR * ) "Serial Xmit Str", 512 /* stack size */, NULL, tskIDLE_PRIORITY + 2, NULL );
/* Create a task to receive characters from the RS232 port and echo them back to the RS232 port. */
xTaskCreate(serial_readwrite_task, ( signed portCHAR * ) "Serial Read/Write", 512 /* stack size */, NULL, tskIDLE_PRIORITY + 10, NULL );
/* Start running the tasks. */
vTaskStartScheduler();
return 0;
}
int main()
{
//uint8_t testint=12;
init_rs232();
enable_rs232_interrupts();
enable_rs232();
fs_init();
fio_init();
register_romfs("romfs", &_sromfs);
/* 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));
/* Test zone */
// testint = fs_open("romfs/test.txt", 0, O_RDONLY); /*fs_open is working if we input correct name
// fio_printf(1, "\rWelcome to FreeRTOS Shell %d \r\n",testint);
// fio_printf(1, "\rWelcome to FreeRTOS Shell\r\n");
/* Create a task to output text read from romfs. */
xTaskCreate(command_prompt,
(signed portCHAR *) "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;
}
int main()
{
init_rs232();
enable_rs232_interrupts();
enable_rs232();
fs_init();
fio_init();
register_romfs("romfs", &_sromfs);
/* Create the queue used by the serial task. Messages for write to
* the RS232. */
vSemaphoreCreateBinary(serial_tx_wait_sem);
serial_rx_queue = xQueueCreate(1, sizeof(serial_ch_msg));
#ifdef UNIT_TEST
xTaskCreate(unit_test_task,
(signed portCHAR *) "Unit Test",
256, // stack size
NULL,
tskIDLE_PRIORITY + 2,
NULL);
#endif
xTaskCreate(shell_task,
(signed portCHAR*) "Shell",
512, /* Stack Size*/
NULL,
tskIDLE_PRIORITY + 1,
NULL);
/* Start running the tasks. */
vTaskStartScheduler();
return 0;
}
int main()
{
init_rs232();
enable_rs232_interrupts();
enable_rs232();
fs_init();
fio_init();
/* Create the queue used by the serial task. Messages for write to
* the RS232. */
serial_rx_queue = xQueueCreate( 1, sizeof(char) );
vSemaphoreCreateBinary(serial_tx_wait_sem);
/* Create a task that run the sell environment. */
xTaskCreate( shellEnv, (signed portCHAR *)"Shell",
512, NULL, tskIDLE_PRIORITY + 5, NULL );
/* Start running the tasks. */
vTaskStartScheduler();
return 0;
}
static void init_spi(void)
{
#if defined(WL_SPI)
int i;
#endif
#if defined(AT45DBX_SPI)
static const gpio_map_t AT45DBX_SPI_GPIO_MAP = {
{ AT45DBX_SPI_SCK_PIN, AT45DBX_SPI_SCK_FUNCTION },
{ AT45DBX_SPI_MISO_PIN, AT45DBX_SPI_MISO_FUNCTION },
{ AT45DBX_SPI_MOSI_PIN, AT45DBX_SPI_MOSI_FUNCTION },
{ AT45DBX_SPI_NPCS2_PIN, AT45DBX_SPI_NPCS2_FUNCTION },
};
#endif
#if defined(WL_SPI)
const gpio_map_t WL_SPI_GPIO_MAP = {
#if defined(WL_SPI_NPCS0)
WL_SPI_NPCS0,
#endif
WL_SPI_NPCS, WL_SPI_MISO, WL_SPI_MOSI, WL_SPI_SCK
};
#endif
#if defined(WL_SPI) || defined(AT45DBX_SPI)
spi_options_t spiOptions = {
.modfdis = 1 /* only param used by spi_initMaster() */
};
#endif
#if defined(AT45DBX_SPI)
gpio_enable_module(AT45DBX_SPI_GPIO_MAP,
sizeof(AT45DBX_SPI_GPIO_MAP) /
sizeof(AT45DBX_SPI_GPIO_MAP[0]));
spi_initMaster(AT45DBX_SPI, &spiOptions);
spi_selectionMode(AT45DBX_SPI, 0, 0, 0);
#endif
#if defined(WL_SPI)
/* same pins might be initialized twice here */
gpio_enable_module(WL_SPI_GPIO_MAP,
sizeof(WL_SPI_GPIO_MAP) /
sizeof(WL_SPI_GPIO_MAP[0]));
for (i = 0; i < sizeof(WL_SPI_GPIO_MAP)/sizeof(WL_SPI_GPIO_MAP[0]); i++)
gpio_enable_pin_pull_up(WL_SPI_GPIO_MAP[i].pin);
/* same SPI controller might be initialized again */
spi_initMaster(&WL_SPI, &spiOptions);
spi_selectionMode(&WL_SPI, 0, 0, 0);
#endif
#if defined(AT45DBX_SPI)
spi_enable(AT45DBX_SPI);
/* put up flash reset pin */
gpio_set_gpio_pin(AT45DBX_CHIP_RESET);
#endif
#if defined(WL_SPI)
spi_enable(&WL_SPI);
#endif
}
static void init_rs232(void)
{
#ifndef NO_SERIAL
#if defined(BOARD_RS232_0)
const gpio_map_t BOARD_RS232_0_GPIO_MAP = {
BOARD_RS232_0_TX,
BOARD_RS232_0_RX,
#if defined(BOARD_RS232_0_RTS) && defined (BOARD_RS232_0_CTS)
BOARD_RS232_0_RTS,
BOARD_RS232_0_CTS
#endif
};
#endif
#if defined(BOARD_RS232_1)
const gpio_map_t BOARD_RS232_1_GPIO_MAP = {
BOARD_RS232_1_TX,
BOARD_RS232_1_RX
#if defined(BOARD_RS232_1_RTS) && defined (BOARD_RS232_1_CTS)
BOARD_RS232_1_RTS,
BOARD_RS232_1_CTS
#endif
};
#endif
#if defined(BOARD_RS232_0)
gpio_enable_module(BOARD_RS232_0_GPIO_MAP,
sizeof(BOARD_RS232_0_GPIO_MAP) /
sizeof(BOARD_RS232_0_GPIO_MAP[0]));
#endif
#if defined(BOARD_RS232_1)
gpio_enable_module(BOARD_RS232_1_GPIO_MAP,
sizeof(BOARD_RS232_1_GPIO_MAP) /
sizeof(BOARD_RS232_1_GPIO_MAP[0]));
#endif
#endif /* NO_SERIAL */
}
static void init_printk(void)
{
#ifndef NO_SERIAL
#if defined(CONFIG_CONSOLE_PORT)
const usart_options_t usart_options = {
.baudrate = 57600,
.charlength = 8,
.paritytype = USART_NO_PARITY,
.stopbits = USART_1_STOPBIT,
.channelmode = USART_NORMAL_CHMODE
};
usart_init_rs232(&CONFIG_CONSOLE_PORT, &usart_options, FPBA_HZ);
#endif
#endif /* NO_SERIAL */
}
void board_init(void)
{
init_exceptions();
init_hmatrix();
init_sys_clocks();
init_interrupts();
init_rs232();
init_printk();
#ifdef WITH_SDRAM
sdramc_init(FHSB_HZ);
#endif
init_spi();
}
int main()
{
unsigned int stacks[TASK_LIMIT][STACK_SIZE];
//struct task_control_block tasks[TASK_LIMIT];
struct pipe_ringbuffer pipes[PIPE_LIMIT];
struct task_control_block *ready_list[PRIORITY_LIMIT + 1]; /* [0 ... 39] */
struct task_control_block *wait_list = NULL;
//size_t task_count = 0;
size_t current_task = 0;
size_t i;
struct task_control_block *task;
int timeup;
unsigned int tick_count = 0;
SysTick_Config(configCPU_CLOCK_HZ / configTICK_RATE_HZ);
init_rs232();
__enable_irq();
tasks[task_count].stack = (void*)init_task(stacks[task_count], &first);
tasks[task_count].pid = 0;
tasks[task_count].priority = PRIORITY_DEFAULT;
task_count++;
/* Initialize all pipes */
for (i = 0; i < PIPE_LIMIT; i++)
pipes[i].start = pipes[i].end = 0;
/* Initialize fifos */
for (i = 0; i <= PATHSERVER_FD; i++)
_mknod(&pipes[i], S_IFIFO);
/* Initialize ready lists */
for (i = 0; i <= PRIORITY_LIMIT; i++)
ready_list[i] = NULL;
while (1) {
tasks[current_task].stack = activate(tasks[current_task].stack);
tasks[current_task].status = TASK_READY;
timeup = 0;
switch (tasks[current_task].stack->r8) {
case 0x1: /* fork */
if (task_count == TASK_LIMIT) {
/* Cannot create a new task, return error */
tasks[current_task].stack->r0 = -1;
}
else {
/* Compute how much of the stack is used */
size_t used = stacks[current_task] + STACK_SIZE
- (unsigned int*)tasks[current_task].stack;
/* New stack is END - used */
tasks[task_count].stack = (void*)(stacks[task_count] + STACK_SIZE - used);
/* Copy only the used part of the stack */
memcpy(tasks[task_count].stack, tasks[current_task].stack,
used * sizeof(unsigned int));
/* Set PID */
tasks[task_count].pid = task_count;
/* Set priority, inherited from forked task */
tasks[task_count].priority = tasks[current_task].priority;
/* Set return values in each process */
tasks[current_task].stack->r0 = task_count;
tasks[task_count].stack->r0 = 0;
tasks[task_count].prev = NULL;
tasks[task_count].next = NULL;
task_push(&ready_list[tasks[task_count].priority], &tasks[task_count]);
/* There is now one more task */
task_count++;
}
break;
case 0x2: /* getpid */
tasks[current_task].stack->r0 = current_task;
break;
case 0x3: /* write */
_write(&tasks[current_task], tasks, task_count, pipes);
break;
case 0x4: /* read */
_read(&tasks[current_task], tasks, task_count, pipes);
break;
case 0x5: /* interrupt_wait */
/* Enable interrupt */
NVIC_EnableIRQ(tasks[current_task].stack->r0);
/* Block task waiting for interrupt to happen */
tasks[current_task].status = TASK_WAIT_INTR;
break;
case 0x6: /* getpriority */
{
int who = tasks[current_task].stack->r0;
if (who > 0 && who < (int)task_count)
tasks[current_task].stack->r0 = tasks[who].priority;
else if (who == 0)
tasks[current_task].stack->r0 = tasks[current_task].priority;
else
tasks[current_task].stack->r0 = -1;
} break;
case 0x7: /* setpriority */
{
int who = tasks[current_task].stack->r0;
int value = tasks[current_task].stack->r1;
value = (value < 0) ? 0 : ((value > PRIORITY_LIMIT) ? PRIORITY_LIMIT : value);
if (who > 0 && who < (int)task_count)
tasks[who].priority = value;
else if (who == 0)
tasks[current_task].priority = value;
else {
tasks[current_task].stack->r0 = -1;
break;
}
tasks[current_task].stack->r0 = 0;
} break;
case 0x8: /* mknod */
if (tasks[current_task].stack->r0 < PIPE_LIMIT)
tasks[current_task].stack->r0 =
_mknod(&pipes[tasks[current_task].stack->r0],
tasks[current_task].stack->r2);
else
tasks[current_task].stack->r0 = -1;
break;
case 0x9: /* sleep */
if (tasks[current_task].stack->r0 != 0) {
tasks[current_task].stack->r0 += tick_count;
tasks[current_task].status = TASK_WAIT_TIME;
}
break;
default: /* Catch all interrupts */
if ((int)tasks[current_task].stack->r8 < 0) {
unsigned int intr = -tasks[current_task].stack->r8 - 16;
if (intr == SysTick_IRQn) {
/* Never disable timer. We need it for pre-emption */
timeup = 1;
tick_count++;
}
else {
/* Disable interrupt, interrupt_wait re-enables */
NVIC_DisableIRQ(intr);
}
/* Unblock any waiting tasks */
for (i = 0; i < task_count; i++)
if ((tasks[i].status == TASK_WAIT_INTR && tasks[i].stack->r0 == intr) ||
(tasks[i].status == TASK_WAIT_TIME && tasks[i].stack->r0 == tick_count))
tasks[i].status = TASK_READY;
}
}
/* Put waken tasks in ready list */
for (task = wait_list; task != NULL;) {
struct task_control_block *next = task->next;
if (task->status == TASK_READY)
task_push(&ready_list[task->priority], task);
task = next;
}
/* Select next TASK_READY task */
for (i = 0; i < (size_t)tasks[current_task].priority && ready_list[i] == NULL; i++);
if (tasks[current_task].status == TASK_READY) {
if (!timeup && i == (size_t)tasks[current_task].priority)
/* Current task has highest priority and remains execution time */
continue;
else
task_push(&ready_list[tasks[current_task].priority], &tasks[current_task]);
}
else {
task_push(&wait_list, &tasks[current_task]);
}
while (ready_list[i] == NULL)
i++;
current_task = task_pop(&ready_list[i])->pid;
}
return 0;
}
void* external_command_thread(void* para)
{
char *interface=(char*)para;
int fd;
char buf[MAXLEN];
int l,n;
int mode=0;
printf("External IO Thread started, device %s\n",interface);
if (!strncmp(interface, "rs232:",6)) {
fd=init_rs232(interface);
}
else if (!strncmp(interface, "udp:",4)) {
fd=init_udp(interface);
mode=1;
}
else {
// FIXME: udp&Co
fprintf(stderr,"Unsupported interface type %s\n",interface);
return NULL;
}
if (fd<0) {
char err[256];
strerror_r(errno,err,sizeof(err));
fprintf(stderr,"Unable to open interface type %s (%s)\n",interface,err);
return NULL;
}
l=0;
while(1) {
if (!mode) {
// RS232
n=read(fd,buf+l,1);
if (n==1) {
if (buf[l]=='\r' || buf[l]=='\n') {
buf[l]=0;
if (!external_send(buf))
write(fd,"OK\n",3);
else
write(fd,"NAK\n",4);
l=0;
}
else {
if (l==MAXLEN-1)
l=0;
else
l++;
}
}
else
usleep(40*1000);
}
else {
char *p;
n=read(fd,buf,MAXLEN-1);
buf[MAXLEN-1]=0;
// Only first line in packet
p=strchr(buf,'\n');
if (p)
*p=0;
external_send(buf);
}
}
return NULL;
}
int __rtenv_start()
{
int i;
#ifdef TRACE
logfile = host_action(SYS_OPEN, "logqemu", 4);
#endif
init_rs232();
/* Initialize memory pool */
memory_pool_init(&memory_pool, MEM_LIMIT, memory_space);
/* Initialize all files */
for (i = 0; i < FILE_LIMIT; i++)
files[i] = NULL;
/* Initialize ready lists */
for (i = 0; i <= PRIORITY_LIMIT; i++)
list_init(&ready_list[i]);
/* Initialise event monitor */
event_monitor_init(&event_monitor, events, ready_list);
/* Initialize fifos */
for (i = 0; i <= PATHSERVER_FD; i++)
file_mknod(i, -1, files, S_IFIFO, &memory_pool, &event_monitor);
/* Register IRQ events, see INTR_LIMIT */
for (i = -15; i < INTR_LIMIT - 15; i++)
event_monitor_register(&event_monitor, INTR_EVENT(i), intr_release, 0);
/* Register TASK blocked event -> pthread_join, atomic etc. */
for (i = 0; i < TASK_LIMIT; i++) {
int pid = i;
event_monitor_register(&event_monitor, TASK_EVENT(i), task_release, &pid);
}
/* Register MUTEX events */
for (i = 0; i < MUTEX_LIMIT; i++)
event_monitor_register(&event_monitor, MUTEX_EVENT(i), mutex_release, 0);
event_monitor_register(&event_monitor, TIME_EVENT, time_release, &tick_count);
/* Initialize all task threads */
task_create(0, pathserver, NULL);
task_create(0, signal_server, NULL);
task_create(0, romdev_driver, NULL);
task_create(0, romfs_server, NULL);
task_create(0, mount_task, NULL);
task_create(PRIORITY_LIMIT, kernel_thread, NULL);
current_tcb = &tasks[current_task];
__mutex.count = 0;
__mutex.ishead = 1;
SysTick_Config(configCPU_CLOCK_HZ / configTICK_RATE_HZ);
task_start();
/* never execute here */
return 0;
}
