diff options
| author | krolyxon <me@krolyxon.com> | 2026-05-11 14:01:44 +0530 |
|---|---|---|
| committer | krolyxon <me@krolyxon.com> | 2026-05-11 14:01:44 +0530 |
| commit | f34b1e2fbd94bcc8d0ee2e2e2e43e214d0b329a1 (patch) | |
| tree | 235d29da4668906d1e11d651980cea8b0c69dec7 /src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp | |
| parent | 360d2d2ad3bd584014683f3579fc2e2348c16852 (diff) | |
Migrate to PlatformIO
Now since i have been able to make PSRAM working with platformio, i
don't have to use this shitty Arduino-IDE anymore which does not even
allow me to use subfolders like a normal programmer would do
Diffstat (limited to 'src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp')
| -rw-r--r-- | src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp | 1309 |
1 files changed, 1309 insertions, 0 deletions
diff --git a/src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp b/src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp new file mode 100644 index 0000000..5568989 --- /dev/null +++ b/src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp @@ -0,0 +1,1309 @@ +/*
+ 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 |