LY RTOS for WinAVR

最新推荐文章于 2024-07-05 14:48:13 发布
最新推荐文章于 2024-07-05 14:48:13 发布
阅读量1.2k 收藏 1
点赞数
文章标签： semaphore output compiler timer struct gcc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ly_liuyang/article/details/2578781
版权
/*
 LY RTOS a lightweight micro RTOS for WinAVR - GCC for ATMEL AVR micro controller
 build 2008.5.28 copyrights by LYSoft(C) Liu Yang
 http://G4Soft.net
*/
 
// you cannot remove this for your project which use LY RTOS
// 不得LYSoft之移除版权信息
unsigned char CopyRights[] ={"LY RTOS for AVR by LYSoft Liu Yang"};
 
#include <io.h>
#include <iom32.h>
#include <interrupt.h>
 
#define F_CPU        11059200
#define BAUDRATE     9600
 
// avoid compiler to use the following register
/*
register unsigned char tempR16 asm("r16");
register unsigned char tempR17 asm("r17");
// only about R15 can be used with IMD data LDI R16,0x01
*/
 
#define OSMaxTask        3
#define OSInfinite       0xFFFF
#define OSInvalid        0xFF
#define OSTaskEmpty      0
#define OSTaskReady      1
#define OSTaskWait       2
#define OSTaskSuspend    3
// Time(Sec) = CCR * (MAX - TCNT0 + 1) / F_CPU
#define OSTimerValue     120 // about 100ns
#define MCURegCount      32
 
static unsigned char OSCurrentTaskID = 0;
static unsigned char OSAtomFlag = 0;
static unsigned long OSIdleCount = 0, OSTickCount = 0;
 
struct tagTaskControlBlock
{
    unsigned char Status;
 unsigned int Stack;
 unsigned int WaitTick;
 unsigned char * Semaphore;
} TCB[OSMaxTask + 1];
 
unsigned char OSCreateTask(void (*Task)(void), unsigned char *TaskStack)
{
 unsigned char i = 1, TaskID;
 for (TaskID = 0; TaskID < OSMaxTask + 1; TaskID ++)
    if (TCB[TaskID].Status == OSTaskEmpty)
        {
            i = 0;
            break;
        }
  if (i) return OSInvalid;
 TCB[TaskID].Status = OSTaskReady;
 // PUSH = SP --; POP = SP ++
 *TaskStack --= (unsigned int)Task;        // save low address of SP
 *TaskStack --= (unsigned int)Task >> 8; // save high address of SP
 *TaskStack --= 0x00;                      // R0 __tmp_reg__
 *TaskStack --= 0x80;                      // SREG: SEI = 1 
 for (i = 0; i < MCURegCount - 1; i ++) *TaskStack --= 0x00;
 TCB[TaskID].Stack = (unsigned int)TaskStack;     // save SP
}
 
unsigned char OSTerminateTask(unsigned char TaskID)
{
    if (TaskID > OSMaxTask) return 0;
    if (TCB[TaskID].Status == OSTaskEmpty) return 0;
    TCB[TaskID].Status = OSTaskEmpty;
    return 1;
}
 
void OSSwitchTask()
{
    unsigned char i = OSMaxTask;
 while (i)
 {
      i --;
      OSCurrentTaskID ++;
    if (OSCurrentTaskID > OSMaxTask) OSCurrentTaskID = 1;
    if (TCB[OSCurrentTaskID].Status == OSTaskReady) return;
    // check semaphore
    if (TCB[OSCurrentTaskID].Semaphore > 0)
        if (* TCB[OSCurrentTaskID].Semaphore > 0)
            { // deattach semaphore from task and then resume task
                TCB[OSCurrentTaskID].Semaphore = 0;
                // task ready for dispatch
                TCB[OSCurrentTaskID].Status = OSTaskReady;
                return;
            }
 }
 // OS idle
 OSCurrentTaskID = 0;
 return;
}
 
// Macro for saving the context during an interrupt service.
#define SaveContext(void) /
    __asm__ __volatile__ ( /
        "push   r0"     "/n/t" /
        "in     r0, __SREG__" "/n/t" /
        "cli"           "/n/t" /
        "push   r0"     "/n/t" /
        "push   r1"     "/n/t" /
        "clr    __zero_reg__"   "/n/t" /
        "push   r2"     "/n/t" /
        "push   r3"     "/n/t" /
        "push   r4"     "/n/t" /
        "push   r5"     "/n/t" /
        "push   r6"     "/n/t" /
        "push   r7"     "/n/t" /
        "push   r8"     "/n/t" /
        "push   r9"     "/n/t" /
        "push   r10"    "/n/t" /
        "push   r11"    "/n/t" /
        "push   r12"    "/n/t" /
        "push   r13"    "/n/t" /
        "push   r14"    "/n/t" /
        "push   r15"    "/n/t" /
        "push   r16"    "/n/t" /
        "push   r17"    "/n/t" /
        "push   r18"    "/n/t" /
        "push   r19"    "/n/t" /
        "push   r20"    "/n/t" /
        "push   r21"    "/n/t" /
        "push   r22"    "/n/t" /
        "push   r23"    "/n/t" /
        "push   r24"    "/n/t" /
        "push   r25"    "/n/t" /
        "push   r26"    "/n/t" /
        "push   r27"    "/n/t" /
        "push   r28"    "/n/t" /
        "push   r29"    "/n/t" /
        "push   r30"    "/n/t" /
        "push   r31"    "/n/t" /
    :: /
    )   
 
// Macro for restoring the context during an interrupt service.
#define RestoreContext(void) /
    __asm__ __volatile__ ( /
        "pop    r31"    "/n/t" /
        "pop    r30"    "/n/t" /
        "pop    r29"    "/n/t" /
        "pop    r28"    "/n/t" /
        "pop    r27"    "/n/t" /
        "pop    r26"    "/n/t" /
        "pop    r25"    "/n/t" /
        "pop    r24"    "/n/t" /
        "pop    r23"    "/n/t" /
        "pop    r22"    "/n/t" /
        "pop    r21"    "/n/t" /
        "pop    r20"    "/n/t" /
        "pop    r19"    "/n/t" /
        "pop    r18"    "/n/t" /
        "pop    r17"    "/n/t" /
        "pop    r16"    "/n/t" /
        "pop    r15"    "/n/t" /
        "pop    r14"    "/n/t" /
        "pop    r13"    "/n/t" /
        "pop    r12"    "/n/t" /
        "pop    r11"    "/n/t" /
        "pop    r10"    "/n/t" /
        "pop    r9"     "/n/t" /
        "pop    r8"     "/n/t" /
        "pop    r7"     "/n/t" /
        "pop    r6"     "/n/t" /
        "pop    r5"     "/n/t" /
        "pop    r4"     "/n/t" /
        "pop    r3"     "/n/t" /
        "pop    r2"     "/n/t" /
        "pop    r1"     "/n/t" /
        "pop    r0"     "/n/t" /
        "out    __SREG__, r0" "/n/t" /
        "pop    r0"    "/n/t" /
    :: /
    )
 
void OSDispatch(void) __attribute__ ((naked));
void OSDispatch(void)
{
 SaveContext();
 __asm__ __volatile__("INT_OSDispatch: /t");    // dispatch from interrupt
 
 if (OSAtomFlag == 0)
      {
          TCB[OSCurrentTaskID].Stack = SP;
          OSSwitchTask();
          SP = TCB[OSCurrentTaskID].Stack;
      }
    
 RestoreContext();
 __asm__ __volatile__("RETI /t");
}
 
ISR(TIMER0_OVF_vect) __attribute__ ((naked));
ISR(TIMER0_OVF_vect)
{
 SaveContext();
 
 static unsigned char TaskID; // move variable out of register
 for (TaskID = 1; TaskID < OSMaxTask + 1; TaskID ++)
 {
    if (TCB[TaskID].WaitTick && TCB[TaskID].WaitTick != OSInfinite && TCB[TaskID].Status == OSTaskWait)
    {
      TCB[TaskID].WaitTick --;
      if (TCB[TaskID].WaitTick == 0) TCB[TaskID].Status = OSTaskReady;
    }
 }
 
 OSTickCount ++;
 TCNT0 = OSTimerValue;
 __asm__ __volatile__("JMP INT_OSDispatch /t");
}
 
void OSSuspendTask(unsigned char TaskID)
{
    if (TaskID > OSMaxTask) return;
 TCB[TaskID].Status = OSTaskSuspend;
 if (OSCurrentTaskID == TaskID) OSDispatch();
}
 
void OSResumeTask(unsigned char TaskID)
{
    if (OSCurrentTaskID == TaskID || TaskID > OSMaxTask) return;
 TCB[TaskID].Status = OSTaskReady;
 OSDispatch();
}
 
void OSDelay(unsigned int Ticks)
{
 if (Ticks)
 {      
    TCB[OSCurrentTaskID].WaitTick = Ticks;
    TCB[OSCurrentTaskID].Status = OSTaskWait;
    OSDispatch();
 }
}
 
void OSIdleTask()
{
    while(1)
    {
        OSDispatch();
        OSIdleCount ++;
    }
}
 
#define OSIdleTaskStackSize 64
unsigned char OSIdleTaskStack[OSIdleTaskStackSize];
 
void OSInit()
{
    unsigned char i;   
    for (i = 0; i < OSMaxTask + 1; i ++)
    {
        TCB[i].Status = OSTaskEmpty;
        TCB[i].Stack = 0;
        TCB[i].WaitTick = 0;
        TCB[i].Semaphore = 0;
    }
    OSCreateTask(OSIdleTask, OSIdleTaskStack + OSIdleTaskStackSize - 1);
    OSAtomFlag = 0;
}
 
void OSExecute()         
{
 TCCR0 = 0;
 TCCR0 |= (1 << CS01);
 TIMSK |= (1 << TOIE0);
 TCNT0 = OSTimerValue;
 SP = TCB[0].Stack + MCURegCount + 1;
  sei();
 __asm__ __volatile__("RETI /t" );
}
 
void OSEnterAtom(unsigned char IsAllowINT)
{
    if (IsAllowINT == 0) cli();
    OSAtomFlag = 1;
}
 
void OSLeaveAtom()
{
    OSAtomFlag = 0;
    sei();
}
 
unsigned char OSGetCurrentTaskID()
{
    return OSCurrentTaskID;
}
 
unsigned long OSGetTickCount()
{
    return OSTickCount;
}
unsigned long OSGetIdleCount()
{
    return OSIdleCount;
}
 
// Semaphore
void OSPostSemaphore(unsigned char * Semaphore)
{
    if (Semaphore == 0) return;
    if (* Semaphore < 0xFF) * Semaphore += 1;
}
 
unsigned char OSWaitSemaphore(unsigned char * Semaphore, unsigned int Ticks)
{
    if (Semaphore == 0) return;
    if (* Semaphore > 0)
        {
            * Semaphore -= 1;
            return 1;
        }
    // Semaphore = 0, suspend current task
    if (Ticks)
        {
            TCB[OSCurrentTaskID].WaitTick = Ticks;
            TCB[OSCurrentTaskID].Semaphore = Semaphore;
            TCB[OSCurrentTaskID].Status = OSTaskWait;
          OSDispatch();
      }
    if (* Semaphore > 0)
        {
            * Semaphore -= 1;
            return 1;
        }
    return 0;           
}
 
//*************************************************************************
 
#define uchar unsigned char
#define uint    unsigned int
#define ulong unsigned long
 
#define MaxReadSize 100
 
uchar ReadSize = 0, Sem = 0, ReadBuffer[MaxReadSize];
 
ISR(USART_RXC_vect)
{
 uchar Data,Status;
    Status = UCSRA;
    Data = UDR;
 if ((Status & ((1<<FE) | (1<<DOR) | (1<<PE))) != 0) return;
 if (Data == 13)
      {       
        UCSRB &= ~(1 << RXCIE);       
        OSPostSemaphore(&Sem);
      return;
    } else if (Data == 10) return;    
    if (ReadSize >= MaxReadSize) return;
    ReadBuffer[ReadSize] = Data;
    ReadSize++;
}
 
void UARTSend(unsigned char *pASCII, unsigned char Length)
{
 uchar i;
 if (Length == 0) Length = 0xFF;
 for (i=0; i < Length; i++)
    {
      if ((Length == 0xFF) && (pASCII[i] == 0)) return;
    while ( !(UCSRA & (1<<UDRE)) ) ;
    UDR = pASCII[i];
    }
}
 
void UARTEnableReceive()
{    
    ReadSize = 0;
    UCSRB |= (1 << RXCIE);
}
 
#define sbi(port, bit) (port) |= (1 << (bit))
#define cbi(port, bit) (port) &= ~(1 << (bit))
#define nob(port, bit) (port) ^= (1 << (bit))
 
#define KBPort PORTB
#define KBDDR DDRB
#define KBPIN PINB
#define KBLine 7
 
uchar ScanKey()
{
    uchar i, j, k;   
    for (i = 0; i < KBLine; i++)
    {
        KBDDR = 0x80; //use PB7 as LCD light output, but original is KBDDR = 0;
        sbi(KBDDR, i);
        KBPort = KBPort | 0x7F; //use PB7 as LCD light output, but original is KBPort = 0xFF;
        cbi(KBPort, i);
        j = ~(1<<i);
        k = ~KBPIN;
        k &= 0x7F; //added for use PB7 as LCD light output
        if ((k & j) != 0)
            {
                OSDelay(1000);
                if ((k & j) != 0) return ((k & j) | (1<<i));
            }
    }
    return 0;
}
 
void UARTInit()     //初始化串口
{
 UCSRC = (1<<URSEL) | 0x06;     //异步，8位数据，无奇偶校验，一个停止位，无倍速    
 UBRRL= (F_CPU/BAUDRATE/16-1)%256;
 UBRRH= (F_CPU/BAUDRATE/16-1)/256;
 UCSRA = 0x00;
 UCSRB = (1<<RXCIE)|(1<<RXEN)|(1<<TXEN); //|(1<<TXCIE);
 UDR=0;
}
 
void Task1()
{    
 unsigned char i, Text[16];
 while (1)
 {
    i = ScanKey();
    if (i)
        {
            sprintf(Text, "Key: %u/r/n", i);
            OSEnterAtom(0);
            UARTSend(Text, 0);
            OSLeaveAtom();
        }
 }
}
 
void Task2()
{
 unsigned char i, Text[32];
 while (1)
 {
      i = OSWaitSemaphore(&Sem, OSInfinite);     
      OSEnterAtom(0);
      if (i)
          {
              sprintf(Text, "CMD > [%u]/r/n", ReadSize);
              UARTSend(Text, 0);
          }    else // these code never runs when Ticks = OSInfinite
              UARTSend("Read Timeout/r/n", 0);             
    OSLeaveAtom();
    UARTEnableReceive();
 }
}
 
void Task3()
{
    unsigned int i = 0;
 unsigned char Text[48];
 while (1)
 {
    i ++;
    sprintf(Text, "TCC: %u, IC: %lu, OSTC: %lu/r/n", i, OSIdleCount, OSTickCount);
    OSEnterAtom(0);
    UARTSend(Text, 0);
    OSLeaveAtom();
    OSDelay(5000);   
 }
}
 
void InitMCU()
{
    // init port
    DDRA = 0x37;
    DDRC = 0xFF;
    DDRD = 0xFF;
    PORTA = 0;
    PORTC = 0;
    PORTD = 0;
}
 
// global task stack
static unsigned char Stack[600];
 
int main (void)
{
 InitMCU();
 UARTInit();
 
 OSInit();
 OSCreateTask(Task1, Stack + 199);
 OSCreateTask(Task2, Stack + 399);
 OSCreateTask(Task3, Stack + 599);
 OSExecute();
}
ly_liuyang
关注
汽车编程-Using the TASKING RTOS for TriCore.pdf
07-27
汽车编程-Using the TASKING RTOS for TriCore 本文档旨在介绍TASKING RTOS在TriCore微控制器上的应用，探讨汽车编程领域中的实时操作系统的应用。_below_ 1. 实时系统 实时系统（Real-time System）是一种计算机...
Estaño: RTOS for microcontrollers-开源
05-06
【 Estaño：为微控制器设计的开源RTOS 】 在嵌入式系统开发中，实时操作系统（RTOS）扮演着至关重要的角色，特别是在微控制器应用中。Estaño是一个专门为微控制器设计的开源RTOS，它旨在提供高效、可靠且轻量级的...
内存管理（RTOS）
weixin_62292999的博客
07-05 1398
如果程序不需要删除，堆内存对象可以使用这个文件，对堆内存进行管理，如果在一些严格的系统里面，如果不允许使用动态内存(就是不允许分配内存，使用过后回收内存)，就可以使用这个函数，进行分配内存，因为这个文件不回收内存。A在创建任务之前整个Heap都是空着的，B是分配一个任务之后heap的使用情况，C是3个任务之后heap的使用情况，这个时候如果有任务结束，这些空间是不会被收回的。，如果内存的地址不连续，可以使用 heap_5.c 如果内存是分开的不连续的，在使用。
主流 RTOS 评估
pwl999的博客
04-21 7433
1. RT-Thread RT-Thread 是国内出产的一款非常优秀的 RTOS。它和 FreeRTOS 、uCos 等经典 RTOS 最大的不同是：它不仅仅是一个实时内核，还具备丰富的中间层组件。 它提供了一个完整的软件栈解决方案，而不需要用户搜集各种 核心组件 手工从头搭建。 包括以下部分: 内核层：RT-Thread 内核，是 RT-Thread 的核心部分，包括了内核系统中对象的实现，例如多线程及其调度、信号量、邮箱、消息队列、内存管理、定时器等；libcpu/BSP（芯片移植相关文件 / 板
CMSIS-RTOS2简介
propor的专栏
06-17 1077
CMSIS-RTOS2
深入探究RTOS的任务调度
m0_74976404的博客
06-18 1814
阅读引言： 此文将会从一个过程文件， 一步一步的分析RTOS的任务调度实现， 这里选用FreeRTOS分析， 别的也差不多的， 可能在细节上有少许不一样。
RTOS实时操作系统概述
生活需要深度
05-26 1196
RT-Thread操作系统进程管理算法和Linux中RT调度器中的RR调度相同，在严格优先级的基础上增加了时间片轮训。关于这个操作系统的调度管理流程可以查阅《普中RT-Thread开发攻略_V2.1--基于STM32》书籍。书籍从0写一个RT-Thread操作系统，并在这个基础上完成部分简单的应用开发功能。
RTOS概述
四季帆的博客
06-07 2299
1. RTOS核心 RTOS 系统的核心就是任务管理，FreeRTOS 也不例外，上手 RTOS 系统首先必须掌握的也是任务的创建、删除、挂起和恢复等操作。
RTOS学习笔记
小伟的博客
07-03 1282
实时内核RTOS操作系统：FreeRTOS，UCOS，RTX，RT-Thread，DJYOS等
各种 RTOS 对比
u011011827的博客
07-11 2601
RTOS
如何快速入门RTOS
一起学嵌入式
10-26 5117
摘要 本文结合自己学习RTOS的经历，来谈谈如何快速入门一款RTOS，希望能够给初学者以启发，找到适合自己的学习思路和方法。 我的学习经历 ucos学习 我是在上学期间接触到了RTOS，当时学习的是ucos-II。首次接触RTOS，许多概念都是全新的，找了两本书就开始学习了。《嵌入式操作系统uCOS-II(第二版)》（邵贝贝译著）、《嵌入式实时操作系统μCOS-II原理及应用》（任哲编著）。 说实话，对于初学者来说，《嵌入式实时操作系统μCOS-II原理及应用》这本书更合适一些，门槛低
RTOS面试题（一）
生活需要深度
05-28 4955
一个处理器核心在某一时刻只能运行一个任务，操作系统中任务调度器的责任就是决定在某一时刻究竟运行哪个任务。 实时操作系统中都要包含一个实时任务调度器，这个任务调度器与其它操作系统的最大不同是强调：严格按照优先级来分配CPU时间，并且时间片轮转不是实时调度器的一个必选项。FreeRTOS就是一款支持多任务运行的实时操作系统，具有时间片、抢占式和合作式三种调度方式。抢占式调度器 使用了抢占式调度，最高优先级的任务一旦就绪，总能得到 CPU 的控制权。 比如，当一个运行着的任务被其它高优先级的任务抢占，当前任务的
simple RTOS for C51_rtos_
10-03
在这个名为“simple RTOS for C51_rtos_”的项目中，我们看到主要涉及到的是针对C51芯片的简单RTOS实现。C51是Microchip公司为8051系列微控制器编写的编译器，因此这个RTOS是为这类MCU设计的。 首先，我们要理解...
IEEE Standard for a Real-Time Operating System (RTOS) for Small-
06-21
IEEE Standard for a Real-Time Operating System (RTOS) for Small-Scale Embedded Systems-2018 IEEE Standard for a Real-Time Operating System (RTOS) for Small-Scale Embedded Systems-2018是IEEE Consumer ...
PRTOS Preemptive RTOS for embedded aps:PRTOS是用于嵌入式系统的简单，紧凑的抢占式RTOS-开源
05-09
只有950行代码实现了所有RTOS功能（SLOC-L）； 该系统文档详尽，包含全面的手册，注释良好的源代码和演示功能的测试套件。 该系统经过验证-自1982年以来一直在体外医疗设备，过程控制仪器和工业机械中使用； PRTOS...
基于SpringBoot仿天猫购物系统.zip(毕设&课设&实训&大作业&竞赛&项目)
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
Python网络爬虫与推荐算法新闻推荐平台(毕设&课设&实训&大作业&竞赛&项目)
最新发布
09-20
Python网络爬虫与推荐算法新闻推荐平台：网络爬虫：通过Python实现新浪新闻的爬取，可爬取新闻页面上的标题、文本、图片、视频链接（保留排版） 推荐算法：权重衰减+标签推荐+区域推荐+热点推荐.zip项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
THUCNews数据集
09-20
THUCNews数据集
Q音：Vue3+Pinia+Vue Router4+Vant4的移动端仿抖音短视频项目.zip(毕设&课设&实训&大作业&竞赛&
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
汽车编程- TASKING RTOS for TriCore 使用指南
The document "Using the TASKING RTOS for TriCore" provides a comprehensive guide on how to effectively utilize the TASKING Real-Time Operating System (RTOS) for TriCore microcontrollers in automotive ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值