diff options
| author | krolyxon <me@krolyxon.com> | 2026-05-14 23:01:07 +0530 |
|---|---|---|
| committer | krolyxon <me@krolyxon.com> | 2026-05-14 23:01:07 +0530 |
| commit | 0b8b30d25d9e374cb8814aa652d52d5b74d5171a (patch) | |
| tree | 67083979c079ec047f1ac49fb15ce73712de6546 /test/ELECHOUSE_CC1101_SRC_DRV.cpp | |
| parent | 45d23ef49d3dd6c7ac6547187dde788d536d88c6 (diff) | |
remove test files
Diffstat (limited to 'test/ELECHOUSE_CC1101_SRC_DRV.cpp')
| -rw-r--r-- | test/ELECHOUSE_CC1101_SRC_DRV.cpp | 1309 |
1 files changed, 0 insertions, 1309 deletions
diff --git a/test/ELECHOUSE_CC1101_SRC_DRV.cpp b/test/ELECHOUSE_CC1101_SRC_DRV.cpp deleted file mode 100644 index 5568989..0000000 --- a/test/ELECHOUSE_CC1101_SRC_DRV.cpp +++ /dev/null @@ -1,1309 +0,0 @@ -/*
- ELECHOUSE_CC1101.cpp - CC1101 module library
- Copyright (c) 2010 Michael.
- Author: Michael, <www.elechouse.com>
- Version: November 12, 2010
-
- This library is designed to use CC1101/CC1100 module on Arduino platform.
- CC1101/CC1100 module is an useful wireless module.Using the functions of the
- library, you can easily send and receive data by the CC1101/CC1100 module.
- Just have fun!
- For the details, please refer to the datasheet of CC1100/CC1101.
-----------------------------------------------------------------------------------------------------------------
-cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and publish Wilson Shen (ELECHOUSE).
-----------------------------------------------------------------------------------------------------------------
-*/
-#include <SPI.h>
-#include "ELECHOUSE_CC1101_SRC_DRV.h"
-#include <Arduino.h>
-
-/****************************************************************/
-#define WRITE_BURST 0x40 //write burst
-#define READ_SINGLE 0x80 //read single
-#define READ_BURST 0xC0 //read burst
-#define BYTES_IN_RXFIFO 0x7F //byte number in RXfifo
-#define max_modul 6
-
-SPIClass CCSPI(HSPI);
-
-byte modulation = 2;
-byte frend0;
-byte chan = 0;
-int pa = 12;
-byte last_pa;
-byte SCK_PIN;
-byte MISO_PIN;
-byte MOSI_PIN;
-byte SS_PIN;
-byte GDO0;
-byte GDO2;
-byte SCK_PIN_M[max_modul];
-byte MISO_PIN_M[max_modul];
-byte MOSI_PIN_M[max_modul];
-byte SS_PIN_M[max_modul];
-byte GDO0_M[max_modul];
-byte GDO2_M[max_modul];
-byte gdo_set=0;
-bool spi = 0;
-bool ccmode = 0;
-float MHz = 433.92;
-byte m4RxBw = 0;
-byte m4DaRa;
-byte m2DCOFF;
-byte m2MODFM;
-byte m2MANCH;
-byte m2SYNCM;
-byte m1FEC;
-byte m1PRE;
-byte m1CHSP;
-byte pc1PQT;
-byte pc1CRC_AF;
-byte pc1APP_ST;
-byte pc1ADRCHK;
-byte pc0WDATA;
-byte pc0PktForm;
-byte pc0CRC_EN;
-byte pc0LenConf;
-byte trxstate = 0;
-byte clb1[2]= {24,28};
-byte clb2[2]= {31,38};
-byte clb3[2]= {65,76};
-byte clb4[2]= {77,79};
-
-/****************************************************************/
-uint8_t PA_TABLE[8] {0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00};
-// -30 -20 -15 -10 0 5 7 10
-uint8_t PA_TABLE_315[8] {0x12,0x0D,0x1C,0x34,0x51,0x85,0xCB,0xC2,}; //300 - 348
-uint8_t PA_TABLE_433[8] {0x12,0x0E,0x1D,0x34,0x60,0x84,0xC8,0xC0,}; //387 - 464
-// -30 -20 -15 -10 -6 0 5 7 10 12
-uint8_t PA_TABLE_868[10] {0x03,0x17,0x1D,0x26,0x37,0x50,0x86,0xCD,0xC5,0xC0,}; //779 - 899.99
-// -30 -20 -15 -10 -6 0 5 7 10 11
-uint8_t PA_TABLE_915[10] {0x03,0x0E,0x1E,0x27,0x38,0x8E,0x84,0xCC,0xC3,0xC0,}; //900 - 928
-/****************************************************************
-*FUNCTION NAME:SpiStart
-*FUNCTION :spi communication start
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SpiStart(void)
-{
- // initialize the SPI pins
- pinMode(SCK_PIN, OUTPUT);
- pinMode(MOSI_PIN, OUTPUT);
- pinMode(MISO_PIN, INPUT);
- pinMode(SS_PIN, OUTPUT);
-
- // enable SPI
- #ifdef ESP32
- CCSPI.begin(SCK_PIN, MISO_PIN, MOSI_PIN, SS_PIN);
- #else
- CCSPI.begin();
- #endif
-}
-/****************************************************************
-*FUNCTION NAME:SpiEnd
-*FUNCTION :spi communication disable
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SpiEnd(void)
-{
- // disable SPI
- CCSPI.endTransaction();
- CCSPI.end();
-}
-/****************************************************************
-*FUNCTION NAME: GDO_Set()
-*FUNCTION : set GDO0,GDO2 pin for serial pinmode.
-*INPUT : none
-*OUTPUT : none
-****************************************************************/
-void ELECHOUSE_CC1101::GDO_Set (void)
-{
- pinMode(GDO0, OUTPUT);
- pinMode(GDO2, INPUT);
-}
-/****************************************************************
-*FUNCTION NAME: GDO_Set()
-*FUNCTION : set GDO0 for internal transmission mode.
-*INPUT : none
-*OUTPUT : none
-****************************************************************/
-void ELECHOUSE_CC1101::GDO0_Set (void)
-{
- pinMode(GDO0, INPUT);
-}
-/****************************************************************
-*FUNCTION NAME:Reset
-*FUNCTION :CC1101 reset //details refer datasheet of CC1101/CC1100//
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::Reset (void)
-{
- digitalWrite(SS_PIN, LOW);
- delay(1);
- digitalWrite(SS_PIN, HIGH);
- delay(1);
- digitalWrite(SS_PIN, LOW);
- while(digitalRead(MISO_PIN));
- CCSPI.transfer(CC1101_SRES);
- while(digitalRead(MISO_PIN));
- digitalWrite(SS_PIN, HIGH);
-}
-/****************************************************************
-*FUNCTION NAME:Init
-*FUNCTION :CC1101 initialization
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::Init(void)
-{
- setSpi();
- SpiStart(); //spi initialization
- digitalWrite(SS_PIN, HIGH);
- digitalWrite(SCK_PIN, HIGH);
- digitalWrite(MOSI_PIN, LOW);
- Reset(); //CC1101 reset
- RegConfigSettings(); //CC1101 register config
- SpiEnd();
-}
-/****************************************************************
-*FUNCTION NAME:SpiWriteReg
-*FUNCTION :CC1101 write data to register
-*INPUT :addr: register address; value: register value
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SpiWriteReg(byte addr, byte value)
-{
- SpiStart();
- digitalWrite(SS_PIN, LOW);
- while(digitalRead(MISO_PIN));
- CCSPI.transfer(addr);
- CCSPI.transfer(value);
- digitalWrite(SS_PIN, HIGH);
- SpiEnd();
-}
-/****************************************************************
-*FUNCTION NAME:SpiWriteBurstReg
-*FUNCTION :CC1101 write burst data to register
-*INPUT :addr: register address; buffer:register value array; num:number to write
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SpiWriteBurstReg(byte addr, byte *buffer, byte num)
-{
- byte i, temp;
- SpiStart();
- temp = addr | WRITE_BURST;
- digitalWrite(SS_PIN, LOW);
- while(digitalRead(MISO_PIN));
- CCSPI.transfer(temp);
- for (i = 0; i < num; i++)
- {
- CCSPI.transfer(buffer[i]);
- }
- digitalWrite(SS_PIN, HIGH);
- SpiEnd();
-}
-/****************************************************************
-*FUNCTION NAME:SpiStrobe
-*FUNCTION :CC1101 Strobe
-*INPUT :strobe: command; //refer define in CC1101.h//
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SpiStrobe(byte strobe)
-{
- SpiStart();
- digitalWrite(SS_PIN, LOW);
- while(digitalRead(MISO_PIN));
- CCSPI.transfer(strobe);
- digitalWrite(SS_PIN, HIGH);
- SpiEnd();
-}
-/****************************************************************
-*FUNCTION NAME:SpiReadReg
-*FUNCTION :CC1101 read data from register
-*INPUT :addr: register address
-*OUTPUT :register value
-****************************************************************/
-byte ELECHOUSE_CC1101::SpiReadReg(byte addr)
-{
- byte temp, value;
- SpiStart();
- temp = addr| READ_SINGLE;
- digitalWrite(SS_PIN, LOW);
- while(digitalRead(MISO_PIN));
- CCSPI.transfer(temp);
- value=CCSPI.transfer(0);
- digitalWrite(SS_PIN, HIGH);
- SpiEnd();
- return value;
-}
-
-/****************************************************************
-*FUNCTION NAME:SpiReadBurstReg
-*FUNCTION :CC1101 read burst data from register
-*INPUT :addr: register address; buffer:array to store register value; num: number to read
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SpiReadBurstReg(byte addr, byte *buffer, byte num)
-{
- byte i,temp;
- SpiStart();
- temp = addr | READ_BURST;
- digitalWrite(SS_PIN, LOW);
- while(digitalRead(MISO_PIN));
- CCSPI.transfer(temp);
- for(i=0;i<num;i++)
- {
- buffer[i]=CCSPI.transfer(0);
- }
- digitalWrite(SS_PIN, HIGH);
- SpiEnd();
-}
-
-/****************************************************************
-*FUNCTION NAME:SpiReadStatus
-*FUNCTION :CC1101 read status register
-*INPUT :addr: register address
-*OUTPUT :status value
-****************************************************************/
-byte ELECHOUSE_CC1101::SpiReadStatus(byte addr)
-{
- byte value,temp;
- SpiStart();
- temp = addr | READ_BURST;
- digitalWrite(SS_PIN, LOW);
- while(digitalRead(MISO_PIN));
- CCSPI.transfer(temp);
- value=CCSPI.transfer(0);
- digitalWrite(SS_PIN, HIGH);
- SpiEnd();
- return value;
-}
-/****************************************************************
-*FUNCTION NAME:SPI pin Settings
-*FUNCTION :Set Spi pins
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setSpi(void){
- if (spi == 0){
- #if defined __AVR_ATmega168__ || defined __AVR_ATmega328P__
- SCK_PIN = 13; MISO_PIN = 12; MOSI_PIN = 11; SS_PIN = 10;
- #elif defined __AVR_ATmega1280__ || defined __AVR_ATmega2560__
- SCK_PIN = 52; MISO_PIN = 50; MOSI_PIN = 51; SS_PIN = 53;
- #elif ESP8266
- SCK_PIN = 14; MISO_PIN = 12; MOSI_PIN = 13; SS_PIN = 15;
- #elif ESP32
- SCK_PIN = 18; MISO_PIN = 19; MOSI_PIN = 23; SS_PIN = 5;
- #else
- SCK_PIN = 13; MISO_PIN = 12; MOSI_PIN = 11; SS_PIN = 10;
- #endif
-}
-}
-/****************************************************************
-*FUNCTION NAME:COSTUM SPI
-*FUNCTION :set costum spi pins.
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setSpiPin(byte sck, byte miso, byte mosi, byte ss){
- spi = 1;
- SCK_PIN = sck;
- MISO_PIN = miso;
- MOSI_PIN = mosi;
- SS_PIN = ss;
-}
-/****************************************************************
-*FUNCTION NAME:COSTUM SPI
-*FUNCTION :set costum spi pins.
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::addSpiPin(byte sck, byte miso, byte mosi, byte ss, byte modul){
- spi = 1;
- SCK_PIN_M[modul] = sck;
- MISO_PIN_M[modul] = miso;
- MOSI_PIN_M[modul] = mosi;
- SS_PIN_M[modul] = ss;
-}
-/****************************************************************
-*FUNCTION NAME:GDO Pin settings
-*FUNCTION :set GDO Pins
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setGDO(byte gdo0, byte gdo2){
-GDO0 = gdo0;
-GDO2 = gdo2;
-GDO_Set();
-}
-/****************************************************************
-*FUNCTION NAME:GDO0 Pin setting
-*FUNCTION :set GDO0 Pin
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setGDO0(byte gdo0){
-GDO0 = gdo0;
-GDO0_Set();
-}
-/****************************************************************
-*FUNCTION NAME:GDO Pin settings
-*FUNCTION :add GDO Pins
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::addGDO(byte gdo0, byte gdo2, byte modul){
-GDO0_M[modul] = gdo0;
-GDO2_M[modul] = gdo2;
-gdo_set=2;
-GDO_Set();
-}
-/****************************************************************
-*FUNCTION NAME:add GDO0 Pin
-*FUNCTION :add GDO0 Pin
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::addGDO0(byte gdo0, byte modul){
-GDO0_M[modul] = gdo0;
-gdo_set=1;
-GDO0_Set();
-}
-/****************************************************************
-*FUNCTION NAME:set Modul
-*FUNCTION :change modul
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setModul(byte modul){
- SCK_PIN = SCK_PIN_M[modul];
- MISO_PIN = MISO_PIN_M[modul];
- MOSI_PIN = MOSI_PIN_M[modul];
- SS_PIN = SS_PIN_M[modul];
- if (gdo_set==1){
- GDO0 = GDO0_M[modul];
- }
- else if (gdo_set==2){
- GDO0 = GDO0_M[modul];
- GDO2 = GDO2_M[modul];
- }
-}
-/****************************************************************
-*FUNCTION NAME:CCMode
-*FUNCTION :Format of RX and TX data
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setCCMode(bool s){
-ccmode = s;
-if (ccmode == 1){
-SpiWriteReg(CC1101_IOCFG2, 0x0B);
-SpiWriteReg(CC1101_IOCFG0, 0x06);
-SpiWriteReg(CC1101_PKTCTRL0, 0x05);
-SpiWriteReg(CC1101_MDMCFG3, 0xF8);
-SpiWriteReg(CC1101_MDMCFG4,11+m4RxBw);
-}else{
-SpiWriteReg(CC1101_IOCFG2, 0x0D);
-SpiWriteReg(CC1101_IOCFG0, 0x0D);
-SpiWriteReg(CC1101_PKTCTRL0, 0x32);
-SpiWriteReg(CC1101_MDMCFG3, 0x93);
-SpiWriteReg(CC1101_MDMCFG4, 7+m4RxBw);
-}
-setModulation(modulation);
-}
-/****************************************************************
-*FUNCTION NAME:Modulation
-*FUNCTION :set CC1101 Modulation
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setModulation(byte m){
-if (m>4){m=4;}
-modulation = m;
-Split_MDMCFG2();
-switch (m)
-{
-case 0: m2MODFM=0x00; frend0=0x10; break; // 2-FSK
-case 1: m2MODFM=0x10; frend0=0x10; break; // GFSK
-case 2: m2MODFM=0x30; frend0=0x11; break; // ASK
-case 3: m2MODFM=0x40; frend0=0x10; break; // 4-FSK
-case 4: m2MODFM=0x70; frend0=0x10; break; // MSK
-}
-SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);
-SpiWriteReg(CC1101_FREND0, frend0);
-setPA(pa);
-}
-/****************************************************************
-*FUNCTION NAME:PA Power
-*FUNCTION :set CC1101 PA Power
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setPA(int p)
-{
-int a;
-pa = p;
-
-if (MHz >= 300 && MHz <= 348){
-if (pa <= -30){a = PA_TABLE_315[0];}
-else if (pa > -30 && pa <= -20){a = PA_TABLE_315[1];}
-else if (pa > -20 && pa <= -15){a = PA_TABLE_315[2];}
-else if (pa > -15 && pa <= -10){a = PA_TABLE_315[3];}
-else if (pa > -10 && pa <= 0){a = PA_TABLE_315[4];}
-else if (pa > 0 && pa <= 5){a = PA_TABLE_315[5];}
-else if (pa > 5 && pa <= 7){a = PA_TABLE_315[6];}
-else if (pa > 7){a = PA_TABLE_315[7];}
-last_pa = 1;
-}
-else if (MHz >= 378 && MHz <= 464){
-if (pa <= -30){a = PA_TABLE_433[0];}
-else if (pa > -30 && pa <= -20){a = PA_TABLE_433[1];}
-else if (pa > -20 && pa <= -15){a = PA_TABLE_433[2];}
-else if (pa > -15 && pa <= -10){a = PA_TABLE_433[3];}
-else if (pa > -10 && pa <= 0){a = PA_TABLE_433[4];}
-else if (pa > 0 && pa <= 5){a = PA_TABLE_433[5];}
-else if (pa > 5 && pa <= 7){a = PA_TABLE_433[6];}
-else if (pa > 7){a = PA_TABLE_433[7];}
-last_pa = 2;
-}
-else if (MHz >= 779 && MHz <= 899.99){
-if (pa <= -30){a = PA_TABLE_868[0];}
-else if (pa > -30 && pa <= -20){a = PA_TABLE_868[1];}
-else if (pa > -20 && pa <= -15){a = PA_TABLE_868[2];}
-else if (pa > -15 && pa <= -10){a = PA_TABLE_868[3];}
-else if (pa > -10 && pa <= -6){a = PA_TABLE_868[4];}
-else if (pa > -6 && pa <= 0){a = PA_TABLE_868[5];}
-else if (pa > 0 && pa <= 5){a = PA_TABLE_868[6];}
-else if (pa > 5 && pa <= 7){a = PA_TABLE_868[7];}
-else if (pa > 7 && pa <= 10){a = PA_TABLE_868[8];}
-else if (pa > 10){a = PA_TABLE_868[9];}
-last_pa = 3;
-}
-else if (MHz >= 900 && MHz <= 928){
-if (pa <= -30){a = PA_TABLE_915[0];}
-else if (pa > -30 && pa <= -20){a = PA_TABLE_915[1];}
-else if (pa > -20 && pa <= -15){a = PA_TABLE_915[2];}
-else if (pa > -15 && pa <= -10){a = PA_TABLE_915[3];}
-else if (pa > -10 && pa <= -6){a = PA_TABLE_915[4];}
-else if (pa > -6 && pa <= 0){a = PA_TABLE_915[5];}
-else if (pa > 0 && pa <= 5){a = PA_TABLE_915[6];}
-else if (pa > 5 && pa <= 7){a = PA_TABLE_915[7];}
-else if (pa > 7 && pa <= 10){a = PA_TABLE_915[8];}
-else if (pa > 10){a = PA_TABLE_915[9];}
-last_pa = 4;
-}
-if (modulation == 2){
-PA_TABLE[0] = 0;
-PA_TABLE[1] = a;
-}else{
-PA_TABLE[0] = a;
-PA_TABLE[1] = 0;
-}
-SpiWriteBurstReg(CC1101_PATABLE,PA_TABLE,8);
-}
-/****************************************************************
-*FUNCTION NAME:Frequency Calculator
-*FUNCTION :Calculate the basic frequency.
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setMHZ(float mhz){
-byte freq2 = 0;
-byte freq1 = 0;
-byte freq0 = 0;
-
-MHz = mhz;
-
-for (bool i = 0; i==0;){
-if (mhz >= 26){
-mhz-=26;
-freq2+=1;
-}
-else if (mhz >= 0.1015625){
-mhz-=0.1015625;
-freq1+=1;
-}
-else if (mhz >= 0.00039675){
-mhz-=0.00039675;
-freq0+=1;
-}
-else{i=1;}
-}
-if (freq0 > 255){freq1+=1;freq0-=256;}
-
-SpiWriteReg(CC1101_FREQ2, freq2);
-SpiWriteReg(CC1101_FREQ1, freq1);
-SpiWriteReg(CC1101_FREQ0, freq0);
-
-Calibrate();
-}
-/****************************************************************
-*FUNCTION NAME:Calibrate
-*FUNCTION :Calibrate frequency
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::Calibrate(void){
-
-if (MHz >= 300 && MHz <= 348){
-SpiWriteReg(CC1101_FSCTRL0, map(MHz, 300, 348, clb1[0], clb1[1]));
-if (MHz < 322.88){SpiWriteReg(CC1101_TEST0,0x0B);}
-else{
-SpiWriteReg(CC1101_TEST0,0x09);
-int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);
-if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}
-if (last_pa != 1){setPA(pa);}
-}
-}
-else if (MHz >= 378 && MHz <= 464){
-SpiWriteReg(CC1101_FSCTRL0, map(MHz, 378, 464, clb2[0], clb2[1]));
-if (MHz < 430.5){SpiWriteReg(CC1101_TEST0,0x0B);}
-else{
-SpiWriteReg(CC1101_TEST0,0x09);
-int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);
-if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}
-if (last_pa != 2){setPA(pa);}
-}
-}
-else if (MHz >= 779 && MHz <= 899.99){
-SpiWriteReg(CC1101_FSCTRL0, map(MHz, 779, 899, clb3[0], clb3[1]));
-if (MHz < 861){SpiWriteReg(CC1101_TEST0,0x0B);}
-else{
-SpiWriteReg(CC1101_TEST0,0x09);
-int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);
-if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}
-if (last_pa != 3){setPA(pa);}
-}
-}
-else if (MHz >= 900 && MHz <= 928){
-SpiWriteReg(CC1101_FSCTRL0, map(MHz, 900, 928, clb4[0], clb4[1]));
-SpiWriteReg(CC1101_TEST0,0x09);
-int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);
-if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}
-if (last_pa != 4){setPA(pa);}
-}
-}
-/****************************************************************
-*FUNCTION NAME:Calibration offset
-*FUNCTION :Set calibration offset
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setClb(byte b, byte s, byte e){
-if (b == 1){
-clb1[0]=s;
-clb1[1]=e;
-}
-else if (b == 2){
-clb2[0]=s;
-clb2[1]=e;
-}
-else if (b == 3){
-clb3[0]=s;
-clb3[1]=e;
-}
-else if (b == 4){
-clb4[0]=s;
-clb4[1]=e;
-}
-}
-/****************************************************************
-*FUNCTION NAME:getCC1101
-*FUNCTION :Test Spi connection and return 1 when true.
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-bool ELECHOUSE_CC1101::getCC1101(void){
-setSpi();
-if (SpiReadStatus(0x31)>0){
-return 1;
-}else{
-return 0;
-}
-}
-/****************************************************************
-*FUNCTION NAME:getMode
-*FUNCTION :Return the Mode. Sidle = 0, TX = 1, Rx = 2.
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-byte ELECHOUSE_CC1101::getMode(void){
-return trxstate;
-}
-/****************************************************************
-*FUNCTION NAME:Set Sync_Word
-*FUNCTION :Sync Word
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setSyncWord(byte sh, byte sl){
-SpiWriteReg(CC1101_SYNC1, sh);
-SpiWriteReg(CC1101_SYNC0, sl);
-}
-/****************************************************************
-*FUNCTION NAME:Set ADDR
-*FUNCTION :Address used for packet filtration. Optional broadcast addresses are 0 (0x00) and 255 (0xFF).
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setAddr(byte v){
-SpiWriteReg(CC1101_ADDR, v);
-}
-/****************************************************************
-*FUNCTION NAME:Set PQT
-*FUNCTION :Preamble quality estimator threshold
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setPQT(byte v){
-Split_PKTCTRL1();
-pc1PQT = 0;
-if (v>7){v=7;}
-pc1PQT = v*32;
-SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);
-}
-/****************************************************************
-*FUNCTION NAME:Set CRC_AUTOFLUSH
-*FUNCTION :Enable automatic flush of RX FIFO when CRC is not OK
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setCRC_AF(bool v){
-Split_PKTCTRL1();
-pc1CRC_AF = 0;
-if (v==1){pc1CRC_AF=8;}
-SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);
-}
-/****************************************************************
-*FUNCTION NAME:Set APPEND_STATUS
-*FUNCTION :When enabled, two status bytes will be appended to the payload of the packet
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setAppendStatus(bool v){
-Split_PKTCTRL1();
-pc1APP_ST = 0;
-if (v==1){pc1APP_ST=4;}
-SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);
-}
-/****************************************************************
-*FUNCTION NAME:Set ADR_CHK
-*FUNCTION :Controls address check configuration of received packages
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setAdrChk(byte v){
-Split_PKTCTRL1();
-pc1ADRCHK = 0;
-if (v>3){v=3;}
-pc1ADRCHK = v;
-SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);
-}
-/****************************************************************
-*FUNCTION NAME:Set WHITE_DATA
-*FUNCTION :Turn data whitening on / off.
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setWhiteData(bool v){
-Split_PKTCTRL0();
-pc0WDATA = 0;
-if (v == 1){pc0WDATA=64;}
-SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);
-}
-/****************************************************************
-*FUNCTION NAME:Set PKT_FORMAT
-*FUNCTION :Format of RX and TX data
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setPktFormat(byte v){
-Split_PKTCTRL0();
-pc0PktForm = 0;
-if (v>3){v=3;}
-pc0PktForm = v*16;
-SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);
-}
-/****************************************************************
-*FUNCTION NAME:Set CRC
-*FUNCTION :CRC calculation in TX and CRC check in RX
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setCrc(bool v){
-Split_PKTCTRL0();
-pc0CRC_EN = 0;
-if (v==1){pc0CRC_EN=4;}
-SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);
-}
-/****************************************************************
-*FUNCTION NAME:Set LENGTH_CONFIG
-*FUNCTION :Configure the packet length
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setLengthConfig(byte v){
-Split_PKTCTRL0();
-pc0LenConf = 0;
-if (v>3){v=3;}
-pc0LenConf = v;
-SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);
-}
-/****************************************************************
-*FUNCTION NAME:Set PACKET_LENGTH
-*FUNCTION :Indicates the packet length
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setPacketLength(byte v){
-SpiWriteReg(CC1101_PKTLEN, v);
-}
-/****************************************************************
-*FUNCTION NAME:Set DCFILT_OFF
-*FUNCTION :Disable digital DC blocking filter before demodulator
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setDcFilterOff(bool v){
-Split_MDMCFG2();
-m2DCOFF = 0;
-if (v==1){m2DCOFF=128;}
-SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);
-}
-/****************************************************************
-*FUNCTION NAME:Set MANCHESTER
-*FUNCTION :Enables Manchester encoding/decoding
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setManchester(bool v){
-Split_MDMCFG2();
-m2MANCH = 0;
-if (v==1){m2MANCH=8;}
-SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);
-}
-/****************************************************************
-*FUNCTION NAME:Set SYNC_MODE
-*FUNCTION :Combined sync-word qualifier mode
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setSyncMode(byte v){
-Split_MDMCFG2();
-m2SYNCM = 0;
-if (v>7){v=7;}
-m2SYNCM=v;
-SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);
-}
-/****************************************************************
-*FUNCTION NAME:Set FEC
-*FUNCTION :Enable Forward Error Correction (FEC)
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setFEC(bool v){
-Split_MDMCFG1();
-m1FEC=0;
-if (v==1){m1FEC=128;}
-SpiWriteReg(CC1101_MDMCFG1, m1FEC+m1PRE+m1CHSP);
-}
-/****************************************************************
-*FUNCTION NAME:Set PRE
-*FUNCTION :Sets the minimum number of preamble bytes to be transmitted.
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setPRE(byte v){
-Split_MDMCFG1();
-m1PRE=0;
-if (v>7){v=7;}
-m1PRE = v*16;
-SpiWriteReg(CC1101_MDMCFG1, m1FEC+m1PRE+m1CHSP);
-}
-/****************************************************************
-*FUNCTION NAME:Set Channel
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setChannel(byte ch){
-chan = ch;
-SpiWriteReg(CC1101_CHANNR, chan);
-}
-/****************************************************************
-*FUNCTION NAME:Set Channel spacing
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setChsp(float f){
-Split_MDMCFG1();
-byte MDMCFG0 = 0;
-m1CHSP = 0;
-if (f > 405.456543){f = 405.456543;}
-if (f < 25.390625){f = 25.390625;}
-for (int i = 0; i<5; i++){
-if (f <= 50.682068){
-f -= 25.390625;
-f /= 0.0991825;
-MDMCFG0 = f;
-float s1 = (f - MDMCFG0) *10;
-if (s1 >= 5){MDMCFG0++;}
-i = 5;
-}else{
-m1CHSP++;
-f/=2;
-}
-}
-SpiWriteReg(19,m1CHSP+m1FEC+m1PRE);
-SpiWriteReg(20,MDMCFG0);
-}
-/****************************************************************
-*FUNCTION NAME:Set Receive bandwidth
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setRxBW(float f){
-Split_MDMCFG4();
-int s1 = 3;
-int s2 = 3;
-for (int i = 0; i<3; i++){
-if (f > 101.5625){f/=2; s1--;}
-else{i=3;}
-}
-for (int i = 0; i<3; i++){
-if (f > 58.1){f/=1.25; s2--;}
-else{i=3;}
-}
-s1 *= 64;
-s2 *= 16;
-m4RxBw = s1 + s2;
-SpiWriteReg(16,m4RxBw+m4DaRa);
-}
-/****************************************************************
-*FUNCTION NAME:Set Data Rate
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setDRate(float d){
-Split_MDMCFG4();
-float c = d;
-byte MDMCFG3 = 0;
-if (c > 1621.83){c = 1621.83;}
-if (c < 0.0247955){c = 0.0247955;}
-m4DaRa = 0;
-for (int i = 0; i<20; i++){
-if (c <= 0.0494942){
-c = c - 0.0247955;
-c = c / 0.00009685;
-MDMCFG3 = c;
-float s1 = (c - MDMCFG3) *10;
-if (s1 >= 5){MDMCFG3++;}
-i = 20;
-}else{
-m4DaRa++;
-c = c/2;
-}
-}
-SpiWriteReg(16, m4RxBw+m4DaRa);
-SpiWriteReg(17, MDMCFG3);
-}
-/****************************************************************
-*FUNCTION NAME:Set Devitation
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setDeviation(float d){
-float f = 1.586914;
-float v = 0.19836425;
-int c = 0;
-if (d > 380.859375){d = 380.859375;}
-if (d < 1.586914){d = 1.586914;}
-for (int i = 0; i<255; i++){
-f+=v;
-if (c==7){v*=2;c=-1;i+=8;}
-if (f>=d){c=i;i=255;}
-c++;
-}
-SpiWriteReg(21,c);
-}
-/****************************************************************
-*FUNCTION NAME:Split PKTCTRL0
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::Split_PKTCTRL1(void){
-int calc = SpiReadStatus(7);
-pc1PQT = 0;
-pc1CRC_AF = 0;
-pc1APP_ST = 0;
-pc1ADRCHK = 0;
-for (bool i = 0; i==0;){
-if (calc >= 32){calc-=32; pc1PQT+=32;}
-else if (calc >= 8){calc-=8; pc1CRC_AF+=8;}
-else if (calc >= 4){calc-=4; pc1APP_ST+=4;}
-else {pc1ADRCHK = calc; i=1;}
-}
-}
-/****************************************************************
-*FUNCTION NAME:Split PKTCTRL0
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::Split_PKTCTRL0(void){
-int calc = SpiReadStatus(8);
-pc0WDATA = 0;
-pc0PktForm = 0;
-pc0CRC_EN = 0;
-pc0LenConf = 0;
-for (bool i = 0; i==0;){
-if (calc >= 64){calc-=64; pc0WDATA+=64;}
-else if (calc >= 16){calc-=16; pc0PktForm+=16;}
-else if (calc >= 4){calc-=4; pc0CRC_EN+=4;}
-else {pc0LenConf = calc; i=1;}
-}
-}
-/****************************************************************
-*FUNCTION NAME:Split MDMCFG1
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::Split_MDMCFG1(void){
-int calc = SpiReadStatus(19);
-m1FEC = 0;
-m1PRE = 0;
-m1CHSP = 0;
-int s2 = 0;
-for (bool i = 0; i==0;){
-if (calc >= 128){calc-=128; m1FEC+=128;}
-else if (calc >= 16){calc-=16; m1PRE+=16;}
-else {m1CHSP = calc; i=1;}
-}
-}
-/****************************************************************
-*FUNCTION NAME:Split MDMCFG2
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::Split_MDMCFG2(void){
-int calc = SpiReadStatus(18);
-m2DCOFF = 0;
-m2MODFM = 0;
-m2MANCH = 0;
-m2SYNCM = 0;
-for (bool i = 0; i==0;){
-if (calc >= 128){calc-=128; m2DCOFF+=128;}
-else if (calc >= 16){calc-=16; m2MODFM+=16;}
-else if (calc >= 8){calc-=8; m2MANCH+=8;}
-else{m2SYNCM = calc; i=1;}
-}
-}
-/****************************************************************
-*FUNCTION NAME:Split MDMCFG4
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::Split_MDMCFG4(void){
-int calc = SpiReadStatus(16);
-m4RxBw = 0;
-m4DaRa = 0;
-for (bool i = 0; i==0;){
-if (calc >= 64){calc-=64; m4RxBw+=64;}
-else if (calc >= 16){calc -= 16; m4RxBw+=16;}
-else{m4DaRa = calc; i=1;}
-}
-}
-/****************************************************************
-*FUNCTION NAME:RegConfigSettings
-*FUNCTION :CC1101 register config //details refer datasheet of CC1101/CC1100//
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::RegConfigSettings(void)
-{
- SpiWriteReg(CC1101_FSCTRL1, 0x06);
-
- setCCMode(ccmode);
- setMHZ(MHz);
-
- SpiWriteReg(CC1101_MDMCFG1, 0x02);
- SpiWriteReg(CC1101_MDMCFG0, 0xF8);
- SpiWriteReg(CC1101_CHANNR, chan);
- SpiWriteReg(CC1101_DEVIATN, 0x47);
- SpiWriteReg(CC1101_FREND1, 0x56);
- SpiWriteReg(CC1101_MCSM0 , 0x18);
- SpiWriteReg(CC1101_FOCCFG, 0x16);
- SpiWriteReg(CC1101_BSCFG, 0x1C);
- SpiWriteReg(CC1101_AGCCTRL2, 0xC7);
- SpiWriteReg(CC1101_AGCCTRL1, 0x00);
- SpiWriteReg(CC1101_AGCCTRL0, 0xB2);
- SpiWriteReg(CC1101_FSCAL3, 0xE9);
- SpiWriteReg(CC1101_FSCAL2, 0x2A);
- SpiWriteReg(CC1101_FSCAL1, 0x00);
- SpiWriteReg(CC1101_FSCAL0, 0x1F);
- SpiWriteReg(CC1101_FSTEST, 0x59);
- SpiWriteReg(CC1101_TEST2, 0x81);
- SpiWriteReg(CC1101_TEST1, 0x35);
- SpiWriteReg(CC1101_TEST0, 0x09);
- SpiWriteReg(CC1101_PKTCTRL1, 0x04);
- SpiWriteReg(CC1101_ADDR, 0x00);
- SpiWriteReg(CC1101_PKTLEN, 0x00);
-}
-/****************************************************************
-*FUNCTION NAME:SetTx
-*FUNCTION :set CC1101 send data
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SetTx(void)
-{
- SpiStrobe(CC1101_SIDLE);
- SpiStrobe(CC1101_STX); //start send
- trxstate=1;
-}
-/****************************************************************
-*FUNCTION NAME:SetRx
-*FUNCTION :set CC1101 to receive state
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SetRx(void)
-{
- SpiStrobe(CC1101_SIDLE);
- SpiStrobe(CC1101_SRX); //start receive
- trxstate=2;
-}
-/****************************************************************
-*FUNCTION NAME:SetTx
-*FUNCTION :set CC1101 send data and change frequency
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SetTx(float mhz)
-{
- SpiStrobe(CC1101_SIDLE);
- setMHZ(mhz);
- SpiStrobe(CC1101_STX); //start send
- trxstate=1;
-}
-/****************************************************************
-*FUNCTION NAME:SetRx
-*FUNCTION :set CC1101 to receive state and change frequency
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SetRx(float mhz)
-{
- SpiStrobe(CC1101_SIDLE);
- setMHZ(mhz);
- SpiStrobe(CC1101_SRX); //start receive
- trxstate=2;
-}
-/****************************************************************
-*FUNCTION NAME:RSSI Level
-*FUNCTION :Calculating the RSSI Level
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-int ELECHOUSE_CC1101::getRssi(void)
-{
-int rssi;
-rssi=SpiReadStatus(CC1101_RSSI);
-if (rssi >= 128){rssi = (rssi-256)/2-74;}
-else{rssi = (rssi/2)-74;}
-return rssi;
-}
-/****************************************************************
-*FUNCTION NAME:LQI Level
-*FUNCTION :get Lqi state
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-byte ELECHOUSE_CC1101::getLqi(void)
-{
-byte lqi;
-lqi=SpiReadStatus(CC1101_LQI);
-return lqi;
-}
-/****************************************************************
-*FUNCTION NAME:SetSres
-*FUNCTION :Reset CC1101
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setSres(void)
-{
- SpiStrobe(CC1101_SRES);
- trxstate=0;
-}
-/****************************************************************
-*FUNCTION NAME:setSidle
-*FUNCTION :set Rx / TX Off
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::setSidle(void)
-{
- SpiStrobe(CC1101_SIDLE);
- trxstate=0;
-}
-/****************************************************************
-*FUNCTION NAME:goSleep
-*FUNCTION :set cc1101 Sleep on
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::goSleep(void){
- trxstate=0;
- SpiStrobe(0x36);//Exit RX / TX, turn off frequency synthesizer and exit
- SpiStrobe(0x39);//Enter power down mode when CSn goes high.
-}
-/****************************************************************
-*FUNCTION NAME:Char direct SendData
-*FUNCTION :use CC1101 send data
-*INPUT :txBuffer: data array to send; size: number of data to send, no more than 61
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SendData(char *txchar)
-{
-int len = strlen(txchar);
-byte chartobyte[len];
-for (int i = 0; i<len; i++){chartobyte[i] = txchar[i];}
-SendData(chartobyte,len);
-}
-/****************************************************************
-*FUNCTION NAME:SendData
-*FUNCTION :use CC1101 send data
-*INPUT :txBuffer: data array to send; size: number of data to send, no more than 61
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SendData(byte *txBuffer,byte size)
-{
- SpiWriteReg(CC1101_TXFIFO,size);
- SpiWriteBurstReg(CC1101_TXFIFO,txBuffer,size); //write data to send
- SpiStrobe(CC1101_SIDLE);
- SpiStrobe(CC1101_STX); //start send
- while (!digitalRead(GDO0)); // Wait for GDO0 to be set -> sync transmitted
- while (digitalRead(GDO0)); // Wait for GDO0 to be cleared -> end of packet
- SpiStrobe(CC1101_SFTX); //flush TXfifo
- trxstate=1;
-}
-/****************************************************************
-*FUNCTION NAME:Char direct SendData
-*FUNCTION :use CC1101 send data without GDO
-*INPUT :txBuffer: data array to send; size: number of data to send, no more than 61
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SendData(char *txchar,int t)
-{
-int len = strlen(txchar);
-byte chartobyte[len];
-for (int i = 0; i<len; i++){chartobyte[i] = txchar[i];}
-SendData(chartobyte,len,t);
-}
-/****************************************************************
-*FUNCTION NAME:SendData
-*FUNCTION :use CC1101 send data without GDO
-*INPUT :txBuffer: data array to send; size: number of data to send, no more than 61
-*OUTPUT :none
-****************************************************************/
-void ELECHOUSE_CC1101::SendData(byte *txBuffer,byte size,int t)
-{
- SpiWriteReg(CC1101_TXFIFO,size);
- SpiWriteBurstReg(CC1101_TXFIFO,txBuffer,size); //write data to send
- SpiStrobe(CC1101_SIDLE);
- SpiStrobe(CC1101_STX); //start send
- delay(t);
- SpiStrobe(CC1101_SFTX); //flush TXfifo
- trxstate=1;
-}
-/****************************************************************
-*FUNCTION NAME:Check CRC
-*FUNCTION :none
-*INPUT :none
-*OUTPUT :none
-****************************************************************/
-bool ELECHOUSE_CC1101::CheckCRC(void){
-byte lqi=SpiReadStatus(CC1101_LQI);
-bool crc_ok = bitRead(lqi,7);
-if (crc_ok == 1){
-return 1;
-}else{
-SpiStrobe(CC1101_SFRX);
-SpiStrobe(CC1101_SRX);
-return 0;
-}
-}
-/****************************************************************
-*FUNCTION NAME:CheckRxFifo
-*FUNCTION :check receive data or not
-*INPUT :none
-*OUTPUT :flag: 0 no data; 1 receive data
-****************************************************************/
-bool ELECHOUSE_CC1101::CheckRxFifo(int t){
-if(trxstate!=2){SetRx();}
-if(SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO){
-delay(t);
-return 1;
-}else{
-return 0;
-}
-}
-/****************************************************************
-*FUNCTION NAME:CheckReceiveFlag
-*FUNCTION :check receive data or not
-*INPUT :none
-*OUTPUT :flag: 0 no data; 1 receive data
-****************************************************************/
-byte ELECHOUSE_CC1101::CheckReceiveFlag(void)
-{
- if(trxstate!=2){SetRx();}
- if(digitalRead(GDO0)) //receive data
- {
- while (digitalRead(GDO0));
- return 1;
- }
- else // no data
- {
- return 0;
- }
-}
-/****************************************************************
-*FUNCTION NAME:ReceiveData
-*FUNCTION :read data received from RXfifo
-*INPUT :rxBuffer: buffer to store data
-*OUTPUT :size of data received
-****************************************************************/
-byte ELECHOUSE_CC1101::ReceiveData(byte *rxBuffer)
-{
- byte size;
- byte status[2];
-
- if(SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO)
- {
- size=SpiReadReg(CC1101_RXFIFO);
- SpiReadBurstReg(CC1101_RXFIFO,rxBuffer,size);
- SpiReadBurstReg(CC1101_RXFIFO,status,2);
- SpiStrobe(CC1101_SFRX);
- SpiStrobe(CC1101_SRX);
- return size;
- }
- else
- {
- SpiStrobe(CC1101_SFRX);
- SpiStrobe(CC1101_SRX);
- return 0;
- }
-}
-ELECHOUSE_CC1101 ELECHOUSE_cc1101;
\ No newline at end of file |