starnet.c

都是主从板程序

/**************************************************************
*    Includes
**************************************************************/
#include <hidef.h> /* for EnableInterrupts macro */
#include "device_header.h" /* include peripheral declarations */
#include "pub_def.h"
#include "MC13192_hw_config.h"
#include "mcu_hw_config.h"
#include "simple_mac.h"
#include "remote_controller.h"
#include "bootloader user api.h"
#include "SCI.h"
#include "LCD.h"
#include "ascii_utilities.h"
#include "freescale_radio_hardware.h"

/**************************************************************
*    Data definitions
**************************************************************/
  UINT8 gu8RTxMode; /* Current mode of the MC13192 XCVR */
  tTxPacket gsTxPacket;
  tRxPacket gsRxPacket;
  UINT8 gauTxDataBuffer[26];
  UINT8 gauRxDataBuffer[26];
  UINT8 gau8String[20];
     
/**************************************************************
*    Main Program
**************************************************************/
void main(void)

{  
  /* Initialize variables. */
  UINT8 u8Channel = 0;
  UINT8 u8DeviceLed = 0x00;
  UINT8 u8Count1 = 0;
  UINT8 u8Garbage = 0;
  UINT32 u32ChannelPower = 0x00000000;
  UINT8 u8PeakChannelPower = 0x00;
  UINT16 u16Count2 = 0;
  UINT8 u8TempChannelPower = 0x00000000;
  UINT8 u8pChannel = 0;
  UINT8 u8aChannel = 0;
  UINT8 u8MaxpChannelPower = 0x00;
  UINT32 u32MaxaChannelPower = 0x00000000;
  UINT16 u16OldTime = 0;
  UINT16 u16RTXOldTime = 0;
  UINT16 u16NewTime = 0;
  UINT16 u16Count = 0;
  UINT8 u8Toggle = 0;
  UINT8 u8ToCount = 0;
  UINT8 u8AppStatus = 0;
  UINT8 u8LightLed = 0x00;
  UINT8 u8LinkQuality = 0;
  UINT8 u8RetryCount = 0;
  UINT8 u8Dsn = 0xFF;
  UINT8 number=0x00;
  UINT8 u8Flag=0;
  UINT8 i=0x00;
  UINT8 txed=0x00;
  UINT8 u8ED=0x00;
  UINT8 delivernum=0x01;
  UINT8 my[16]={0x07,0x01,0x08,0x02,0x04,0x0a,0x06,0x07,0x0d,0x09,0x0f,0x00,0x0c,0x02,0x0a,0x0f};

  gsTxPacket.u8DataLength = 0;
  gsTxPacket.pu8Data = &gauTxDataBuffer[0];
  gsRxPacket.u8DataLength = 0;
  gsRxPacket.pu8Data = &gauRxDataBuffer[0];
  gsRxPacket.u8MaxDataLength = 30;
  gsRxPacket.u8Status = 0;

  
  /* Begin init */
  MCUInit(); 
  RadioInit();
  
  LED1DIR = 1; /* LED directions */
  LED2DIR = 1;
  LED3DIR = 1;
  LED4DIR = 1;
  
  MLMESetMC13192ClockRate(1); /* 8MHz CLKo, 4MHz bus clock */
  
  /******************************************************************
  To adjust output power call the MLME_MC13192_PA_output_adjust() with:
  
  MAX_POWER     (+3 to +5dBm)
  NOMINAL_POWER (0 dBm)
  MIN_POWER     ~(-16dBm)
  
  or somewhere custom ? (0-15, 11 (NOMINAL_POWER) being Default power)

    ******************************************************************/
    //MLMEMC13192PAOutputAdjust(MAX_POWER);    //Set MAX power setting
  //MLMEMC13192PAOutputAdjust(MIN_POWER);    //Set MIN power setting
  MLMEMC13192PAOutputAdjust(NOMINAL_POWER);    //Set Nominal power setting    


  
  UseExternalClock();
  /* Application init code. */
  SRTISC=SRTISC&~0x07; /* Disable wake up timer. */
  SPMSC2=SPMSC2&~0x03; /* Enable deep sleep mode stop3. */
  TPM1SC = 0x0E; /* Timer divide by 64. (16uS timebase for 4MHz bus clock). */

  PB0PU = 1; /* Pushbutton directions and pull-ups */
  PB0DIR = 0;
  PB1PU = 1;
  PB1DIR = 0;
  PB2PU = 1;
  PB2DIR = 0;
  PB3PU = 1;
  PB3DIR = 0;
  
  


  /* Enable all IRQ sources. Ready to go. */
  MC13192_IRQ_IE_BIT = 1;
  EnableInterrupts;
  
  
  
  /***************************************************************/
  /* Begin App                                                   */
  /***************************************************************/
  /* First time application start-up code. */
  /* All LEDs on for start-up. Indicates controller */
  LED1 = 0;
  LED2 = 0;
  LED3 = 0;
  LED4 = 0;
  /* Allow LEDs to glow for a short. Indicates Controller. */
  MCUDelay(LONGFLASHON);
  /* Test to see if manual u8Channel selection is desired. */
  if ((PB0 ==0) || (PB1 ==0) || (PB2 ==0) || (PB3 ==0))
   /* Set the manual u8Channel. */
  {
    if (PB0 == 0)               
    {
        u8Channel = 1; 
        
    }
    if (PB1 == 0)
    {
        u8Channel = 2;
    }
    if (PB2 == 0)
    {
        u8Channel = 3;
    }
    if (PB3 == 0)
    {
        u8Channel = 4;
    }
  }
  /* Now all LEDs off. */
  LedDrive(u8DeviceLed);
  MCUDelay (LONGFLASHON);
  /* Allow SECURITY LED to glow for a short. Indicates code. */
  LedDrive(SECURITY);
  MCUDelay(LONGFLASHON);
  /* Now all LEDs off. */
  LedDrive(u8DeviceLed);
  MCUDelay (LONGFLASHON);
  if (u8Channel == 0) /* Automatic u8Channel selection. */
  {
    /* All LEDs on for duration of u8Channel scan. */
    LED1 = 0;
    LED2 = 0;
    LED3 = 0;
    LED4 = 0;
    /* u8Channel scan. Choose the cleanest u8Channel. */
    /* u8Channel is mapped as 1=0, 2=5, 3=10, 4=15. */
    for (u8Count1=1; u8Count1<(5); u8Count1++) /* Scan through "u8Channels" 1-4. */
    {
        u8Garbage = (u8Count1-1);
        u8Garbage = ((u8Garbage << 2) + u8Garbage);
        MLMESetChannelRequest(u8Garbage); /* Set actual u8Channel. */
        u32ChannelPower = 0x00000000;
        u8PeakChannelPower = 0xFE;
        for (u16Count2=1; u16Count2<(2049); u16Count2++) /* Average/peak detect the readings over 2048 measurements. */
        {
            u8TempChannelPower = MLMEEnergyDetect();
            if (u8TempChannelPower < u8PeakChannelPower)
            {
                u8PeakChannelPower = u8TempChannelPower; /* Find peak power for the u8Channel */
            }
            u32ChannelPower = u8TempChannelPower + u32ChannelPower; /* Sum the readings. */
        }
        u32ChannelPower = (u32ChannelPower>>11); /* Divide to get the average. */
        if (u8PeakChannelPower > u8MaxpChannelPower)
        {
        u8MaxpChannelPower = u8PeakChannelPower; 
        u8pChannel = u8Count1; /* Weaker peak power on this u8Channel */
        }
        if (u32ChannelPower > u32MaxaChannelPower) /* Pick the u8Channel with the largest (i.e. weakest) reading. */
        {
            u32MaxaChannelPower = u32ChannelPower;
            u8aChannel = u8Count1; /* Weaker average power on this u8Channel */
        }
        
      }
      u8Channel = u8pChannel; /* Final u8Channel can be based on peak or average */
  }
  else /* Manual u8Channel selection. Wait for pushbutton release, then debounce. */
  {
      while ((PB0 ==0) || (PB1 ==0) || (PB2 ==0) || (PB3 ==0)); /* A PB is still depressed */
      MCUDelay(DEBOUNCE); /* All PBs released. Wait for debounce. */
  }
  /* Now all LEDs off. */
  LedDrive(u8DeviceLed);
  MCUDelay(LONGFLASHOFF);
  /* Allow selected u8Channel LED to glow for a short. */
  LedDrive(u8Channel);
  MCUDelay(LONGFLASHON);
  /* Now all LEDs off. Initialization complete. */
  LedDrive(0x00);
  
  
  /**************************************************************
  *    Main Loop, repeated now forever
  **************************************************************/
  for(;;)
  { 
    u8RetryCount=0;
    u8DeviceLed = 0x00; /* LEDs all off */
    u8LightLed = 0x00;
    LedDrive(0x0f);
    u8AppStatus = 0;
    /* Enable keyboard irq. Depressing PB0 will cause a wake up */
    KBI1SC_KBIMOD = 0;
    KBI1SC_KBI1E = 1;
    UseMcuClock(); /* MCU internal clock selected since we'll lose our external clock */
    // MC13192ContReset();  Place the MC13192 into Reset mode 
 //   KBDWAIT() Wait for PB1 to be depressed. Note: requires Rev C GB60 board 
    u8Dsn++; /* increment the data sequence number */
    if (u8Dsn == 0xFF) /* 0xFF is reserved and used at startup only for devices */
    {
        u8Dsn = 0x00;
    }
     RadioInit();
      MLMESetChannelRequest(((u8Channel-1)<<2) + (u8Channel-1)); /* Set the selected u8Channel. */
    MLMESetMC13192ClockRate(1); /* Back to 8MHz CLKo */
    UseExternalClock(); /* Use external accurate clock */
    u16OldTime = MCUReadTmr1();
    u16NewTime = u16OldTime;
    u8ToCount = 0;
    
    /***********************************************************************************/
       
       
            if ((PB0 ==0) ||(PB1 ==0) ||  (PB2 ==0) || (PB3 ==0))
   
             {
               if (PB0 == 0)
                  {  u8AppStatus=4;
                     
                  }
               
               if (PB1 == 0)
                  {
                  u8AppStatus=5;
                  
                  }
               
               if (PB2 == 0)
                  {
                  u8AppStatus=6;
                  
                  }
               if (PB3 == 0)
                  {
                  u8AppStatus=7;
                  }
                LedDrive(u8DeviceLed);
                MCUDelay(DEBOUNCE); 
                while ((PB1 ==0) ||(PB0 ==0) || (PB2 ==0) || (PB3 ==0)); 
                MCUDelay(DEBOUNCE);
                u8RetryCount=0;
             }
         
  if(u8AppStatus==0)                
      //**************channel send to find device,loop every time
  {     //u8Dsn++; /* increment the data sequence number */
    //if (u8Dsn == 0xFF) /* 0xFF is reserved and used at startup only for devices */
    //{
     //   u8Dsn = 0x00;
   // }
   LedDrive(0x06);
   MLMERXEnableRequest(&gsRxPacket, 0x);
   while (gu8RTxMode != IDLE_MODE) // Wait until RX is done */
            {
               LOW_POWER_WHILE(); // Conserve MCU power */
            }
            if ((gsRxPacket.u8Status == SUCCESS)) // Good packet received */
            {
               if ((gauRxDataBuffer[0] == 0xE1)  && (gauRxDataBuffer[2] == SECURITY) && (gauRxDataBuffer[4] == u8Channel)&& (gauRxDataBuffer[7] == channelREQ))
               {
                    u8AppStatus=1;
                    LedDrive(0x09);
               }
            }
  }
  if (u8AppStatus==1)
   {
        u8ED =MLMEEnergyDetect();
        gauTxDataBuffer[0] = 0xE1; 
        gauTxDataBuffer[1] = 0xCC;
        gauTxDataBuffer[2] = SECURITY; 
        gauTxDataBuffer[3] = u8ED; 
        gauTxDataBuffer[4] = u8Channel; 
        gauTxDataBuffer[5] = u8Dsn; 
        gauTxDataBuffer[6] = 0x00; 
        gauTxDataBuffer[7] = channelCMD;
        gsTxPacket.u8DataLength = 8;
        u16NewTime = MCUReadTmr1 ();
        u16RTXOldTime = u16NewTime;
        while ((u16NewTime-u16RTXOldTime) < DWELLTIME) 
        {
            u16NewTime = MCUReadTmr1 ();
        }