rtos.c

Counter

// *********************************************************
//                             include
// *********************************************************
#define ENABLE_BIT_DEFINITIONS
#define _XTALL 7372000
#include <stdlib.h>
#include <iom8.h>
#include <inavr.h>

unsigned char MODBUSmasiv[20];
unsigned char MODBUScaunt=0,MODBUSsize = 4;
unsigned char LRC,ResLRC;
unsigned char MODBUSdeode[16]= {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
unsigned char ID,ID_H,ID_L;
__root unsigned char MODBUSSend[20],MODBUSleght;
#include "oS.c"
#include "oS.h"
#include "oSdef.h"
#include "UART_mega8.c"

struct 
    {
        unsigned reset_0      : 1;
        unsigned overflow_0   : 1;
        unsigned strobfront_0 : 1;
        
        unsigned reset_1      : 1;
        unsigned overflow_1   : 1;
        unsigned strobfront_1 : 1;
    }Flags;

unsigned char MODBUSCODEC (unsigned char data1,unsigned char data2);
void InitExtInt (void);
void Timer0Init (void);

unsigned char CheckCounter[2] ={0,0};
unsigned int CauntMen;

void main(void)
  {
    DDRD =0xF0;

    DDRB = 0xDD;//0xC5;
 //   DDRD = 0x10;
    
 //   DDRB = 0x08;
    DDRC = 0;
     __enable_interrupt(); 
    
    PORTB |= 0x18;
    
    ID = PINC ^ 0x3F;
    ID_H = MODBUSdeode[ID>>4];
    ID_L = MODBUSdeode[ID &~ 0xF0];
     PORTD &= ~0x10;
     USART_Init(3);
//     TaskOn (3);
     TaskOn (5);
     
 
    
        Timer0Init();
    InitExtInt();
   while(1)
      {

        ISR();
        TaskRan();
      }
  }

void Task0(void)
   {
       TaskOff(0);
      //TaskOn ();
   }

void Task1(void)
   {

   }

   void Task2(void)
   {
      unsigned char i, CauntH,CauntL;
      TaskOff(2);
      LRC = 0;
      for ( i=1;i<5;i++)
          {
              LRC = LRC + MODBUSmasiv[i];
          }
      LRC = 0xFF - LRC;
      LRC = LRC + 1;

     ResLRC = MODBUSCODEC(MODBUSmasiv[5],MODBUSmasiv[6]);

    CauntH = CauntMen>>8;
    CauntL = CauntMen;
   
    
    if (LRC == ResLRC)
      {
       LRC = 0;
    //  PORTB ^= 0x08;
      MODBUSSend [0] = ':';
      MODBUSSend [1] = 'F';
      MODBUSSend [2] = '0';
      MODBUSSend [3] = 'A';
      MODBUSSend [4] = 'A';
      MODBUSSend [5] = ID_H;
      MODBUSSend [6] = ID_L;
      MODBUSSend [7] = MODBUSdeode[CauntH >> 4];
      MODBUSSend [8] = MODBUSdeode[CauntH &~ 0xF0];
      MODBUSSend [9] = MODBUSdeode[CauntL >> 4];
      MODBUSSend [10]= MODBUSdeode[CauntL &~ 0xF0];

      for ( i=1;i<11;i++)
          {
              LRC = LRC + MODBUSSend[i];
          }
      LRC = 0xFF - LRC;
      LRC = LRC + 1;
      //MODBUSSend [8] = LRC;
      MODBUSSend [11] = MODBUSdeode[LRC>>4];
      MODBUSSend [12] = MODBUSdeode[LRC &~ 0xF0];
      MODBUSSend [13] = 0x0D;
      MODBUSSend [14] = 0x0A;
      
      CauntMen =0;
      __delay_cycles (_XTALL * 5E-3);
  _putstring();
     
    /*  _putchar( MODBUSSend [1]);
      _putchar( MODBUSSend [2]);
      _putchar( MODBUSSend [3]);
      _putchar( MODBUSSend [4]);
      _putchar( MODBUSSend [5]);
      _putchar( MODBUSSend [6]);
      _putchar( MODBUSSend [7]);
      _putchar( MODBUSSend [8]);
      _putchar( MODBUSSend [9]);
      _putchar( MODBUSSend [10]);
      _putchar( 'E');
      _putchar( '7');
    //  _putchar( MODBUSSend [11]);
    //  _putchar( MODBUSSend [12]);
      _putchar( MODBUSSend [13]);
      _putchar( MODBUSSend [14]);
     // __delay_cycles (_XTALL * 50E-3);
     // PORTD &= ~0x10;
      //UCSRB |=  (1<<TXCIE);
*/
       }

/*
      _putchar( MODBUSmasiv [0]);
      _putchar( MODBUSmasiv [1]);
      _putchar( MODBUSmasiv [2]);
      _putchar( MODBUSmasiv [3]);
      _putchar( MODBUSmasiv [4]);
      _putchar( MODBUSmasiv [5]);
      _putchar( MODBUSmasiv [6]);
      _putchar( MODBUSmasiv [7]);
      _putchar( MODBUSmasiv [8]);
       //TaskOn ();*/
   }

   void Task3(void)
   {
      // TaskOff(3);
 /*     unsigned char i;
       LRC = 0;
      PORTB ^= 0x08;
      MODBUSSend [0] = ':';
      MODBUSSend [1] = 'F';
      MODBUSSend [2] = '0';
      MODBUSSend [3] = 'A';
      MODBUSSend [4] = 'A';
      MODBUSSend [5] = MODBUSdeode[Flags.reset_0];
      MODBUSSend [6] = MODBUSdeode[Flags.reset_1];
      MODBUSSend [7] = MODBUSdeode[CheckCounter[0] >> 4];
      MODBUSSend [8] = MODBUSdeode[CheckCounter[0] &~ 0xF0];
      MODBUSSend [9] = MODBUSdeode[CheckCounter[1] >> 4];
      MODBUSSend [10]= MODBUSdeode[CheckCounter[1] &~ 0xF0];

      for ( i=1;i<11;i++)
          {
              LRC = LRC + MODBUSSend[i];
          }
      LRC = 0xFF - LRC;
      LRC = LRC + 1;
      //MODBUSSend [8] = LRC;
      MODBUSSend [11] = MODBUSdeode[LRC>>4];
      MODBUSSend [12] = MODBUSdeode[LRC &~ 0xF0];
      MODBUSSend [13] = 0x0D;
      MODBUSSend [14] = 0x0A;
      
      CauntMen =0;
      __delay_cycles (_XTALL * 5E-3);
  _putstring();
   __delay_cycles (_XTALL * 200E-3);
       //TaskOn ();*/
   }

   void Task4(void)
   {
       TaskOff(4);
       //TaskOn ();
   }

   void Task5(void)
   {
     //  TaskOff(5);
       //TaskOn ();
   }

unsigned char MODBUSCODEC (unsigned char data1,unsigned char data2)
 {
   unsigned char i,result;

          for ( i=0;i<16;i++)
           {
             if (data1 == MODBUSdeode[i])
                {
                     result = i;
                     result = result << 4;
                }
           }
          for ( i=0;i<16;i++)
           {
             if (data2 == MODBUSdeode[i])
                {
                     result = result + i;

                }
           }
   return result;
 }
 
void Timer0Init (void)
{
Flags.overflow_0 = 1;
Flags.overflow_1 = 1;

// TCCR0=3;
// TIMSK=0x81;
}

void InitExtInt (void)
{
  Flags.strobfront_1 = 0;
  Flags.strobfront_0 = 0; 
  MCUCR |= 0x0A;
  GICR |= 0xC0;
   
}

#pragma vector = TIMER0_OVF_vect  // MAIN system timer
__interrupt void TIMER0_OVF (void)
{


}

#pragma vector = TIMER2_COMP_vect  
__interrupt void TIMER2_COMP (void)
{
   TCNT2 = 0;
//   Flags.overflow_1 = 1;
   
//   switch(Flags.strobfront_1)
//    {
//      case 0 :
       if (CheckCounter[1] < 12) CheckCounter[1]++;
       else 
          {
          PORTB |= 0x08;
            if(Flags.reset_1)
                {
                   Flags.reset_1 = 0;                                
                }
          }
       
//      break;
      
//      case 1 : 
      
//      break;
   
//   }   
}

#pragma vector = TIMER1_COMPA_vect  // MAIN system timer
__interrupt void TIMER1_COMPA (void)
{
    TCNT1 = 0;
//    Flags.overflow_0 = 1;
   
//   switch(Flags.strobfront_0)
//    {
//      case 0 :
       if (CheckCounter[0] < 12) CheckCounter[0]++;
       else 
          {PORTB |= 0x10;
            if(Flags.reset_0)
                {
                  if (Flags.reset_1) CauntMen++;
                  Flags.reset_0 = 0;                                
                }
          }
       
//      break;
      
//      case 1 : 
      
//      break;
//    }     
}


#pragma vector = INT0_vect
__interrupt void INT0_v (void)
{

    if(TCNT1 > 60 || Flags.overflow_0 )
              {
                  TCCR1A = 0;
                  TCCR1B = 0x05;
                  OCR1A = 100;
                  TCNT1 = 0;
                  TIMSK |= 0x10;
         
                  if (CheckCounter[0]) CheckCounter[0]--;
                  else { Flags.reset_0 = 1;
                        PORTB &= ~0x10;}
                  
                  Flags.overflow_0 = 0;
               //   MCUCR &= ~0x03;
               //   MCUCR |=  0x02;
                  
                  
                 // Flags.strobfront_0 = 0;
              }        

/*
switch(Flags.strobfront_0)
    {
      case 0 :
           if(TCNT1 > 50 || Flags.overflow_0 )
              {
                  TCCR1A = 0;
                  TCCR1B = 3;
                  OCR1A = 150;
                  TCNT1 = 0;
                  TIMSK |= 0x10;
                  
                  Flags.overflow_0 = 0;
                  MCUCR &= ~0x03; 
                  MCUCR |=  0x03;
                  Flags.strobfront_0 =1;
              }    
      break;
      
      case 1 :     
           if(TCNT1 > 100 || Flags.overflow_0 )
              {
                  TCCR1A = 0;
                  TCCR1B = 0x05;
                  OCR1A = 78;
                  TCNT1 = 0;
                  TIMSK |= 0x10;
         
                  if (CheckCounter[0]) CheckCounter[0]--;
                  else  Flags.reset_0 = 1;
                  
                  Flags.overflow_0 = 0;
                  MCUCR &= ~0x03;
                  MCUCR |=  0x02;
                  
                  
                  Flags.strobfront_0 = 0;
              }        
      break;        
    } */
}

#pragma vector = INT1_vect
__interrupt void INT1_v (void)
{
  if(TCNT2 > 60 || Flags.overflow_1 )
              {
                  TIMSK |= 0x80;
                  TCNT2 = 0;       
                  OCR2 = 100;
                  TCCR2 = 0x07;
         
                  if (CheckCounter[1]) CheckCounter[1]--;
                  else  {Flags.reset_1 = 1;
                  PORTB &= ~0x08;}
                  
                  Flags.overflow_1 = 0;
               //   MCUCR &= ~0x0C;
               //   MCUCR |=  0x08;
}                  
                  
              //    Flags.strobfront_1 = 0;
/*
 switch(Flags.strobfront_1)
    {
      case 0 :
           if(TCNT2 > 50 || Flags.overflow_1 )
              {
                  TIMSK |= 0x80;
                  TCNT2 = 0;       
                  OCR2 = 150;
                  TCCR2 = 0x04; 
                  Flags.overflow_1 = 0;
                  MCUCR &= ~0x0C; 
                  MCUCR |=  0x0C;
                  Flags.strobfront_1 =1;
              }    
      break;
      
      case 1 :     
           if(TCNT2 > 100 || Flags.overflow_1 )
              {
                  TIMSK |= 0x80;
                  TCNT2 = 0;       
                  OCR2 = 78;
                  TCCR2 = 0x07;
         
                  if (CheckCounter[1]) CheckCounter[1]--;
                  else  Flags.reset_1 = 1;
                  
                  Flags.overflow_1 = 0;
                  MCUCR &= ~0x0C;
                  MCUCR |=  0x08;
                  
                  
                  Flags.strobfront_1 = 0;
              } 
      break;        
    }*/ 
 /////
}