LY RTOS for WinAVR

/*
 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();
}
### 光流法C++源代码解析与应用 #### 光流法原理 光流法是一种在计算机视觉领域中用于追踪视频序列中运动物体的方法。它基于亮度不变性假设,即场景中的点在时间上保持相同的灰度值,从而通过分析连续帧之间的像素变化来估计运动方向和速度。在数学上,光流场可以表示为像素位置和时间的一阶导数,即Ex、Ey(空间梯度)和Et(时间梯度),它们共同构成光流方程的基础。 #### C++实现细节 在给定的C++源代码片段中,`calculate`函数负责计算光流场。该函数接收一个图像缓冲区`buf`作为输入,并初始化了几个关键变量:`Ex`、`Ey`和`Et`分别代表沿x轴、y轴和时间轴的像素强度变化;`gray1`和`gray2`用于存储当前帧和前一帧的平均灰度值;`u`则表示计算出的光流矢量大小。 #### 图像处理流程 1. **初始化和预处理**:`memset`函数被用来清零`opticalflow`数组,它将保存计算出的光流数据。同时,`output`数组被填充为白色,这通常用于可视化结果。 2. **灰度计算**:对每一像素点进行处理,计算其灰度值。这里采用的是RGB通道平均值的计算方法,将每个像素的R、G、B值相加后除以3,得到一个近似灰度值。此步骤确保了计算过程的鲁棒性和效率。 3. **光流向量计算**:通过比较当前帧和前一帧的灰度值,计算出每个像素点的Ex、Ey和Et值。这里值得注意的是,光流向量的大小`u`是通过`Et`除以`sqrt(Ex^2 + Ey^2)`得到的,再乘以10进行量化处理,以减少计算复杂度。 4. **结果存储与阈值处理**:计算出的光流值被存储在`opticalflow`数组中。如果`u`的绝对值超过10,则认为该点存在显著运动,因此在`output`数组中将对应位置标记为黑色,形成运动区域的可视化效果。 5. **状态更新**:通过`memcpy`函数将当前帧复制到`prevframe`中,为下一次迭代做准备。 #### 扩展应用:Lukas-Kanade算法 除了上述基础的光流计算外,代码还提到了Lukas-Kanade算法的应用。这是一种更高级的光流计算方法,能够提供更精确的运动估计。在`ImgOpticalFlow`函数中,通过调用`cvCalcOpticalFlowLK`函数实现了这一算法,该函数接受前一帧和当前帧的灰度图,以及窗口大小等参数,返回像素级别的光流场信息。 在实际应用中,光流法常用于目标跟踪、运动检测、视频压缩等领域。通过深入理解和优化光流算法,可以进一步提升视频分析的准确性和实时性能。 光流法及其C++实现是计算机视觉领域的一个重要组成部分,通过对连续帧间像素变化的精细分析,能够有效捕捉和理解动态场景中的运动信息
微信小程序作为腾讯推出的一种轻型应用形式,因其便捷性与高效性,已广泛应用于日常生活中。以下为该平台的主要特性及配套资源说明: 特性方面: 操作便捷,即开即用:用户通过微信内搜索或扫描二维码即可直接使用,无需额外下载安装,减少了对手机存储空间的占用,也简化了使用流程。 多端兼容,统一开发:该平台支持在多种操作系统与设备上运行,开发者无需针对不同平台进行重复适配,可在一个统一的环境中完成开发工作。 功能丰富,接口完善:平台提供了多样化的API接口,便于开发者实现如支付功能、用户身份验证及消息通知等多样化需求。 社交整合,传播高效:小程序深度嵌入微信生态,能有效利用社交关系链,促进用户之间的互动与传播。 开发成本低,周期短:相比传统应用程序,小程序的开发投入更少,开发周期更短,有助于企业快速实现产品上线。 资源内容: “微信小程序-项目源码-原生开发框架-含效果截图示例”这一资料包,提供了完整的项目源码,并基于原生开发方式构建,确保了代码的稳定性与可维护性。内容涵盖项目结构、页面设计、功能模块等关键部分,配有详细说明与注释,便于使用者迅速理解并掌握开发方法。此外,还附有多个实际运行效果的截图,帮助用户直观了解功能实现情况,评估其在实际应用中的表现与价值。该资源适用于前端开发人员、技术爱好者及希望拓展业务的机构,具有较高的参考与使用价值。欢迎查阅,助力小程序开发实践。资源来源于网络分享,仅用于学习交流使用,请勿用于商业,如有侵权请联系我删除!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值