int main(int argc, char* argv[])
{
signal(SIGTERM, catch_signal);
//signal(SIGINT, catch_signal);
int statusA, statusG, statusF, mutexacc, mutexgyro, i,j;
logIndex = 0;
// enable rt_task_print
rt_print_auto_init(1);
/* Avoids memory swapping for this program */
mlockall(MCL_CURRENT|MCL_FUTURE);
// Create mutexs
mutexgyro = rt_mutex_create(&mutex_gyro,NULL);
if(mutexgyro!=0){
fprintf(stderr, "Unable to create gyroscope mutex! Exiting...\n");
exit(EXIT_FAILURE);
}
mutexacc = rt_mutex_create(&mutex_acc,NULL);
if(mutexacc!=0){
fprintf(stderr, "Unable to create accelorometer mutex! Exiting...\n");
exit(EXIT_FAILURE);
}
isRunning = 1;
/*
* Arguments: &task, name, stack size (0=default), priority,
* mode (FPU, start suspended, ...)
*/
statusA = rt_task_create(&accThread, NULL, 0, 0, T_JOINABLE);
statusG = rt_task_create(&gyroThread, NULL, 0, 0, T_JOINABLE);
statusF = rt_task_create(&fusThread, NULL, 0, 0, T_JOINABLE);
/*
* Arguments: &task, task function, function argument
*/
statusA = rt_task_start(&accThread, &accelerometer, NULL);
statusG = rt_task_start(&gyroThread, &gyroscope, NULL);
statusF = rt_task_start(&fusThread, &sensor_fusion, NULL);
// threads in infinite loop, therefore this prevents the main from finishing
// (and killing its threads)
statusA = rt_task_join(&gyroThread);
statusF = rt_task_join(&fusThread);
statusG = rt_task_join(&accThread);
printlog[logIndex] = 4000;
for (i = 0; i < 50; i++) {
printf("Fusion%d: %d\n", i, printlog[i]);
}
rt_mutex_delete(&mutex_acc);
rt_mutex_delete(&mutex_gyro);
}
/* public functions ========================================================= */
int speed_init(void) {
if (running) {
goto err_running;
}
if ((ostream = fopen("speed", "w")) == NULL) {
goto err_ostream;
}
rt_intr_create(&intr, NULL, 81, 0);
rt_intr_enable(&intr);
rt_mutex_create(&mutex_instant, NULL);
rt_mutex_create(&mutex_average, NULL);
rt_queue_create(&queue, "irq81", QUEUE_SIZE, Q_UNLIMITED, Q_FIFO);
rt_task_spawn(&task_soft, NULL, 0, 80, 0, task_soft_routine, NULL);
rt_task_spawn(&task_hard, NULL, 0, 90, 0, task_hard_routine, NULL);
instant = 0;
average = 0;
running = 1;
return 0;
err_ostream:
err_running:
return -1;
}
int main(){
rt_print_auto_init(1);
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_task_shadow(NULL, "main", 5, T_CPU(0)|T_JOINABLE);
#ifdef mutex
rt_mutex_create(&a, "Mutex");
rt_mutex_create(&b, "b");
#endif
rt_task_create(&task1, "Task1", 0, 1, T_CPU(0)|T_JOINABLE);
rt_task_create(&task2, "Task2", 0, 2, T_CPU(0)|T_JOINABLE);
rt_task_start(&task1, &semWait1, NULL);
rt_task_start(&task2, &semWait2, NULL);
rt_printf("sync \n");
rt_task_join(&task1);
rt_task_join(&task2);
#ifdef mutex
rt_mutex_delete(&a);
rt_mutex_delete(&b);
#endif
}
ECRTData::ECRTData() {
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_mutex_create(&(this->mutex), NULL);
rt_mutex_create(&(this->mutexBuffer), NULL);
rt_cond_create(&(this->freeCond), NULL);
rt_task_create(&(this->ecThread), NULL, 0, 99, T_JOINABLE);
rt_task_create(&(this->frThread), NULL, 0, 99, T_JOINABLE);
rt_task_create(&(this->statusThread), NULL, 0, 99, T_JOINABLE);
rt_task_create(&(this->supervisorThread), NULL, 0, 99, T_JOINABLE);
}
/* telnet server */
void telnet_srv(void)
{
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(RX_BUFFER_SIZE);
if (ptr)
{
rt_ringbuffer_init(&telnet->rx_ringbuffer, ptr, RX_BUFFER_SIZE);
}
else
{
rt_kprintf("telnet: no memory\n");
return;
}
ptr = rt_malloc(TX_BUFFER_SIZE);
if (ptr)
{
rt_ringbuffer_init(&telnet->tx_ringbuffer, ptr, TX_BUFFER_SIZE);
}
else
{
rt_kprintf("telnet: no memory\n");
return;
}
/* create tx ringbuffer lock */
telnet->tx_ringbuffer_lock = rt_mutex_create("telnet_tx", RT_IPC_FLAG_FIFO);
/* create rx ringbuffer lock */
telnet->rx_ringbuffer_lock = rt_mutex_create("telnet_rx", RT_IPC_FLAG_FIFO);
tid = rt_thread_create("telnet", telnet_thread, RT_NULL, 2048, 25, 5);
if (tid != RT_NULL)
rt_thread_startup(tid);
}
else
{
rt_kprintf("telnet: already running\n");
}
}
int demo_init(void)
{
mutex = rt_mutex_create("mutex", RT_IPC_FLAG_FIFO);
if (mutex == 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;
}
rt_err_t rt_hw_sdcard_init(const char * spi_device_name)
{
int size;
rt_uint32_t id, total_block;
struct sdcard_device * sd;
struct rt_device * device;
sd = &_sdcard;
device = &(sd->parent);
lock = rt_mutex_create("lock", RT_IPC_FLAG_FIFO);
/* open sd card file, if not exist, then create it */
sd->file = fopen(SDCARD_SIM, "rb+");
if (sd->file == NULL)
{
/* create a file to simulate sd card */
sd->file = fopen(SDCARD_SIM, "wb+");
fseek(sd->file, 0, SEEK_END);
size = ftell(sd->file);
fseek(sd->file, 0, SEEK_SET );
if (size < SDCARD_SIZE)
{
int i;
unsigned char* ptr;
ptr = (unsigned char*) malloc (1024 * 1024);
if (ptr == NULL)
{
SD_TRACE("malloc error, no memory!\n");
return RT_ERROR;
}
memset(ptr, 0x0, 1024 * 1024);
fseek(sd->file, 0, SEEK_SET);
for(i=0; i<(SDCARD_SIZE / (1024*1024)); i++)
fwrite(ptr, 1024 * 1024, 1, sd->file);
free(ptr);
}
}
fseek(sd->file, 0, SEEK_SET);
device->type = RT_Device_Class_Block;
device->init = rt_sdcard_init;
device->open = rt_sdcard_open;
device->close = rt_sdcard_close;
device->read = rt_sdcard_read;
device->write = rt_sdcard_write;
device->control = rt_sdcard_control;
device->user_data = NULL;
rt_device_register(device, "sd0",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
return RT_EOK;
}
Mutex::Mutex(){
// make string of format mut_##
std::string st("mut_");
st += std::to_string(Mutex::mutex_count++);
// create mutex and display messages according to status flag
int status = rt_mutex_create(&mutex, st.c_str());
switch(status){
case 0:
return;
case -ENOMEM:
Debug::output("Mutext::Mutex - the system fails to get enough dynamic memory from the global real-time heap in order to register the mutex.");
break;
case -EEXIST:
Debug::output("Mutext::Mutex - the name is already in use by some registered object.");
break;
case -EPERM:
Debug::output("Mutext::Mutex - this service was called from an asynchronous context.");
break;
default:
Debug::output("Mutext::Mutex - Unknown error");
break;
}
}
static void sdlfb_hw_init(void)
{
/* set video driver for VC++ debug */
//_putenv("SDL_VIDEODRIVER=windib");
//if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_AUDIO) < 0)
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
exit(1);
}
_device.parent.init = sdlfb_init;
_device.parent.open = sdlfb_open;
_device.parent.close = sdlfb_close;
_device.parent.read = RT_NULL;
_device.parent.write = RT_NULL;
_device.parent.control = sdlfb_control;
_device.width = SDL_SCREEN_WIDTH;
_device.height = SDL_SCREEN_HEIGHT;
_device.screen = SDL_SetVideoMode(_device.width, _device.height, 16, SDL_SWSURFACE | SDL_DOUBLEBUF);
if (_device.screen == NULL)
{
fprintf(stderr, "Couldn't set video mode: %s\n", SDL_GetError());
exit(1);
}
SDL_WM_SetCaption("RT-Thread/GUI Simulator", NULL);
rt_device_register(RT_DEVICE(&_device), "sdl", RT_DEVICE_FLAG_RDWR);
sdllock = rt_mutex_create("fb", RT_IPC_FLAG_FIFO);
}
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;
}
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;
}
void logInit(void)
{
int i;
rt_thread_t log_thread;
if(isInit)
return;
logs = &_log_start;
logsLen = &_log_stop - &_log_start;
logsCrc = crcSlow(logs, logsLen);
// Big lock that protects the log datastructures
logLock = rt_mutex_create("log_lock",RT_IPC_FLAG_FIFO);
for (i=0; i<logsLen; i++)
{
if(!(logs[i].type & LOG_GROUP))
logsCount++;
}
//Manually free all log blocks
for(i=0; i<LOG_MAX_BLOCKS; i++)
logBlocks[i].id = BLOCK_ID_FREE;
//Init data structures and set the log subsystem in a known state
logReset();
//Start the log task
//xTaskCreate(logTask, (const signed char * const)"log",
// configMINIMAL_STACK_SIZE, NULL, /*priority*/1, NULL);
log_thread = rt_thread_create("log", logTask, RT_NULL, 512, 10, 5);
isInit = RT_TRUE;
}
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;
}
mutex_impl() :
lockCount(0), leaveWarnSwitchOn(false)
{
int ret = rt_mutex_create(&m, NULL);
if (ret != 0) {
(logMessage("thread::detail::mutex_impl::%s: Could not create RT_MUTEX: (%d) %s")
% __func__ % -ret % strerror(-ret)).raise<std::logic_error>();
}
}
int main(int argc, char* argv[])
{
rt_print_auto_init(1);
signal(SIGTERM, catch_signal);
signal(SIGINT, catch_signal);
mlockall(MCL_CURRENT|MCL_FUTURE);
done=1;
int flag=0;
while (flag<sizeQ){
gyroQ[flag]=rand()%366;
flag++;
}
int err =rt_mutex_create(&a,"MyMutex");//creating mutex
err =rt_mutex_create(&g,NULL);
rt_task_create(&Accelerometer,NULL , 0, 0, T_JOINABLE);
rt_task_create(&gyroscope, NULL, 0, 0, T_JOINABLE);
rt_task_create(&fusion, NULL, 0, 0, T_JOINABLE);
rt_task_start(&gyroscope, &gyro,NULL);
rt_task_start(&Accelerometer, &Acc, NULL);
rt_task_start(&fusion, &fusionT, NULL);
rt_task_join(&gyroscope);
rt_task_join(&Accelerometer);
rt_task_join(&fusion);
rt_task_delete(&gyroscope);
rt_task_delete(&Accelerometer);
rt_task_delete(&fusion);
rt_mutex_delete(&a);
rt_mutex_delete(&g);
flag=0;
while (flag<sizeFinal){//print out result
rt_printf("Result%d: %d\n",flag,finalNum[flag]);
flag++;
}
}
int rt_application_init()
{
rt_thread_t init_thread;
rt_err_t result;
/* 初始化静态互斥量 */
result = rt_mutex_init(&static_mutex, "smutex", RT_IPC_FLAG_FIFO);
if (result != RT_EOK)
{
rt_kprintf("init static mutex failed.\n");
return -1;
}
/* 创建一个动态互斥量 */
dynamic_mutex = rt_mutex_create("dmutex", RT_IPC_FLAG_FIFO);
if (dynamic_mutex == RT_NULL)
{
rt_kprintf("create dynamic mutex failed.\n");
return -1;
}
#if (RT_THREAD_PRIORITY_MAX == 32)
init_thread = rt_thread_create("init",
rt_init_thread_entry, RT_NULL,
2048, 8, 20);
#else
init_thread = rt_thread_create("init",
rt_init_thread_entry, RT_NULL,
2048, 80, 20);
#endif
if (init_thread != RT_NULL)
rt_thread_startup(init_thread);
rt_thread_init(&thread1,
"thread1",
rt_thread_entry1,
RT_NULL,
&thread1_stack[0],
sizeof(thread1_stack),11,5);
rt_thread_startup(&thread1);
rt_thread_init(&thread2,
"thread2",
rt_thread_entry2,
RT_NULL,
&thread2_stack[0],
sizeof(thread2_stack),10,5);
rt_thread_startup(&thread2);
return 0;
}
static rt_err_t rt_dflash_init (rt_device_t dev)
{
FLASH_Init();
SectorSize = FLASH_GetSectorSize();
StartAddr = RT_ALIGN(((uint32_t)&Image$$ER_IROM1$$RO$$Limit + SectorSize), SectorSize);
DiskSize = FLASH_SIZE - StartAddr;
rt_kprintf("dflash sector size:%d 0ffset:0x%X\r\n", SectorSize, StartAddr);
mutex = rt_mutex_create("_mu", RT_IPC_FLAG_FIFO);
return RT_EOK;
}
int ff_cre_syncobj(BYTE drv, _SYNC_t *m)
{
char name[8];
rt_mutex_t mutex;
rt_snprintf(name, sizeof(name), "fat%d", drv);
mutex = rt_mutex_create(name, RT_IPC_FLAG_FIFO);
if (mutex != RT_NULL)
{
*m = mutex;
return RT_TRUE;
}
return RT_FALSE;
}
void rt_hw_lcd1602_init()
{
LCD_init();
LcdMutex = rt_mutex_create( "Lcd", RT_IPC_FLAG_FIFO);
rt_sem_init(&(lcd_writesem), "lcdlock", 0, 0);
LcdUserData.CurCmd = DispEnd;
//lcd1602_FileNameRollStart();
lcd1602_ConectStart();
/* register sdcard device */
lcd1602.type = RT_Device_Class_Char;
lcd1602.init = rt_lcd1602_init;
lcd1602.open = rt_lcd1602_open;
lcd1602.close = rt_lcd1602_close;
lcd1602.read = rt_lcd1602_read;
lcd1602.write = rt_lcd1602_write;
lcd1602.control = rt_lcd1602_control;
/* no private */
lcd1602.user_data = &LcdUserData;
rt_device_register(&lcd1602, "Lcd1602", RT_DEVICE_FLAG_WRONLY);
lcd1602.write(&lcd1602, 0, "TA DownLoader Staring...", 0xff);
/*
if (lcd_thread_filename != RT_NULL)
{
rt_thread_startup(lcd_thread_filename);
//rt_thread_suspend(lcd_thread_filename);
}
*/
//lcd_thread_connect = rt_thread_create("lcdCon", lcd1602_ConnectDispThread, (void *)0, 1024, 7, 20);
/*
if (lcd_thread_connect != RT_NULL)
{
rt_thread_startup(lcd_thread_connect);
rt_thread_suspend(lcd_thread_connect);
}
lcd1602.write(&lcd1602, 0, "TA DownLoader Staring...", 0xff);
*/
}
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);
}
/** Create a new mutex
* @param mutex pointer to the mutex to create
* @return a new mutex */
err_t sys_mutex_new(sys_mutex_t *mutex)
{
static unsigned short counter = 0;
char tname[RT_NAME_MAX];
sys_mutex_t tmpmutex;
RT_DEBUG_NOT_IN_INTERRUPT;
rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_MUTEX_NAME, counter);
counter++;
tmpmutex = rt_mutex_create(tname, RT_IPC_FLAG_FIFO);
if( tmpmutex == RT_NULL )
return ERR_MEM;
else
{
*mutex = tmpmutex;
return ERR_OK;
}
}
//对SPI2进行初始化,主模式
void SPI2_Init(void)
{
SPI_InitTypeDef SPI_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable SPI2 and GPIOA clocks */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2,ENABLE);
/* Configure SPI2 pins: NSS, SCK, MISO and MOSI */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
//SPI2 NSS
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_SetBits(GPIOB, GPIO_Pin_4);
/* SPI2 configuration */
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; //SPI2设置为两线全双工
SPI_InitStructure.SPI_Mode = SPI_Mode_Master; //设置SPI2为主模式
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; //SPI发送接收8位帧结构
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High; //串行时钟在不操作时，时钟为高电平
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge; //第二个时钟沿开始采样数据
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; //NSS信号由软件（使用SSI位）管理
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; //定义波特率预分频的值:波特率预分频值为8
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; //数据传输从MSB位开始
SPI_InitStructure.SPI_CRCPolynomial = 7; //CRC值计算的多项式
SPI_Init(SPI2, &SPI_InitStructure);
/* Enable SPI2 */
SPI_Cmd(SPI2, ENABLE); //使能SPI2外设
spi2lock = rt_mutex_create("spi2Lock", RT_IPC_FLAG_FIFO);
RT_ASSERT(spi2lock != RT_NULL);
}
/* Task start */
int hit_task_start(){
int err;
err = rt_mutex_create(&hit_task_mutex, "task_hit_mutex");
if(err == 0){
hit_task_mutex_created = 1;
printk("rt-app: Task HIT create mutex succeed\n");
}else{
printk("rt-app: Task HIT create mutex failed\n");
goto fail;
}
err = rt_task_create(&hit_task_handle,
"task_hit",
TASK_STKSZ,
TASK_HIT_PRIO,
0);
if (err == 0){
err = rt_task_start(&hit_task_handle, &hit_task, NULL);
hit_task_created = 1;
if(err != 0){
printk("rt-app: Task HIT starting failed\n");
goto fail;
}else{
printk("rt-app: Task HIT starting succeed\n");
}
}else{
printk("rt-app: Task HIT creation failed\n");
goto fail;
}
return 0;
fail:
hit_task_cleanup_task();
hit_task_cleanup_objects();
return -1;
}
void hm_tdc_thread_entry(void* parameter)
{
rt_device_t tdc = RT_NULL;
rt_uint8_t tof_data_count = 0;
rt_uint8_t temp_data_count = 0;
rt_uint8_t loop_count = TOF_DATA_BUF_LEN/TEMP_DATA_BUF_LEN;
tdc = rt_device_find(HM_BOARD_TDC_NAME);
RT_ASSERT(tdc);
rt_device_open(tdc, RT_DEVICE_OFLAG_RDWR);
#if (HM_BOARD_UART_6 == 1)
tt_print_device = rt_device_find(TOF_TEMP_PRINT_DEVICE);
RT_ASSERT(tt_print_device);
rt_device_open(tt_print_device, RT_DEVICE_OFLAG_RDWR);
#endif
tof_lock = rt_mutex_create("L_tof", RT_IPC_FLAG_FIFO);
RT_ASSERT(tof_lock);
temp_lock = rt_mutex_create("L_temp", RT_IPC_FLAG_FIFO);
RT_ASSERT(temp_lock);
while(1) {
loop_count--;
{ /* TOF */
if(rt_mutex_take(tof_lock, rt_tick_from_millisecond(LOCK_TACK_WAIT_TIME_MS)) != RT_EOK) {
rt_kprintf("TOF take lock error\n");
continue;
}
else {
rt_device_control(tdc, SPI_TDC_GP21_CTRL_MEASURE_TOF2, &tof_data[tof_data_count].data);
tof_data[tof_data_count].time = rt_tick_get();
rt_mutex_release(tof_lock);
tof_data_count++;
}
}
if(loop_count == 0) { /* TEMP */
loop_count = TOF_DATA_BUF_LEN/TEMP_DATA_BUF_LEN;
if(rt_mutex_take(temp_lock, rt_tick_from_millisecond(LOCK_TACK_WAIT_TIME_MS)) != RT_EOK) {
rt_kprintf("temprature take lock error\n");
continue;
}
else {
rt_device_control(tdc, SPI_TDC_GP21_CTRL_MEASURE_TEMP, &temp_data[temp_data_count].data);
temp_data[temp_data_count].time = rt_tick_get();
rt_mutex_release(temp_lock);
temp_data_count++;
}
}
if((temp_data_count==TEMP_DATA_BUF_LEN) || (tof_data_count==TOF_DATA_BUF_LEN)) { /* Send event */
temp_data_count = 0;
tof_data_count = 0;
if(rt_event_send(cal_event, TDC_DATA_FULL_EVENT) != RT_EOK) {
rt_kprintf("TDC send event error\n");
}
}
rt_thread_delay(rt_tick_from_millisecond(TDC_SLEEP_TIME_MS));
}
}
/// Create and Initialize a Mutex object
osMutexId osMutexCreate(osMutexDef_t *mutex_def)
{
return rt_mutex_create(mutex_def->name, mutex_def->flag);
}
int main(void)
{
unsigned long long before;
RT_ALARM nalrm;
RT_BUFFER nbuf;
RT_COND ncond;
RT_EVENT nevt;
RT_HEAP nheap;
RT_MUTEX nmtx;
RT_PIPE npipe;
RT_QUEUE nq;
RT_SEM nsem;
RT_TASK ntsk;
int failed = 0;
mlockall(MCL_CURRENT|MCL_FUTURE);
rt_print_auto_init(1);
rt_fprintf(stderr, "Checking for leaks in native skin services\n");
before = get_used();
check_native(rt_alarm_create(&nalrm, NULL));
check_native(rt_alarm_delete(&nalrm));
check_used("alarm", before, failed);
before = get_used();
check_native(rt_buffer_create(&nbuf, NULL, 16384, B_PRIO));
check_native(rt_buffer_delete(&nbuf));
check_used("buffer", before, failed);
before = get_used();
check_native(rt_cond_create(&ncond, NULL));
check_native(rt_cond_delete(&ncond));
check_used("cond", before, failed);
before = get_used();
check_native(rt_event_create(&nevt, NULL, 0, EV_PRIO));
check_native(rt_event_delete(&nevt));
check_used("event", before, failed);
before = get_used();
check_native(rt_heap_create(&nheap, "heap", 16384, H_PRIO | H_SHARED));
check_native(rt_heap_delete(&nheap));
check_used("heap", before, failed);
before = get_used();
check_native(rt_mutex_create(&nmtx, NULL));
check_native(rt_mutex_delete(&nmtx));
check_used("mutex", before, failed);
before = get_used();
check_native(rt_pipe_create(&npipe, NULL, P_MINOR_AUTO, 0));
check_native(rt_pipe_delete(&npipe));
check_used("pipe", before, failed);
before = get_used();
check_native(rt_queue_create(&nq, "queue", 16384, Q_UNLIMITED, Q_PRIO));
check_native(rt_queue_delete(&nq));
check_used("queue", before, failed);
before = get_used();
check_native(rt_sem_create(&nsem, NULL, 0, S_PRIO));
check_native(rt_sem_delete(&nsem));
check_used("sem", before, failed);
before = get_used();
check_native(rt_task_spawn(&ntsk, NULL, 0, 1, T_JOINABLE, empty, NULL));
check_native(rt_task_join(&ntsk));
sleep(1); /* Leave some time for xnheap
* deferred free */
check_used("task", before, failed);
return failed ? EXIT_FAILURE : EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
char tempname[] = "/tmp/sigdebug-XXXXXX";
char buf[BUFSIZ], dev[BUFSIZ];
RT_TASK main_task, rt_task;
long int start, trash, end;
unsigned char *mayday, *p;
struct sigaction sa;
int old_wd_value;
char r, w, x, s;
int tmp_fd, d;
FILE *maps;
int err;
rt_print_auto_init(1);
if (argc < 2 || strcmp(argv[1], "--skip-watchdog") != 0) {
wd = fopen("/sys/module/xeno_nucleus/parameters/"
"watchdog_timeout", "w+");
if (!wd) {
fprintf(stderr, "FAILURE: no watchdog available and "
"--skip-watchdog not specified\n");
exit(EXIT_FAILURE);
}
err = fscanf(wd, "%d", &old_wd_value);
check("get watchdog", err, 1);
err = fprintf(wd, "2");
check("set watchdog", err, 1);
fflush(wd);
}
maps = fopen("/proc/self/maps", "r");
if (maps == NULL) {
perror("open /proc/self/maps");
exit(EXIT_FAILURE);
}
while (fgets(buf, sizeof(buf), maps)) {
if (sscanf(buf, "%lx-%lx %c%c%c%c %lx %x:%x %d%s\n",
&start, &end, &r, &w, &x, &s, &trash,
&d, &d, &d, dev) == 11
&& r == 'r' && x == 'x'
&& !strcmp(dev, "/dev/rtheap") && end - start == 4096) {
printf("mayday page starting at 0x%lx [%s]\n"
"mayday code:", start, dev);
mayday = (unsigned char *)start;
for (p = mayday; p < mayday + 32; p++)
printf(" %.2x", *p);
printf("\n");
}
}
fclose(maps);
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = sigdebug_handler;
sa.sa_flags = SA_SIGINFO;
sigaction(SIGDEBUG, &sa, NULL);
sa.sa_sigaction = dummy_handler;
sigaction(SIGUSR1, &sa, NULL);
printf("mlockall\n");
munlockall();
setup_checkdebug(SIGDEBUG_NOMLOCK);
err = rt_task_shadow(&main_task, "main_task", 0, 0);
check("rt_task_shadow", err, -EINTR);
check_sigdebug_received("SIGDEBUG_NOMLOCK");
mlockall(MCL_CURRENT | MCL_FUTURE);
errno = 0;
tmp_fd = mkstemp(tempname);
check_no_error("mkstemp", -errno);
unlink(tempname);
check_no_error("unlink", -errno);
mem = mmap(NULL, 1, PROT_READ | PROT_WRITE, MAP_SHARED, tmp_fd, 0);
check_no_error("mmap", -errno);
err = write(tmp_fd, "X", 1);
check("write", err, 1);
err = rt_task_shadow(&main_task, "main_task", 0, 0);
check_no_error("rt_task_shadow", err);
err = rt_mutex_create(&prio_invert, "prio_invert");
check_no_error("rt_mutex_create", err);
err = rt_mutex_acquire(&prio_invert, TM_INFINITE);
check_no_error("rt_mutex_acquire", err);
err = rt_sem_create(&send_signal, "send_signal", 0, S_PRIO);
check_no_error("rt_sem_create", err);
err = rt_task_spawn(&rt_task, "rt_task", 0, 1, T_WARNSW | T_JOINABLE,
rt_task_body, NULL);
check_no_error("rt_task_spawn", err);
err = rt_sem_p(&send_signal, TM_INFINITE);
check_no_error("rt_sem_signal", err);
pthread_kill(rt_task_thread, SIGUSR1);
rt_task_sleep(rt_timer_ns2ticks(20000000LL));
err = rt_mutex_release(&prio_invert);
check_no_error("rt_mutex_release", err);
err = rt_task_join(&rt_task);
check_no_error("rt_task_join", err);
err = rt_mutex_delete(&prio_invert);
check_no_error("rt_mutex_delete", err);
err = rt_sem_delete(&send_signal);
check_no_error("rt_sem_delete", err);
if (wd) {
fprintf(wd, "%d", old_wd_value);
fclose(wd);
}
fprintf(stderr, "Test OK\n");
return 0;
}
void initStruct(void) {
int err;
/* Creation des mutex */
if (err = rt_mutex_create(&mutexEtat, NULL)) {
rt_printf("Error mutex create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_mutex_create(&mutexMove, NULL)) {
rt_printf("Error mutex create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_mutex_create(&mutexRobot, NULL)) {
rt_printf("Error mutex create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_mutex_create(&mutexServer, NULL)) {
rt_printf("Error mutex create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_mutex_create(&mutexArene, NULL)) {
rt_printf("Error mutex create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_mutex_create(&mutexImage, NULL)) {
rt_printf("Error mutex create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_mutex_create(&mutexPositionRobot, NULL)) {
rt_printf("Error mutex create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_mutex_create(&mutexPositionVoulue, NULL)) {
rt_printf("Error mutex create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_mutex_create(&mutexValidArene, NULL)) {
rt_printf("Error mutex create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
/* Creation des semaphores */
if (err = rt_sem_create(&semConnecterRobot, NULL, 0, S_FIFO)) {
rt_printf("Error semaphore create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_sem_create(&semWatchdog, NULL, 0, S_FIFO)) {
rt_printf("Error semaphore create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_sem_create(&semPosition, NULL, 0, S_FIFO)) {
rt_printf("Error semaphore create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_sem_create(&semAcquArene, NULL, 0, S_FIFO)) {
rt_printf("Error semaphore create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_sem_create(&semValidArene, NULL, 0, S_FIFO)) {
rt_printf("Error semaphore create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_sem_create(&semBattery, NULL, 0, S_FIFO)) {
rt_printf("Error semaphore create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_sem_create(&semWebcam, NULL, 0, S_FIFO)) {
rt_printf("Error semaphore create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_sem_create(&semMission, NULL, 0, S_FIFO)) {
rt_printf("Error semaphore create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
/* Creation des taches */
if (err = rt_task_create(&tcommunicate, NULL, 0, PRIORITY_TCOMMUNICATE, 0)) {
rt_printf("Error task create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_task_create(&tconnect, NULL, 0, PRIORITY_TCONNECT, 0)) {
rt_printf("Error task create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_task_create(&tmove, NULL, 0, PRIORITY_TMOVE, 0)) {
rt_printf("Error task create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_task_create(&tsend, NULL, 0, PRIORITY_TSEND, 0)) {
rt_printf("Error task create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_task_create(&twatchdog, NULL, 0, PRIORITY_TWATCHDOG, 0)) {
rt_printf("Error task create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_task_create(&tbattery, NULL, 0, PRIORITY_TBATTERY, 0)) {
rt_printf("Error task create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_task_create(&tcam, NULL, 0, PRIORITY_TCAM, 0)) {
rt_printf("Error task create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_task_create(&tposition, NULL, 0, PRIORITY_TPOSITION, 0)) {
rt_printf("Error task create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_task_create(&tarena, NULL, 0, PRIORITY_TARENA, 0)) {
rt_printf("Error task create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
if (err = rt_task_create(&tmission, NULL, 0, PRIORITY_TMISSION, 0)) {
rt_printf("Error task create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
/* Definition des periodes */
rt_task_set_periodic(&tmove, TM_NOW, 200000000); // 200ms
rt_task_set_periodic(&tsend, TM_NOW, 200000000); // 200ms
rt_task_set_periodic(&twatchdog, TM_NOW, 1000000000); // 1s
rt_task_set_periodic(&tbattery, TM_NOW, 250000000); // 250ms
rt_task_set_periodic(&tcam, TM_NOW, 600000000); // 600ms
rt_task_set_periodic(&tposition, TM_NOW, 600000000); // 600ms
rt_task_set_periodic(&tmission, TM_NOW, 600000000); // 600ms
/* Creation des files de messages */
if (err = rt_queue_create(&queueMsgGUI, "toto", MSG_QUEUE_SIZE*sizeof(DMessage), MSG_QUEUE_SIZE, Q_FIFO))
{
rt_printf("Error msg queue create: %s\n", strerror(-err));
exit(EXIT_FAILURE);
}
/* Creation des structures globales du projet */
areneValidee = 1;
arena = 0;
robot = d_new_robot();
mvt = d_new_movement();
server = d_new_server();
image = d_new_image();
positionRobot = d_new_position();
positionVoulue = d_new_position();
etat_communication = malloc(sizeof(Etat_communication_t));
etat_communication->robot = 1;
etat_communication->moniteur = 1;
}
int cond_wait_until(cond_t *cond, mutex_t *mutex, unsigned long long date)
{
struct timespec ts = {
.tv_sec = date / NS_PER_S,
.tv_nsec = date % NS_PER_S,
};
return -pthread_cond_timedwait(cond, mutex, &ts);
}
#define cond_destroy(cond) (-pthread_cond_destroy(cond))
int thread_msleep(unsigned ms)
{
struct timespec ts = {
.tv_sec = (ms * NS_PER_MS) / NS_PER_S,
.tv_nsec = (ms * NS_PER_MS) % NS_PER_S,
};
return -nanosleep(&ts, NULL);
}
int thread_spawn(thread_t *thread, int prio,
void *(*handler)(void *cookie), void *cookie)
{
struct sched_param param;
pthread_attr_t tattr;
int err;
pthread_attr_init(&tattr);
pthread_attr_setinheritsched(&tattr, PTHREAD_EXPLICIT_SCHED);
pthread_attr_setschedpolicy(&tattr, SCHED_FIFO);
param.sched_priority = prio;
pthread_attr_setschedparam(&tattr, ¶m);
pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
pthread_attr_setstacksize(&tattr, xeno_stacksize(0));
err = pthread_create(thread, &tattr, handler, cookie);
pthread_attr_destroy(&tattr);
return -err;
}
#define thread_yield() sched_yield()
#define thread_kill(thread, sig) (-__real_pthread_kill(thread, sig))
#define thread_self() pthread_self()
#define thread_join(thread) (-pthread_join(thread, NULL))
#else /* __NATIVE_SKIN__ */
typedef RT_MUTEX mutex_t;
typedef RT_TASK *thread_t;
typedef RT_COND cond_t;
#define timer_read() rt_timer_read()
int __mutex_init(mutex_t *mutex, const char *name, int type, int pi)
{
if (type == PTHREAD_MUTEX_ERRORCHECK)
return -EINVAL;
(void)(pi);
return -rt_mutex_create(mutex, name);
}
#define mutex_init(mutex, type, pi) __mutex_init(mutex, #mutex, type, pi)
#define mutex_destroy(mutex) rt_mutex_delete(mutex)
#define mutex_lock(mutex) rt_mutex_acquire(mutex, TM_INFINITE)
#define mutex_unlock(mutex) rt_mutex_release(mutex)
int __cond_init(cond_t *cond, const char *name, int absolute)
{
(void)(absolute);
return rt_cond_create(cond, name);
}
#define cond_init(cond, absolute) __cond_init(cond, #cond, absolute)
#define cond_signal(cond) rt_cond_signal(cond)
#define cond_wait(cond, mutex, ns) rt_cond_wait(cond, mutex, (RTIME)ns)
#define cond_wait_until(cond, mutex, ns) \
rt_cond_wait_until(cond, mutex, (RTIME)ns)
#define cond_destroy(cond) rt_cond_delete(cond)
#define thread_self() rt_task_self()
#define thread_msleep(ms) rt_task_sleep((RTIME)ms * NS_PER_MS)
int
thread_spawn_inner(thread_t *thread, const char *name,
int prio, void *(*handler)(void *), void *cookie)
{
thread_t tcb;
int err;
tcb = malloc(sizeof(*tcb));
if (!tcb)
return -ENOSPC;
err = rt_task_spawn(tcb, name, 0, prio, T_JOINABLE,
(void (*)(void *))handler, cookie);
if (!err)
*thread = tcb;
return err;
}
