app.c

ucos-ii 的完整代码

/*
*********************************************************************************************************
*                                               uC/OS-II
*                                         The Real-Time Kernel
*
*                                           Sample code
*
* File : app.c
* By   : Eric Shufro
*********************************************************************************************************
*/
 #include <includes.h>

extern  void  LED_Init(void);
static  void  MyTask1(void *p_arg);
static  void  MyTask2(void *p_arg);
static  void  MyTask3(void *p_arg);
static  void  MyTask4(void *p_arg);
static  void  MyTask5(void *p_arg);  
static  void  AccelerometerTask(void *p_arg);


#define  yes   1
#define   no    0

#define   PTA2  1
#define   PTA3  2
#define   PTD2  3
#define   PTD3  4



OS_STK      MyTask1STK[MyTask1_STK_SIZE];  
OS_STK      MyTask2STK[MyTask2_STK_SIZE];
OS_STK      MyTask3STK[MyTask3_STK_SIZE];
OS_STK      MyTask4STK[MyTask4_STK_SIZE];
OS_STK      MyTask5STK[MyTask5_STK_SIZE];    
OS_STK      AccelerometerTaskStk[ACCELEROMETER_TASK_STK_SIZE];

static byte some_key_pressed;         // static variables for the Button manipulation
static byte key_press_debounced;
static byte TimeCount=0;

        

void InitSystems() 
{
  
  SOPT1  = 0x23;                          // Disable COP,RSTO, enable STOP,BKGD,RESET
  SOPT2  = 0x00;                          // SPI1 on PTB2/3/4/5, IIC1 on PTA2/3
  SPMSC1 = 0x00;                          // Disable LVD
  SPMSC2 = 0x00;                          // Disable power-down modes
  SPMSC3 = 0x00;                          // Disable LVWIE, low trip points
  SCGC1  = 0xFF;                          // Enable bus clock to peripherals
  SCGC2  = 0xFF;                          // Enable bus clock to peripherals
} // end InitSystems

void EnablePullups() 
{
  
  PTAPE = 0xFF;                           // Enable PORT A Internal Pullups
  PTBPE = 0xFF;                           // Enable PORT B Internal Pullups
  PTCPE = 0xFF;                           // Enable PORT C Internal Pullups
  PTDPE = 0xFF;                           // Enable PORT D Internal Pullups
  PTEPE = 0xFF;                           // Enable PORT E Internal Pullups
  PTFPE = 0xFF;                           // Enable PORT F Internal Pullups
  PTGPE = 0x0F;                           // Enable PTG0/1/2/3 Internal Pullups
  PTHPE = 0xC3;                           // Enable PTH0/1/6/7 Internal Pullups
} //end EnablePullups

void InitKBI() {
  
  /*KBI1 Init*/
  KBI1SC_KBIE   = 0;                      // Mask KBI1 interrupts
                                           
                                              
  KBI1ES_KBEDG3 = 0;                      // KBI1P3 internal pull-up, falling edge/low level
  KBI1ES_KBEDG2 = 0;                      // KBI1P2 internal pull-up, falling edge/low level

                                           
  KBI1PE_KBIPE3 = 1;                      // Enable KBI1P3 interrupts  
  KBI1PE_KBIPE2 = 1;                      // Enable KBI1P2 interrupts  
                                           
  KBI1SC_KBIMOD = 0;                      // Detect edges only
                                             
  KBI1SC_KBACK  = 1;                      // Clear possible false interrupts

  
  KBI1SC_KBIE   = 1;                      // Enable KBI1 interrupts
  
  /*KBI2 Init*/
  KBI2SC_KBIE   = 0;                      // Mask KBI2 interrupts
                                           
                                              
  KBI2ES_KBEDG3 = 0;                      // KBI2P3 internal pull-up, falling edge/low level
  KBI2ES_KBEDG2 = 0;                      // KBI2P2 internal pull-up, falling edge/low level

                                           
  KBI2PE_KBIPE3 = 1;                      // Enable KBI2P3 interrupts  
  KBI2PE_KBIPE2 = 1;                      // Enable KBI2P2 interrupts  
                                           
  KBI2SC_KBIMOD = 0;                      // Detect edges only
                                             
  KBI2SC_KBACK  = 1;                      // Clear possible false interrupts

  
  KBI2SC_KBIE   = 1;                      // Enable KBI2 interrupts
} //end InitKBI

 void InitADC(void) {
  
  byte done = 0x00;
  ADCSC1 = 0x1F;                          /* Disable interrupts 
                                             Disable continuous conversions
                                             Disable ADC by setting all ADCH bits */
  ADCSC2 = 0x40;                          /* Select H/W trigger
                                             Disable compare function */
  ADCCFG = 0x03; 	                        /* ADIV=input clock/8
                                             ADLSMP=long sample time
                                             MODE=8-bit conversion
                                             ADICLK=async clock */
  APCTL1 = 0x01;                          // Enable ADP0 as ADC input
} //end InitADC

void SetADC(byte adc_channel, byte aien_value) {

  ADCSC1_AIEN = aien_value&0x01;
  ADCSC1_ADCH = adc_channel;
} //end SetADC

// Initialize the TPM1 for PWM outputs (Channel 1 for Buzzer)
void TPM1Cx_PWM(byte CHAN, byte DUTY_CYCLE, word MOD, byte CLK_PS) 
{

    int val;
    
    if (MOD==0) 
    {
      
       TPM1SC=0x00;                       // disable PWM.
       return; 
    }
    if ((TPM1MODH==(MOD>>8)) && (TPM1MODL==(MOD-1))) 
    {
      
    } 
    else 
    {
      
       TPM1MODH = (byte) (MOD>>8);			  // set period 
       TPM1MODL = (byte) (MOD-1);
    }
    
    switch (CHAN) 
    {
    
      case 0: 
           TPM1C0SC = 0x24;               // Center-aligned low-true pulses
           if (MOD>100)
           {
              val = DUTY_CYCLE*(MOD/100);
           }
           else 
           {
              val = DUTY_CYCLE*MOD/100;
           }
           
           TPM1C0VH = (byte) (val>>8);    // set duty cycle for Channel 0
           TPM1C0VL = (byte) (val);
      break;
        
      case 1:
           TPM1C1SC = 0x24;               // Center-aligned low-true pulses
           if (MOD>100)
           {
              val = DUTY_CYCLE*(MOD/100);
           }
           else 
           {
              val = DUTY_CYCLE*MOD/100;
           }
           
           TPM1C1VH = (byte) (val>>8);    // set duty cycle for Channel 1
           TPM1C1VL = (byte) (val);
      break;
        
      case 2:
           TPM1C2SC = 0x24;               // Center-aligned low-true pulses
           if (MOD>100)
           {
              val = DUTY_CYCLE*(MOD/100);
           }
           else 
           {
              val = DUTY_CYCLE*MOD/100;
           }
           
           TPM1C2VH = (byte) (val>>8);    // set duty cycle for Channel 2
           TPM1C2VL = (byte) (val);
      break;
        
      default:
      break;      
    }
    
    TPM1SC   = (byte) (0x08|(CLK_PS&0x07));        // individual aligned, bus frequency/Prescale, start timer
} //end TPM1Cx_PWM

// Initialize the TPM3 Channels 0-5 for PWM outputs (LEDs)
void TPM3Cx_PWM(byte CHAN, byte DUTY_CYCLE, word MOD, byte CLK_PS) 
{

    int val;
    
    if (MOD==0) 
    {
      
       TPM3SC=0x00;                       // disable PWM.
       return; 
    }
    if ((TPM3MODH==(MOD>>8)) && (TPM3MODL==(MOD-1))) 
    {
      
    } 
     else 
    {
      
         TPM3MODH = (byte) (MOD>>8);		    // set period 
       TPM3MODL = (byte) (MOD-1);
    }
    
    
    switch (CHAN) 
    {
    
      case 0: 
           TPM3C0SC = 0x24;               // Center-aligned low-true pulses
           
           if (MOD>100)
           {
              val = DUTY_CYCLE*(MOD/100);
           }
           else 
           {
              val = DUTY_CYCLE*MOD/100;
           }
           
           TPM3C0VH = (byte) (val>>8);    // set duty cycle for Channel 0
           TPM3C0VL = (byte) (val);
      break;
        
      case 1:
           TPM3C1SC = 0x24;               // Center-aligned low-true pulses
           if (MOD>100)
           {
              val = DUTY_CYCLE*(MOD/100);
           }
           else 
           {
              val = DUTY_CYCLE*MOD/100;
           }
           
           TPM3C1VH = (byte) (val>>8);    // set duty cycle for Channel 1
           TPM3C1VL = (byte) (val);
      break;
        
      case 2:
           TPM3C2SC = 0x24;               // Center-aligned low-true pulses
           if (MOD>100)
           {
              val = DUTY_CYCLE*(MOD/100);
           }
           else 
           {
              val = DUTY_CYCLE*MOD/100;
           }
           
           TPM3C2VH = (byte) (val>>8);    // set duty cycle for Channel 2
           TPM3C2VL = (byte) (val);
      break;
        
      case 3:
           TPM3C3SC = 0x24;               // Center-aligned low-true pulses
           if (MOD>100)
           {
              val = DUTY_CYCLE*(MOD/100);
           }
           else 
           {
              val = DUTY_CYCLE*MOD/100;
           }
           
           TPM3C3VH = (byte) (val>>8);    // set duty cycle for Channel 3
           TPM3C3VL = (byte) (val);
      break;
        
      case 4:
           TPM3C4SC = 0x24;               // Center-aligned low-true pulses
           if (MOD>100)
           {
              val = DUTY_CYCLE*(MOD/100);