int main() {
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_print_auto_init(1);
RT_TASK low, med, high, sync;
rt_task_create(&low, "low", 0, 10, T_CPU(1)|T_JOINABLE);
rt_task_create(&med, "med", 0, 20, T_CPU(1)|T_JOINABLE);
rt_task_create(&high, "high", 0, 30, T_CPU(1)|T_JOINABLE);
rt_task_create(&sync, "sync", 0, 99, T_CPU(1)|T_JOINABLE);
rt_sem_create(&sem, "sem", 0, S_PRIO);
rt_sem_create(&resourceSem, "resourceSem", 1, S_PRIO);
rt_mutex_create(&resourceMutex, "resourceMutex");
rt_task_start(&low, &lowFunc, NULL);
rt_task_start(&med, &medFunc, NULL);
rt_task_start(&high, &highFunc, NULL);
rt_task_start(&sync, &syncFunc, NULL);
rt_task_join(&low);
rt_task_join(&med);
rt_task_join(&high);
rt_task_join(&sync);
rt_sem_delete(&sem);
rt_sem_delete(&resourceSem);
rt_mutex_delete(&resourceMutex);
return 0;
}
int main(){
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_print_auto_init(1);
rt_sem_create(&semaphore, "sem", 1, S_PRIO);
rt_sem_create(&synca, "sync", 0, S_PRIO);
rt_mutex_create(&mutex, "mutex");
RT_TASK L, M, H;
rt_task_shadow(NULL, "main", 4, T_CPU(1)|T_JOINABLE);
rt_task_create(&L, "low", 0, 1, T_CPU(1)|T_JOINABLE);
rt_task_create(&M, "medium", 0, 2, T_CPU(1)|T_JOINABLE);
rt_task_create(&H, "high", 0, 3, T_CPU(1)|T_JOINABLE);
rt_task_start(&L, &low, (void*) 0);
rt_task_start(&M, &medium, (void*) 0);
rt_task_start(&H, &high, (void*) 0);
usleep(100000);
rt_printf("RELEASING SYNC\n");
rt_sem_broadcast(&synca);
rt_task_join(&L);
rt_task_join(&M);
rt_task_join(&H);
rt_sem_delete(&synca);
rt_sem_delete(&semaphore);
rt_mutex_delete(&mutex);
return 0;
}
/* telnet server */
void telnet_srv()
{
rt_thread_t tid;
if (telnet == RT_NULL)
{
rt_uint8_t *ptr;
telnet = rt_malloc (sizeof(struct telnet_session));
if (telnet == RT_NULL)
{
rt_kprintf("telnet: no memory\n");
return;
}
/* init ringbuffer */
ptr = rt_malloc (TELNET_RX_BUFFER);
rb_init(&telnet->rx_ringbuffer, ptr, TELNET_RX_BUFFER);
/* create rx ringbuffer lock */
telnet->rx_ringbuffer_lock = rt_sem_create("rxrb", 1, RT_IPC_FLAG_FIFO);
ptr = rt_malloc (TELNET_TX_BUFFER);
rb_init(&telnet->tx_ringbuffer, ptr, TELNET_TX_BUFFER);
/* create tx ringbuffer lock */
telnet->tx_ringbuffer_lock = rt_sem_create("txrb", 1, RT_IPC_FLAG_FIFO);
/* create network event */
telnet->nw_event = rt_event_create("telnet", RT_IPC_FLAG_FIFO);
}
tid = rt_thread_create("telnet", telnet_thread, RT_NULL,
2048, 25, 5);
if (tid != RT_NULL)
rt_thread_startup(tid);
}
void net_buf_init(rt_size_t size)
{
rt_thread_t tid;
/* init net buffer structure */
_netbuf.read_index = _netbuf.save_index = 0;
_netbuf.size = size; /* net buffer size */
/* allocate buffer */
_netbuf.buffer_data = rt_malloc(_netbuf.size);
_netbuf.data_length = 0;
/* set ready and resume water mater */
_netbuf.ready_wm = _netbuf.size * 90/100;
_netbuf.resume_wm = _netbuf.size * 80/100;
/* set init stat */
_netbuf.stat = NETBUF_STAT_STOPPED;
rt_kprintf("stat -> stopped\n");
_netbuf.wait_ready = rt_sem_create("nready", 0, RT_IPC_FLAG_FIFO);
_netbuf.wait_resume = rt_sem_create("nresum", 0, RT_IPC_FLAG_FIFO);
_netbuf.is_wait_ready = RT_FALSE;
/* crate message queue */
_netbuf_mq = rt_mq_create("njob", sizeof(struct net_buffer_job),
4, RT_IPC_FLAG_FIFO);
/* create net buffer thread */
tid = rt_thread_create("nbuf",
net_buf_thread_entry, RT_NULL,
1024, 22, 5);
if (tid != RT_NULL)
rt_thread_startup(tid);
}
int main (int argc, char * argv[]){
rt_print_auto_init(1);
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_sem_create(&semGlobal1,"semaphore1",1,S_FIFO);
rt_sem_create(&semGlobal2,"semaphore2",0,S_FIFO);
rt_task_create(&t1,"taskOne",0,10,0);
rt_task_create(&t2,"taskTwo",0,10,0);
rt_task_start(&t1,&taskOne,NULL);
rt_task_start(&t2,&taskTwo,NULL);
//rt_printf("end program by CTRL-C\n");
//pause();
}
int main(int argc, char* argv[])
{
// Perform auto-init of rt_print buffers if the task doesn't do so
rt_print_auto_init(1);
// Lock memory : avoid memory swapping for this program
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_printf("starting tasks\n");
int res = rt_sem_create(&semGlobal, "a", 0, S_PRIO);
if(res < 0) rt_printf("Failed to create semaphore; error: %d: %s", res, strerror(-res));
rt_task_create(&task1, "t1", 0, 10, 0);
rt_task_create(&task2, "t2", 0, 20, 0);
rt_task_create(&task3, "t3", 0, 30, 0);
rt_task_create(&task4, "t4", 0, 40, 0);
rt_task_create(&task5, "t5", 0, 50, 0);
int a1 = 1;
int a2 = 2;
int a3 = 3;
int a4 = 4;
int a5 = 5;
rt_task_start(&task1, &task, &a1);
rt_task_start(&task2, &task, &a2);
rt_task_start(&task3, &task, &a3);
rt_task_start(&task4, &task, &a4);
rt_task_start(&task5, &task, &a5);
rt_sem_broadcast(&semGlobal);
}
int semaphore_buffer_worker_init()
{
/* 初始化ring buffer */
rb_init(&working_rb, working_buffer, BUFFER_SIZE);
/* 创建信号量 */
sem = rt_sem_create("sem", 1, RT_IPC_FLAG_FIFO);
if (sem == RT_NULL) {
tc_stat(TC_STAT_END | TC_STAT_FAILED);
return 0;
}
/* 创建线程1 */
tid = rt_thread_create("thread",
thread_entry, RT_NULL, /* 线程入口是thread_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
if (tid != RT_NULL)
rt_thread_startup(tid);
else
tc_stat(TC_STAT_END | TC_STAT_FAILED);
/* 创建线程2 */
worker = rt_thread_create("worker",
worker_entry, RT_NULL, /* 线程入口是worker_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
if (worker != RT_NULL)
rt_thread_startup(worker);
else
tc_stat(TC_STAT_END | TC_STAT_FAILED);
return 0;
}
void startup(){
stepInitializzator();
rt_sem_create(&readDone, "readSem", 0, S_PRIO);
rt_sem_create(&executionDone, "executionSem", 0, S_PRIO);
rt_sem_create(&writeDone, "writeSem", 0, S_PRIO);
rt_task_create(&task, "readerTask", 0, 99, 0);
rt_task_start(&task, &reader, NULL);
rt_task_create(&task, "executorTask", 0, 98, 0);
rt_task_start(&task, &executor, NULL);
rt_task_create(&task, "writerTask", 0, 97, 0);
rt_task_start(&task, &writer, NULL);
}
int main(int argc, char *const argv[])
{
int ret;
traceobj_init(&trobj, argv[0], 0);
ret = rt_sem_create(&sem, "SEMA", 0, S_FIFO);
traceobj_check(&trobj, ret, 0);
ret = rt_task_create(&t_rr1, "rr_task_1", 0, 10, 0);
traceobj_check(&trobj, ret, 0);
ret = rt_task_start(&t_rr1, rr_task, "t1");
traceobj_check(&trobj, ret, 0);
ret = rt_task_create(&t_rr2, "rr_task_2", 0, 10, 0);
traceobj_check(&trobj, ret, 0);
ret = rt_task_start(&t_rr2, rr_task, "t2");
traceobj_check(&trobj, ret, 0);
ret = rt_sem_broadcast(&sem);
traceobj_check(&trobj, ret, 0);
traceobj_join(&trobj);
exit(0);
}
int demo_init(void)
{
sem = rt_sem_create("sem", 1, RT_IPC_FLAG_PRIO);
if (sem == RT_NULL)
{
return 0;
}
t1_count = t2_count = 0;
t1 = rt_thread_create("t1",
thread1_entry, RT_NULL,
512, 7, 10);
if (t1 != RT_NULL)
rt_thread_startup(t1);
t2 = rt_thread_create("t2",
thread2_entry, RT_NULL,
512, 5, 10);
if (t2 != RT_NULL)
rt_thread_startup(t2);
worker = rt_thread_create("worker",
worker_thread_entry, RT_NULL,
512, 6, 10);
if (worker != RT_NULL)
rt_thread_startup(worker);
return 0;
}
//startup code
void startup(){
int err = 0;
// semaphore to sync task startup on
err = rt_sem_create(&mysync,"MySemaphore",1,S_FIFO);
if(err < 0) rt_printf("Failed to create semaphore; error: %d: %s", err, strerror(-err));
err = 0;
// set timing to ns
rt_timer_set_mode(BASEPERIOD);
err = rt_task_create(&highP, "high", 0, HIGH, 0);
if(err < 0) rt_printf("Failed to create task high; error: %d: %s", err, strerror(-err));
err = 0;
err = rt_task_start(&highP, &prioHigh, 0);
if(err < 0) rt_printf("Failed to start task high; error: %d: %s", err, strerror(-err));
err = 0;
err = rt_task_create(&midP, "mid", 0, MID, 0);
if(err < 0) rt_printf("Failed to create task medium; error: %d: %s", err, strerror(-err));
err = 0;
err = rt_task_start(&midP, &prioMid, 0);
if(err < 0) rt_printf("Failed to start task medium; error: %d: %s", err, strerror(-err));
err = 0;
err = rt_task_create(&lowP, "low", 0, LOW, 0);
if(err < 0) rt_printf("Failed to create task low; error: %d: %s", err, strerror(-err));
err = 0;
err = rt_task_start(&lowP, &prioLow, 0);
if(err < 0) rt_printf("Failed to start task low; error: %d: %s", err, strerror(-err));
err = 0;
}
//startup code
void startup()
{
int i;
char str[10] ;
// semaphore to sync task startup on
rt_sem_create(&mysync,"MySemaphore",0,S_FIFO);
// set timing to ns
rt_timer_set_mode(BASEPERIOD);
for(i=0; i < NTASKS; i++) {
rt_printf("start task : %d\n",i);
sprintf(str,"task%d",i);
rt_task_create(&demo_task[i], str, 0, 50, 0);
rt_task_start(&demo_task[i], &demo, &i);
}
// assign priorities to tasks
// (or in creation use 50+i)
rt_task_set_priority(&demo_task[0],LOW);
rt_task_set_priority(&demo_task[1],MID);
rt_task_set_priority(&demo_task[2],MID);
rt_printf("wake up all tasks\n");
rt_sem_broadcast(&mysync);
}
int rs485_system_init(void)
{
rt_err_t result;
rt_thread_t init_thread;
rs485_send_mut = rt_mutex_create("rs485mut",RT_IPC_FLAG_FIFO);
rs485_data_init();
uart1_dev_my = (struct _uart_dev_my*)rt_malloc(sizeof(struct _uart_dev_my));
if (uart1_dev_my == RT_NULL)
{
rt_kprintf("no memory for shell\n");
return -1;
}
memset(uart1_dev_my, 0, sizeof(struct _uart_dev_my));
rt_sem_init(&(uart1_dev_my->rx_sem), "rs485rx", 0, 0);
uart1_dev_my->device = RT_NULL;
uart1_rs485_set_device();
uart1_sem = rt_sem_create("uart1_sem",0, RT_IPC_FLAG_FIFO);
init_thread = rt_thread_create("rs485",rt_rs485_thread_entry, RT_NULL,
4092, 8, 21);
if (init_thread != RT_NULL)
rt_thread_startup(init_thread);
return 0;
}
int main(int argc, char* argv[]) {
// Create semaphores
rt_sem_create(&sem_dec, "increment semaphore", 0, S_FIFO);
rt_sem_create(&sem_inc, "decrement semaphore", 1, S_FIFO);
// Create tasks
rt_task_create(&t1, "task1", 0, 1, 0);
rt_task_create(&t2, "task2", 0, 1, 0);
rt_task_start(&t1, &taskOne, 0);
rt_task_start(&t2, &taskTwo, 0);
// Clean up the semaphores
rt_sem_delete(&sem_dec);
rt_sem_delete(&sem_inc);
return 0;
}
int main(){
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_print_auto_init(1);
rt_sem_create(&semA, "A", 1, S_FIFO | S_PRIO);
rt_sem_create(&semB, "B", 1, S_FIFO | S_PRIO);
rt_sem_create(&syncsem, "ss", 0, S_FIFO);
RT_TASK tasks[3];
rt_task_create(tasks, "C", 0, 99, T_CPU(0)|T_JOINABLE);
//rt_task_create(&(tasks[1]), "B", 0, 50, T_CPU(0));
rt_task_create(tasks+2, "D", 0, 33, T_CPU(0));
rt_task_start(&(tasks[0]),&task_H,(void*)'H');
//rt_task_start(&(tasks[1]),&task_M,(void*)'M');
rt_task_start(&(tasks[2]),&task_L,(void*)'L');
rt_task_shadow(NULL, "main", 0, 0);
rt_task_sleep_ms(200);
rt_sem_broadcast(&syncsem);
//rt_task_sleep_ms(2000);
rt_task_join(tasks);
rt_task_join(tasks+2);
rt_sem_delete(&semA);
rt_sem_delete(&semB);
/*
pthread_t disturbance[10];
for (i=0; i<10; i++){
pthread_create(&(disturbance[i]),NULL,&busy_wait,NULL);
}
for (i=0; i<10; i++){
pthread_join(disturbance[i],NULL);
}
*/
return 0;
};
int main(int argc, char **argv)
{
mlockall(MCL_CURRENT|MCL_FUTURE); //lock current mem alloc and future mem alloc main mem
rt_print_auto_init(1); //hvis vi trenger printf
rt_sem_create(&xenomai_semaphore, "Vaarsemafor", SEM_INIT_COUNT, SEM_MODE);
rt_sem_create(&resource_semaphore, "ressursemafor", SEM_RES_INIT_COUNT, SEM_MODE);
rt_mutex_create(&resMut,"Resource control mutex");
rt_task_create(&taskLow, "task L", AUT0_STCK_SIZE, 50, SINGLE_CORE_MODE);
rt_task_create(&taskMed, "task M", AUT0_STCK_SIZE, 75, SINGLE_CORE_MODE);
rt_task_create(&taskHigh, "task H", AUT0_STCK_SIZE, 99, SINGLE_CORE_MODE);
rt_task_shadow (NULL, "main", 99,SINGLE_CORE_MODE);
rt_task_start(&taskLow, &taskL, NULL);
rt_task_start(&taskMed, &taskM, NULL);
rt_task_start(&taskHigh, &taskH, NULL);
rt_printf("Started program\n");
rt_task_sleep(ONE_SEC);
rt_printf("One second passed\n");
rt_sem_broadcast(&xenomai_semaphore);
while(1){
rt_task_sleep(100000);
}
rt_sem_delete(&xenomai_semaphore);
rt_sem_delete(&resource_semaphore);
rt_mutex_delete(&resMut);
return 0;
}
/**
* Init Mutex, Semaphores and Condition variable
*/
void TimerInit(void)
{
int ret = 0;
char taskname[32];
// lock process in to RAM
//mlockall(MCL_CURRENT | MCL_FUTURE);
snprintf(taskname, sizeof(taskname), "S1-%d", current->pid);
rt_sem_create(&CanFestival_mutex, taskname, 1, S_FIFO);
snprintf(taskname, sizeof(taskname), "S2-%d", current->pid);
rt_sem_create(&control_task, taskname, 0, S_FIFO);
snprintf(taskname, sizeof(taskname), "M1-%d", current->pid);
rt_mutex_create(&condition_mutex, taskname);
snprintf(taskname, sizeof(taskname), "C1-%d", current->pid);
rt_cond_create(&timer_set, taskname);
}
/* FM25L256 using SPI2 */
void fm25_spi_cfg()
{
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
/* Enable SPI Periph clock */
RCC_AHB1PeriphClockCmd(FM25_SPI_NSS_GPIO_CLK | FM25_SPI_GPIO_CLK, ENABLE);
RCC_APB1PeriphClockCmd(FM25_SPI_CLK, ENABLE); //enable SPI clock
//Setup GPIO
GPIO_InitStructure.GPIO_Pin = FM25_SPI_SCK | FM25_SPI_MISO | FM25_SPI_MOSI;
/*Connect Pin to AF*/
GPIO_PinAFConfig(FM25_SPI_GPIO, GPIO_PinSource3, GPIO_AF_SPI3);
GPIO_PinAFConfig(FM25_SPI_GPIO, GPIO_PinSource4, GPIO_AF_SPI3);
GPIO_PinAFConfig(FM25_SPI_GPIO, GPIO_PinSource5, GPIO_AF_SPI3);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(FM25_SPI_GPIO, &GPIO_InitStructure);
/* CS pin: PB12 */
GPIO_InitStructure.GPIO_Pin = FM25_SPI_NSS_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_Init(FM25_SPI_NSS_GPIO, &GPIO_InitStructure);
CS_HIGH();
SPI_Cmd(FM25_SPI, DISABLE);
/*------------------------ SPI configuration ------------------------*/
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;//SPI_Direction_1Line_Tx;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;/* 72M/64=1.125M */
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
//SPI_I2S_DeInit(FM25_SPI);
SPI_Init(FM25_SPI, &SPI_InitStructure);
/* Enable SPI_MASTER */
SPI_Cmd(FM25_SPI, ENABLE);
//SPI_CalculateCRC(FM25_SPI, DISABLE);
fram_lock = rt_sem_create("framlock", 1, RT_IPC_FLAG_FIFO);
}
sys_sem_t sys_sem_new(u8_t count)
{
static int counter = 0;
char tname[RT_NAME_MAX];
rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_SEM_NAME, counter);
#if SYS_DEBUG
{
struct rt_thread *thread;
thread = rt_thread_self();
LWIP_DEBUGF(SYS_DEBUG, ("%s, Create sem: %s \n",thread->name, tname));
}
#endif
counter++;
return rt_sem_create(tname, count, RT_IPC_FLAG_FIFO);
}
err_t sys_sem_new(sys_sem_t *sem, u8_t count)
{
static unsigned short counter = 0;
char tname[RT_NAME_MAX];
sys_sem_t tmpsem;
RT_DEBUG_NOT_IN_INTERRUPT;
rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_SEM_NAME, counter);
counter++;
tmpsem = rt_sem_create(tname, count, RT_IPC_FLAG_FIFO);
if( tmpsem == RT_NULL )
return ERR_MEM;
else
{
*sem = tmpsem;
return ERR_OK;
}
}
int main(int argc, char* argv[])
{
char str[10] ;
int i;
rt_print_auto_init(1);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_printf("start task\n");
rt_sem_create(&sem, "sem", 0, S_FIFO);
for (i=0; i<5; i++)
{
sprintf(str, "hello-%d", i);
rt_task_create(&task[i], str, 0, 50+i, 0);
rt_task_start(&task[i], &demo, &i);
}
// rt_sem_v(&sem);
rt_sem_broadcast(&sem);
}
//startup code
void startup()
{
int i;
char str[10] ;
// semaphore to sync task startup on
rt_sem_create(&mysync,"MySemaphore",0,S_FIFO);
// change to period mode because round robin does not work
// in one shot mode
rt_timer_set_mode(BASEPERIOD);// set tick period
for(i=0; i < NTASKS; i++) {
rt_printf("start task : %d\n",i);
sprintf(str,"task%d",i);
if(i<NTASKS-1){rt_task_create(&demo_task[i], str, 0, 50, 0);}
else{rt_task_create(&demo_task[i],str,0,80,0);}
rt_task_start(&demo_task[i], &demo, &i);
}
rt_printf("wake up all tasks\n");
rt_sem_broadcast(&mysync);
}
int main(int argc, char *const argv[])
{
int ret;
traceobj_init(&trobj, argv[0], sizeof(tseq) / sizeof(int));
ret = rt_sem_create(&sem, "SEMA", 0, S_FIFO);
traceobj_check(&trobj, ret, 0);
ret = rt_task_create(&t_test, "test_task", 0, 10, 0);
traceobj_check(&trobj, ret, 0);
traceobj_mark(&trobj, 1);
ret = rt_task_start(&t_test, test_task, NULL);
traceobj_check(&trobj, ret, 0);
traceobj_mark(&trobj, 2);
ret = rt_task_suspend(&t_test);
traceobj_check(&trobj, ret, 0);
traceobj_mark(&trobj, 3);
ret = rt_sem_v(&sem);
traceobj_check(&trobj, ret, 0);
traceobj_mark(&trobj, 4);
ret = rt_task_resume(&t_test);
traceobj_check(&trobj, ret, 0);
traceobj_mark(&trobj, 5);
traceobj_join(&trobj);
traceobj_verify(&trobj, tseq, sizeof(tseq) / sizeof(int));
exit(0);
}
int main() {
mlockall(MCL_CURRENT|MCL_FUTURE);
RT_TASK low, high, sync;
rt_task_create(&low, "low", 0, 0, T_CPU(1)|T_JOINABLE);
rt_task_create(&high, "high", 0, 1, T_CPU(1)|T_JOINABLE);
rt_task_create(&sync, "sync", 0, 99, T_CPU(1)|T_JOINABLE);
rt_sem_create(&sem, "sem", 0, S_PRIO);
rt_task_start(&low, &wait, NULL);
rt_task_start(&high, &wait, NULL);
rt_task_start(&sync, &syncFunc, NULL);
rt_task_join(&low);
rt_task_join(&high);
rt_task_join(&sync);
rt_sem_delete(&sem);
return 0;
}
int main(int argc, char* argv[])
{
char str[10] ;
int i;
// Perform auto-init of rt_print buffers if the task doesn't do so
rt_print_auto_init(1);
// Lock memory : avoid memory swapping for this program
mlockall(MCL_CURRENT|MCL_FUTURE);
/* create semaphore */
rt_sem_create(&semGlobal,"semaphore",0,S_PRIO);
rt_printf("start task\n");
for (i=0; i<5; i++)
{
/*
* Arguments: &task,
* name,
* stack size (0=default),
* priority,
* mode (FPU, start suspended, ...)
*/
sprintf(str,"hello-%d",i);
rt_task_create(&demo_task, str, 0, 50+i, 0);
/*
* Arguments: &task,
* task function,
* function argument
*/
rt_task_start(&demo_task, &demo, &i);
}
rt_sem_broadcast(&semGlobal);
}
void calibration_init()
{
rt_device_t device;
device = rt_device_find("touch");
if (device == RT_NULL)
return; /* no such device */
touch_screen_calibrated = rt_sem_create("tc_cali", 0, RT_IPC_FLAG_FIFO);
if (touch_screen_calibrated == RT_NULL)
return;
calibration_ptr = (struct calibration_session*)rt_malloc(sizeof(struct calibration_session));
rt_memset(calibration_ptr, 0, sizeof(struct calibration_data));
calibration_ptr->device = device;
rt_device_control(calibration_ptr->device, RT_TOUCH_CALIBRATION, (void*)calibration_data_post);
calibration_ptr->tid = rt_thread_create("cali", calibration_entry, RT_NULL,
2048, 20, 5);
if (calibration_ptr->tid != RT_NULL)
rt_thread_startup(calibration_ptr->tid);
}
int main (int argc, char * argv[]){
char str[10];
int periods[3];
int i;
rt_print_auto_init(1);
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_sem_create(&s, "sem", 1, S_PRIO);
rt_printf("[Main]:start task\n");
for(i=0;i<3;i++){
sprintf(str,"Task-%d",i);
periods[i]=i+1;
rt_task_create(&demo_task,str,10,50+i,0);
rt_task_start(&demo_task,&demo,&periods[i]);
}
//sleep(1);
//rt_task_set_periodic(NULL,TM_NOW,5e8);
//while(1){
// rt_sem_broadcast(&s);
// rt_task_wait_period(NULL);
//}
rt_printf("end program by CTRL-C\n");
pause();
}
int main(int argc, char **argv) {
char task_name[TASKS][16];
RT_TASK task[TASKS];
rt_print_auto_init(1);
if(rt_sem_create(&sem, "Semaphore", 0, S_PRIO) != 0) {
exit(-1);
}
mlockall(MCL_CURRENT|MCL_FUTURE);
for(int i = 0; i < TASKS; i++) {
snprintf(task_name[i], 16, "Lab5Task-%d", i);
if (rt_task_create(&task[i], task_name[i], 0, 10 + (i * 2), T_JOINABLE) != 0) {
exit(-1);
}
}
for (int i = 0; i < TASKS; i++) {
rt_printf("Starting task %s\n", task_name[i]);
rt_task_start(&task[i], &task_body, NULL);
}
rt_printf("All tasks started\n");
rt_sem_broadcast(&sem);
for(int i = 0; i < TASKS; i++) {
rt_task_join(&task[i]);
}
rt_printf("All tasks shutted down\n");
rt_sem_delete(&sem);
}
int semaphore_priority_init()
{
sem = rt_sem_create("sem", 0, RT_IPC_FLAG_PRIO);
if (sem == RT_NULL) {
tc_stat(TC_STAT_END | TC_STAT_FAILED);
return 0;
}
t1_count = t2_count = 0;
t1 = rt_thread_create("t1",
thread1_entry, RT_NULL,
THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
if (t1 != RT_NULL)
rt_thread_startup(t1);
else
tc_stat(TC_STAT_END | TC_STAT_FAILED);
t2 = rt_thread_create("t2",
thread2_entry, RT_NULL,
THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
if (t2 != RT_NULL)
rt_thread_startup(t2);
else
tc_stat(TC_STAT_END | TC_STAT_FAILED);
worker = rt_thread_create("worker",
worker_thread_entry, RT_NULL,
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
if (worker != RT_NULL)
rt_thread_startup(worker);
else
tc_stat(TC_STAT_END | TC_STAT_FAILED);
return 0;
}
void display (void *cookie)
{
int err, n = 0;
time_t start;
err = rt_sem_create(&display_sem,"dispsem",0,S_FIFO);
if (err)
{
fprintf(stderr,"latency: cannot create semaphore: %s\n",strerror(-err));
return;
}
time(&start);
if (quiet)
fprintf(stderr, "running quietly for %d seconds\n", test_duration);
for (;;)
{
long minj, gminj, maxj, gmaxj, avgj;
err = rt_sem_p(&display_sem,TM_INFINITE);
if (err)
{
if (err != -EIDRM)
fprintf(stderr,"latency: failed to pend on semaphore, code %d\n",err);
rt_task_delete(NULL);
}
/* convert jitters to nanoseconds. */
minj = rt_timer_tsc2ns(minjitter);
gminj = rt_timer_tsc2ns(gminjitter);
avgj = rt_timer_tsc2ns(avgjitter);
maxj = rt_timer_tsc2ns(maxjitter);
gmaxj = rt_timer_tsc2ns(gmaxjitter);
if (!quiet)
{
if (data_lines && (n++ % data_lines)==0)
{
time_t now, dt;
time(&now);
dt = now - start - WARMUP_TIME;
printf("RTT| %.2ld:%.2ld:%.2ld\n",
dt / 3600,(dt / 60) % 60,dt % 60);
printf("RTH|%12s|%12s|%12s|%8s|%12s|%12s\n",
"-----lat min","-----lat avg","-----lat max","-overrun",
"----lat best","---lat worst");
}
printf("RTD|%12ld|%12ld|%12ld|%8ld|%12ld|%12ld\n",
minj,
avgj,
maxj,
goverrun,
gminj,
gmaxj);
}
}
}
