ex_zmd.c

PIC单片机从SPI

/////////////////////////////////////////////////////////////////////////
////                              EX_ZMD.C                           ////
////                                                                 ////
//// An 'everything but the kitchen sink' example for the ZMD44102   ////
//// radio.  This example was meant to be run on the CCS Wireless    ////
//// (ZMD) Prototyping Board.                                        ////
////                                                                 ////
//// This example can by dynamically configured, over RS232, to      ////
//// perform any of the following tasks/test: 7 segment LEDs,        ////
//// LEDs, read 802.15.4 packets, write 802.15.4 packets, 802.15.4   ////
//// packet sniffer and an RS232<->802.15.4 link.                    ////
////                                                                 ////
//// If using SIOW or Hyperterminal, press C to configure the unit.  ////
//// Here you can choose the TX strength, addresses, etc.  The last  ////
//// option asks you what you want to display on the 7segment LED.   ////
//// Option 3 will display packet success rate (100-0%), option 1    ////
//// will display packet success rate in tens (which will save you   ////
//// you battery power over option 3), option N will display either  ////
//// the packet count or the last received value.                    ////
////                                                                 ////
//// The unit will save the configuration value and current          ////
//// operational mode to EEPROM, so you can power it down and move   ////
//// it and it will keep its settings (so you can put it into a      ////
//// transmit test, power down the board and move it to a new        ////
//// location, then power it back up and it will continue the        ////
//// transmit test).                                                 ////
////                                                                 ////
/////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2006 Custom Computer Services         ////
//// This source code may only be used by licensed users of the CCS  ////
//// C compiler.  This source code may only be distributed to other  ////
//// licensed users of the CCS C compiler.  No other use,            ////
//// reproduction or distribution is permitted without written       ////
//// permission.  Derivative programs created using this software    ////
//// in object code form are not restricted in any way.              ////
/////////////////////////////////////////////////////////////////////////

#include <18F452.h>
#fuses HS,WDT,WDT128,NOLVP
#use delay(clock=10000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7, errors)

#define BUTTON_PRESSED()  !input(PIN_A4)
#define PIN_LED1  PIN_B4
#define PIN_LED2  PIN_B5
#define PIN_LED3  PIN_A5
#define LED_ON output_low
#define LED_OFF output_high

#define EE_MAGIC     0
#define EE_LAST_MODE 1
#define EE_CHAN      4
#define EE_PAN       5  //size=2
#define EE_MY_ADDR   7  //size=2
#define EE_DEST_ADDR 9  //size=2
#define EE_SHOW_PERCENT 11
#define EE_POWER     12
#define EE_CSMA      13

int8 read_eeprom8(int8 address) {
   return(read_eeprom(address));
}

void write_eeprom8(int8 address, int8 data) {
   write_eeprom(address, data);
}

int16 read_eeprom16(int8 address) {
   union {
      int8 bytes[2];
      int16 val;
   } data;

   data.bytes[0]=read_eeprom8(address++);
   data.bytes[1]=read_eeprom8(address);

   return(data.val);
}

void write_eeprom16(int8 address, int16 data) {
   write_eeprom8(address++, make8(data,0));
   write_eeprom8(address, make8(data,1));
}

#define RS232_BUFFER_SIZE  127
char rs232_buffer[RS232_BUFFER_SIZE];
int8 rs232_nextin=0, rs232_nextout=0;

#int_rda
void isr_rda(void) {
   char c;
   c=getc();
   rs232_buffer[rs232_nextin++]=c;
   if (rs232_nextin >= RS232_BUFFER_SIZE) {rs232_nextin=0;}
}

char bgetc(void) {
   char c;
   while (rs232_nextout==rs232_nextin) {restart_wdt();}
   c=rs232_buffer[rs232_nextout++];
   if (rs232_nextout >= RS232_BUFFER_SIZE) {rs232_nextout=0;}
   return(c);
}

#include <stdlib.h>

void bget_string(char* s, int max) {
   int len;
   char c;

   --max;
   len=0;
   do {
     c=bgetc();
     if(c==8) {  // Backspace
        if(len>0) {
          len--;
          putc(c);
          putc(' ');
          putc(c);
        }
     } else if ((c>=' ')&&(c<='~'))
       if(len<max) {
         s[len++]=c;
         putc(c);
       }
   } while(c!=13);
   s[len]=0;
}

signed int bget_int()
{
  char s[3];
  signed int i;

  bget_string(s, sizeof(s)-1);
  i=atoi(s);
  return(i);
}

signed long bget_long() {
  char s[7];
  signed long l;

  bget_string(s, sizeof(s)-1);
  l=atol(s);
  return(l);
}

#define bkbhit() (rs232_nextin!=rs232_nextout)

#define EXP_OUT_ENABLE  PIN_B2
#define EXP_OUT_CLOCK   PIN_B4
#define EXP_OUT_DO      PIN_B5
#define NUMBER_OF_74595 3
#include <74595.c>

const char digit_format[10]={
//0   1     2     3     4     5     6     7     8     9
0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90
};

void lcd_clear(void) {
   int8 digits[3]={0xFF,0xFF,0xFF};
   write_expanded_outputs(&digits[0]);
   output_low(EXP_OUT_ENABLE);
}

void lcd_putd(int16 num) {
   int8 blank=0;
   int8 digits[3];

   digits[0]=num / 100;
   digits[1]=(num % 100) / 10;
   digits[2]=num % 10;

   if (digits[0])
      digits[0]=digit_format[digits[0]];
   else
   {
      blank=1;
      digits[0]=0xFF;
   }

   if (digits[1] || (blank!=1))
      digits[1]=digit_format[digits[1]];
   else
      digits[1]=0xFF;

   digits[2]=digit_format[digits[2]];

   write_expanded_outputs(&digits[0]);
   output_low(EXP_OUT_ENABLE);
}

#include <zmd44102.h>
#include <zrs232.h>

void zmd_spi_test(void) {
   int16 to=1;

   printf("\r\n\nSPI/PARALLEL TEST (Press space to exit)\r\n\n");

   while(TRUE) {
      restart_wdt();
      to--;
      delay_ms(1);

      if (!to) {
         printf("\rED0: %U     ", zmd_read_reg(ZMD_ED0));
         to=500;
      }

      if (bkbhit()) {
         if (bgetc()==' ')
            return;
      }
   }
}

void zmd_generate_cw(int8 channel, int8 modulated) {
   int8 power;

   power=read_eeprom(EE_POWER);

   if (modulated)
      ZPhy_SetTX(ZPHY_TX_MODE_MODULATED_CARRIER, power);
   else
      ZPhy_SetTX(ZPHY_TX_MODE_CARRIER, power);

   ZMac_SetTX(ZMAC_TX_MODE_DIRECT, ZMAC_TX_SLOTTED_DISABLE);
   ZPhy_SetChannel(channel);
   zmd_set_maccontrol(ZMD_mc_TxOn);

   printf("\r\n(press space to exit)\r\n\n");
   while(TRUE) {
      restart_wdt();
      if (bkbhit()) {
         if (bgetc()==' ') {
            return;
         }
      }
   }

   zmd_set_maccontrol(ZMD_mc_TxRxOff);
   ZMac_SetTX(read_eeprom(EE_CSMA), ZMAC_TX_SLOTTED_DISABLE);
   ZPhy_SetTX(ZPHY_TX_MODE_NORMAL, power);
}

void ZMac_DisplayHeader(ZMAC_HEADER *header)
{
   ZMAC_HEADER hdr;
   int8 mhr2;

   memcpy(&hdr, header, sizeof(ZMAC_HEADER));

   mhr2 = hdr.destNode.addressMode;
   mhr2 |= (hdr.sourceNode.addressMode << 4);

   printf("MHR=%X%X SQ=%X ", (int8)hdr.frameCon, mhr2, hdr.seq);

   if (hdr.frameCon.frameType == ZMAC_FCON_TYPE_DATA)
      printf("DATA ");
   else if (hdr.frameCon.frameType == ZMAC_FCON_TYPE_CMD)
      printf("CMD ");
   else if (hdr.frameCon.frameType == ZMAC_FCON_TYPE_ACK)
   {
      printf("ACK ");
      return;
   }
   else
      printf("BEACON ");

   if (hdr.destNode.addressMode)
   {
      printf("DPAN=%LX DADR=", hdr.destNode.panId.w);
      if (hdr.destNode.addressMode == ZMAC_ADDRESS_MODE_SHORT)
      {
         printf("%LX", hdr.destNode.shortAddress.w);
      }
      else
      {
         printf("%X%X%X%X%X%X%X%X",
         hdr.destNode.longAddress.b[0],
         hdr.destNode.longAddress.b[1],
         hdr.destNode.longAddress.b[2],
         hdr.destNode.longAddress.b[3],
         hdr.destNode.longAddress.b[4],
         hdr.destNode.longAddress.b[5],
         hdr.destNode.longAddress.b[6],
         hdr.destNode.longAddress.b[7]);
      }
      printf(" ");
   }
   if (hdr.sourceNode.addressMode)
   {
      if (!hdr.frameCon.intraPan)
      {
         printf("SPAN=%LX ", hdr.sourceNode.panId.w);
      }
      printf("SADR=");

      if (hdr.destNode.addressMode == ZMAC_ADDRESS_MODE_SHORT)
      {
         printf("%LX", hdr.sourceNode.shortAddress.w);
      }
      else
      {
         printf("%X%X%X%X%X%X%X%X",
         hdr.sourceNode.longAddress.b[0],
         hdr.sourceNode.longAddress.b[1],
         hdr.sourceNode.longAddress.b[2],
         hdr.sourceNode.longAddress.b[3],
         hdr.sourceNode.longAddress.b[4],
         hdr.sourceNode.longAddress.b[5],
         hdr.sourceNode.longAddress.b[6],
         hdr.sourceNode.longAddress.b[7]);
      }
      printf(" ");
   }
}

void packet_sniff(void) {
   int16 count=0;
   int8 len;
   ZMAC_HEADER hdr;

   printf("\r\n\nPacket sniffer CH=%U\r\n(press space to exit)\r\n", ZPhy_GetChannel());

   zmd_storeLQI(TRUE);
   ZMac_StartPromiscous();
   ZMac_StartListen();

   lcd_putd(0);

   while(TRUE) {
      restart_wdt();
      if(bkbhit()) {
         if (bgetc()==' ') break;
      }
      if (ZMac_IsRXReady())
      {
            count++;
            if (count>999) {count=0;}
            lcd_putd(count);

            len=ZMac_GetHeader(&hdr);

            printf("\r\n * ");
            ZMac_DisplayHeader(&hdr);

            printf("DLEN=%U ",len);
            while(len--) {
               printf("%X",ZMac_Getc());
            }

            ZMac_DiscardRX();
            printf(" LQI=%LX", zmd_getLQI());
         }
      }

   ZMac_StopListen();
   ZMac_StopPromiscous();
   zmd_storeLQI(FALSE);
   ZMac_DiscardRXAll();
}

#define GetAbsDiff(a, b)       ( (a < b) ? ((0xffff - b) + a) : (a - b) )

void read_test(void) {
   char showPercent;
   int8 percent;
   int16 bad=0, good=0;
   ZMAC_NODE_INFO remoteNode;
   int16 data,lastdata;
   int1 first=TRUE;
   int8 count;

   showPercent=read_eeprom(EE_SHOW_PERCENT);

   printf("\r\n\nReading Packets CHAN=%U PAN=%LX ME=%LX\r\n",
      ZPhy_GetChannel(),
      ZMac_GetMyPanId(),