main__.c

avr Rtos 255 Task avr Rtos 255 Task

SetPortD_In(unsigned char BitMask )
{ 
        ClrBit( DDRD, BitMask );    
} 
WritePortD(unsigned char Value, unsigned char BitMask )
{
        PORTD &= Value | ~BitMask;
        PORTD |= Value & BitMask;
}
SetPortG_Out(unsigned char BitMask )
{ 
        SetBit( DDRG, BitMask );      
} 
SetPortG_In(unsigned char BitMask )
{ 
        ClrBit( DDRG, BitMask );    
} 
WritePortG(unsigned char Value, unsigned char BitMask )
{
        PORTG &= Value | ~BitMask;
        PORTG |= Value & BitMask;
}               
#include <mega128.h>
static char screenpos[4][20] = {
                                {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
                                 0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93},
                                {0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,
                                 0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3},
                                {0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,
                                 0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7},
                                {0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,
                                 0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7}
                               };  

void temp()
{ 
 int t;
   //dezactivare LCD
  WritePortD(0x00,0x10);//0xx
  //scriere 0 linii
  WritePortA(0x00,0xFF);//data=0
  SetPortA_In(0xFF);//setare port A intrare
  //configurare citire LCD comanda
  WritePortD(0x20,0x70);//010//configurare citire

 for(t=0;t<50;t++);//temporizare
  WritePortD(0x10,0x10);//1xx
  // //activare LCD
  //  MA_WritePort_IO(MA_PORTG,0x00,0x04);
  ///////////////////////////////////////////////////debugbuton

//do{
 //citire busy flag
 //t=PINA;
 //}while(t&0x80);
 //MA_WritePort_IO(MA_PORTE,0xFF,0xFF);//data
 WritePortD(0x00,0x10);//000
 for(t=0;t<50;t++);//temporizare
  WritePortD(0x00,0x70);//000
  SetPortD_In(0x70);//setare port intrare
}

void send_command (const char s)
{ int temp_g;

  
  PORTD=0x00;  //000
  DDRA=0xFF;//setare port A iesire
  DDRD=0xFF;//setare port G iesire

  PORTA=s;//comanda
  PORTD=0x10;  //100
  for(temp_g=0;temp_g<50;temp_g++);//temporizare
  //temp();
}

void send_char (const char s)
{   
  int t;
  //temp();
  WritePortD(0x00,0x70);  //000
  SetPortA_Out(0xFF);//setare port A iesire
  SetPortD_Out(0x70);//setare port G iesire  

  WritePortA(s,0xFF);//data
  WritePortD(0x50,0x70);  //101 scriere data   
  
  for(t=0;t<50;t++);//temporizare
  temp(); 
}

void init()
{
//init_LCD();
  int temp_g;
  int ig;
  //initializare lcd
  DDRA=0xFF;//setare port A iesire
  DDRD=0xFF;//setare port G iesire
  //MA_WritePort_IO(MA_PORTG,0x00,0x07);  //000

  PORTD=0x10; //E=1 enable
  for(temp_g=0;temp_g<200;temp_g++);//temporizare

  //temp();
  for(ig=0;ig<3;ig++)
  {
   send_command(0x3c);//function Set : 8bits 2line on
   for(temp_g=0;temp_g<200;temp_g++);//temporizare
  }
   send_command(0x0F);//Display on
   for(temp_g=0;temp_g<200;temp_g++);//temporizare

   send_command(0x01);//Display clear
   for(temp_g=0;temp_g<200;temp_g++);//temporizare

   send_command(0x06);//Entry mode select
   for(temp_g=0;temp_g<200;temp_g++);//temporizare

 //  MA_WritePort_IO(MA_PORTE,0xFF,0xFF);//data

  // send_command(0x0f);//Display on
   //for(temp_g=0;temp_g<200;temp_g++);//temporizare
//End initializare
}   

void send_string (char *str) {			// sends the whole string to LCD
 while ((*str != 0)&& (*str != 10))
   send_char (*str++);
}

void setpos (char x,char y) {
 send_command (screenpos[x-1][y-1]);
}  
#include "my_os.h"
//#include <mega128.h>
//#include "global.h"
#include <stdlib.h>
//#include <inavr.h>

//externe
extern unsigned char t_sph;
extern unsigned char t_spl;
extern unsigned char t_r29;
extern unsigned char t_r28;
extern unsigned char task_time;
extern unsigned char ig,jg,kg,lg,mg,ng;
extern unsigned int global_inc_g;
extern unsigned int global_inc;
extern unsigned int inc;
extern unsigned char temp_g;
extern unsigned char b_start_so;
//extern S8 lcd_sem;
extern unsigned char lcd_coada[NR_MAX_TASK];


//folosita pentru initializarea t_sp si t_r in rutina timer
void get_tsp(void)
{
//initializare stiva (unde se gaseste adresa stivei)
    tem = (unsigned int) ((rtos[task_curent].adr_task)+OSTaskStkSize)>>8;
    t_sph=(unsigned char)(tem&0x00ff);
    t_spl=(unsigned char)((rtos[task_curent].adr_task)+OSTaskStkSize)&0xff;
//initializarea adresa pointer y
    tem = (unsigned int) ((rtos[task_curent].adr_task)+OSTaskStkSize-2)>>8;
    t_r29=(unsigned char)(tem&0x00ff);
    t_r28=(unsigned char)((rtos[task_curent].adr_task)+OSTaskStkSize-2)&0xff;
}

//salvarea variabilelor globale
void push_var(void)
{
//unsigned char ig,jg,kg,lg,mg,ng;
  rtos[task_curent].adr_task[OSTaskStkSize-5]=ig;
  rtos[task_curent].adr_task[OSTaskStkSize-6]=jg;
  rtos[task_curent].adr_task[OSTaskStkSize-7]=kg;
  rtos[task_curent].adr_task[OSTaskStkSize-8]=lg;
  rtos[task_curent].adr_task[OSTaskStkSize-9]=mg;
  rtos[task_curent].adr_task[OSTaskStkSize-10]=ng;
//  rtos[task_curent].adr_task[OSTaskStkSize-11]=(unsigned char)(global_inc_g&0x0ff);
//  rtos[task_curent].adr_task[OSTaskStkSize-12]=(unsigned char)((global_inc_g>>8)&0x0ff);

  rtos[task_curent].adr_task[OSTaskStkSize-11]=temp_g;
 // rtos[task_curent].adr_task[OSTaskStkSize-12]=init_t;
}
unsigned char comuta_task(void)
{
    if(task_varf==-1)//test daca este goala lista
      return 0;
//nou: task-ul este comutat numai daca este activat!
    do
    {
     if(task_curent>=task_coada)
       task_curent=task_varf-1;
     task_curent++;
     tem++;
    }while(!(rtos[task_curent].activ));
    task_time=rtos[task_curent].nr_timpi;
//initializare stiva (unde se gaseste adresa stivei)
    tem = (unsigned int) ((rtos[task_curent].adr_task)+OSTaskStkSize)>>8;
    t_sph=(unsigned char)(tem&0x00ff);
    t_spl=(unsigned char)((rtos[task_curent].adr_task)+OSTaskStkSize)&0xff;
//initializarea pointer y (unde se gaseste adresa registrilor r29 si r28)
    tem = (unsigned int) ((rtos[task_curent].adr_task)+OSTaskStkSize-2)>>8;
    t_r29=(unsigned char)(tem&0x00ff);
    t_r28=(unsigned char)((rtos[task_curent].adr_task)+OSTaskStkSize-2)&0xff;

    return 1;
} 

 //restaurarea noilor variabile locale
void pop_var(void)
{
  ig=rtos[task_curent].adr_task[OSTaskStkSize-5];
  jg=rtos[task_curent].adr_task[OSTaskStkSize-6];
  kg=rtos[task_curent].adr_task[OSTaskStkSize-7];
  lg=rtos[task_curent].adr_task[OSTaskStkSize-8];
  mg=rtos[task_curent].adr_task[OSTaskStkSize-9];
  ng=rtos[task_curent].adr_task[OSTaskStkSize-10];
  temp_g=rtos[task_curent].adr_task[OSTaskStkSize-11];
}  
  
void start_so(void)
{
 //initializeaza vectorul de taskuri
  task_varf=task_coada=task_curent=-1;//initializeaza index vector taskuri
}     

//functia creaza un task
unsigned char creaza_task(void (*taskf)(void),unsigned char numar)
{
    unsigned int i;
//1.pozitionarea taskului in lista
    if(task_varf==-1)//daca lista este vida
    {
      if(task_coada>=NR_MAX_TASK-1)//daca indexul nu este mai mare decat numarul de task-uri
        return T_EROARE;
      task_coada++;//incrementeaza indexul coada
      task_curent=task_varf=task_coada;
//initializare
    }
    else//daca lista are cel putin un element
    {
      if(task_coada>=NR_MAX_TASK-1)
        return 0;
      task_coada++;
    }
    rtos[task_coada].nr_timpi=numar;//initializare timpi task
    rtos[task_coada].activ=1;//initializare task on/off
    for(i=0;i<OSTaskStkSize;i++)
      rtos[task_coada].adr_task[i]=(unsigned char)i;//initializare stiva in total
//salvarea pointer functie
    i = (unsigned int) taskf;
    rtos[task_coada].adr_task[OSTaskStkSizeHard-1]=(unsigned char)i&0x0ff;//ocmps functie
    rtos[task_coada].adr_task[OSTaskStkSizeHard-2]=(unsigned char)((i>>8)&0x0ff);//ocms functie
//initializarea stivei
    i = (unsigned int) rtos[task_coada].adr_task+OSTaskStkSizeHard-3;
    rtos[task_coada].adr_task[OSTaskStkSize-1]=(unsigned char)i&0xff;
    rtos[task_coada].adr_task[OSTaskStkSize-2]=(unsigned char)(i>>8)&0xff;
//initialiarea pointer y
    i = (unsigned int) rtos[task_coada].adr_task+62;
    rtos[task_coada].adr_task[OSTaskStkSize-3]=(unsigned char)i&0xff;
    rtos[task_coada].adr_task[OSTaskStkSize-4]=(unsigned char)(i>>8)&0xff;

    return 1;
} 
  

//folosita pentru initializarea t_sp si t_r pentru primul task care se va executa
void init_task(void)
{
 //initializare stiva (unde se gaseste adresa stivei)
    task_time=rtos[task_curent].nr_timpi;
    tem = (unsigned int) ((rtos[task_curent].adr_task)+OSTaskStkSize)>>8;
    t_sph=(unsigned char)(tem&0x00ff);
    t_spl=(unsigned char)((rtos[task_curent].adr_task)+OSTaskStkSize)&0xff;
//initializarea pointer y
    tem = (unsigned int) ((rtos[task_curent].adr_task)+OSTaskStkSize-2)>>8;
    t_r29=(unsigned char)(tem&0x00ff);
    t_r28=(unsigned char)((rtos[task_curent].adr_task)+OSTaskStkSize-2)&0xff;
//initialiarea pointer y - la primul task stiva software este pregatita pentru incarcare valori registrii!
    tem = (unsigned int) rtos[task_curent].adr_task+80;
    rtos[task_curent].adr_task[OSTaskStkSize-3]=(unsigned char)tem&0xff;
    rtos[task_curent].adr_task[OSTaskStkSize-4]=(unsigned char)(tem>>8)&0xff;
}  

void PopSP(void)
{
  #asm("cli")
  #asm("  LDS R29,_t_sph");
  #asm("  LDS R28,_t_spl");
  #asm("  LD R16,-Y");
  #asm("  OUT 0x3d,R16");
  #asm("  LD R16,-Y");
  #asm("  OUT 0x3e,R16");

//in plus setare pointer y pentru stiva soft!
  #asm("  LDS R30,_t_r28");
  #asm("  LDS R31,_t_r29");
  #asm("  LD R28,-Z");
  #asm("  LD R29,-Z");

  b_start_so=1;
  #asm("sei")
}