Krolyxon
Commit 8f6c64d

Branches

Tags

Refs →

orion-rffirmwareELECHOUSE_CC1101_SRC_DRV.cpp

1309 lines · 40.6 KB · C++

Raw Blame History Download
1/*
2 ELECHOUSE_CC1101.cpp - CC1101 module library
3 Copyright (c) 2010 Michael.
4 Author: Michael, <www.elechouse.com>
5 Version: November 12, 2010
6
7 This library is designed to use CC1101/CC1100 module on Arduino platform.
8 CC1101/CC1100 module is an useful wireless module.Using the functions of the
9 library, you can easily send and receive data by the CC1101/CC1100 module.
10 Just have fun!
11 For the details, please refer to the datasheet of CC1100/CC1101.
12----------------------------------------------------------------------------------------------------------------
13cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and publish Wilson Shen (ELECHOUSE).
14----------------------------------------------------------------------------------------------------------------
15*/
16#include <SPI.h>
17#include "ELECHOUSE_CC1101_SRC_DRV.h"
18#include <Arduino.h>
19
20/****************************************************************/
21#define WRITE_BURST 0x40 //write burst
22#define READ_SINGLE 0x80 //read single
23#define READ_BURST 0xC0 //read burst
24#define BYTES_IN_RXFIFO 0x7F //byte number in RXfifo
25#define max_modul 6
26
27SPIClass CCSPI(HSPI);
28
29byte modulation = 2;
30byte frend0;
31byte chan = 0;
32int pa = 12;
33byte last_pa;
34byte SCK_PIN;
35byte MISO_PIN;
36byte MOSI_PIN;
37byte SS_PIN;
38byte GDO0;
39byte GDO2;
40byte SCK_PIN_M[max_modul];
41byte MISO_PIN_M[max_modul];
42byte MOSI_PIN_M[max_modul];
43byte SS_PIN_M[max_modul];
44byte GDO0_M[max_modul];
45byte GDO2_M[max_modul];
46byte gdo_set=0;
47bool spi = 0;
48bool ccmode = 0;
49float MHz = 433.92;
50byte m4RxBw = 0;
51byte m4DaRa;
52byte m2DCOFF;
53byte m2MODFM;
54byte m2MANCH;
55byte m2SYNCM;
56byte m1FEC;
57byte m1PRE;
58byte m1CHSP;
59byte pc1PQT;
60byte pc1CRC_AF;
61byte pc1APP_ST;
62byte pc1ADRCHK;
63byte pc0WDATA;
64byte pc0PktForm;
65byte pc0CRC_EN;
66byte pc0LenConf;
67byte trxstate = 0;
68byte clb1[2]= {24,28};
69byte clb2[2]= {31,38};
70byte clb3[2]= {65,76};
71byte clb4[2]= {77,79};
72
73/****************************************************************/
74uint8_t PA_TABLE[8] {0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00};
75// -30 -20 -15 -10 0 5 7 10
76uint8_t PA_TABLE_315[8] {0x12,0x0D,0x1C,0x34,0x51,0x85,0xCB,0xC2,}; //300 - 348
77uint8_t PA_TABLE_433[8] {0x12,0x0E,0x1D,0x34,0x60,0x84,0xC8,0xC0,}; //387 - 464
78// -30 -20 -15 -10 -6 0 5 7 10 12
79uint8_t PA_TABLE_868[10] {0x03,0x17,0x1D,0x26,0x37,0x50,0x86,0xCD,0xC5,0xC0,}; //779 - 899.99
80// -30 -20 -15 -10 -6 0 5 7 10 11
81uint8_t PA_TABLE_915[10] {0x03,0x0E,0x1E,0x27,0x38,0x8E,0x84,0xCC,0xC3,0xC0,}; //900 - 928
82/****************************************************************
83*FUNCTION NAME:SpiStart
84*FUNCTION :spi communication start
85*INPUT :none
86*OUTPUT :none
87****************************************************************/
88void ELECHOUSE_CC1101::SpiStart(void)
89{
90 // initialize the SPI pins
91 pinMode(SCK_PIN, OUTPUT);
92 pinMode(MOSI_PIN, OUTPUT);
93 pinMode(MISO_PIN, INPUT);
94 pinMode(SS_PIN, OUTPUT);
95
96 // enable SPI
97 #ifdef ESP32
98 CCSPI.begin(SCK_PIN, MISO_PIN, MOSI_PIN, SS_PIN);
99 #else
100 CCSPI.begin();
101 #endif
102}
103/****************************************************************
104*FUNCTION NAME:SpiEnd
105*FUNCTION :spi communication disable
106*INPUT :none
107*OUTPUT :none
108****************************************************************/
109void ELECHOUSE_CC1101::SpiEnd(void)
110{
111 // disable SPI
112 CCSPI.endTransaction();
113 CCSPI.end();
114}
115/****************************************************************
116*FUNCTION NAME: GDO_Set()
117*FUNCTION : set GDO0,GDO2 pin for serial pinmode.
118*INPUT : none
119*OUTPUT : none
120****************************************************************/
121void ELECHOUSE_CC1101::GDO_Set (void)
122{
123 pinMode(GDO0, OUTPUT);
124 pinMode(GDO2, INPUT);
125}
126/****************************************************************
127*FUNCTION NAME: GDO_Set()
128*FUNCTION : set GDO0 for internal transmission mode.
129*INPUT : none
130*OUTPUT : none
131****************************************************************/
132void ELECHOUSE_CC1101::GDO0_Set (void)
133{
134 pinMode(GDO0, INPUT);
135}
136/****************************************************************
137*FUNCTION NAME:Reset
138*FUNCTION :CC1101 reset //details refer datasheet of CC1101/CC1100//
139*INPUT :none
140*OUTPUT :none
141****************************************************************/
142void ELECHOUSE_CC1101::Reset (void)
143{
144 digitalWrite(SS_PIN, LOW);
145 delay(1);
146 digitalWrite(SS_PIN, HIGH);
147 delay(1);
148 digitalWrite(SS_PIN, LOW);
149 while(digitalRead(MISO_PIN));
150 CCSPI.transfer(CC1101_SRES);
151 while(digitalRead(MISO_PIN));
152 digitalWrite(SS_PIN, HIGH);
153}
154/****************************************************************
155*FUNCTION NAME:Init
156*FUNCTION :CC1101 initialization
157*INPUT :none
158*OUTPUT :none
159****************************************************************/
160void ELECHOUSE_CC1101::Init(void)
161{
162 setSpi();
163 SpiStart(); //spi initialization
164 digitalWrite(SS_PIN, HIGH);
165 digitalWrite(SCK_PIN, HIGH);
166 digitalWrite(MOSI_PIN, LOW);
167 Reset(); //CC1101 reset
168 RegConfigSettings(); //CC1101 register config
169 SpiEnd();
170}
171/****************************************************************
172*FUNCTION NAME:SpiWriteReg
173*FUNCTION :CC1101 write data to register
174*INPUT :addr: register address; value: register value
175*OUTPUT :none
176****************************************************************/
177void ELECHOUSE_CC1101::SpiWriteReg(byte addr, byte value)
178{
179 SpiStart();
180 digitalWrite(SS_PIN, LOW);
181 while(digitalRead(MISO_PIN));
182 CCSPI.transfer(addr);
183 CCSPI.transfer(value);
184 digitalWrite(SS_PIN, HIGH);
185 SpiEnd();
186}
187/****************************************************************
188*FUNCTION NAME:SpiWriteBurstReg
189*FUNCTION :CC1101 write burst data to register
190*INPUT :addr: register address; buffer:register value array; num:number to write
191*OUTPUT :none
192****************************************************************/
193void ELECHOUSE_CC1101::SpiWriteBurstReg(byte addr, byte *buffer, byte num)
194{
195 byte i, temp;
196 SpiStart();
197 temp = addr | WRITE_BURST;
198 digitalWrite(SS_PIN, LOW);
199 while(digitalRead(MISO_PIN));
200 CCSPI.transfer(temp);
201 for (i = 0; i < num; i++)
202 {
203 CCSPI.transfer(buffer[i]);
204 }
205 digitalWrite(SS_PIN, HIGH);
206 SpiEnd();
207}
208/****************************************************************
209*FUNCTION NAME:SpiStrobe
210*FUNCTION :CC1101 Strobe
211*INPUT :strobe: command; //refer define in CC1101.h//
212*OUTPUT :none
213****************************************************************/
214void ELECHOUSE_CC1101::SpiStrobe(byte strobe)
215{
216 SpiStart();
217 digitalWrite(SS_PIN, LOW);
218 while(digitalRead(MISO_PIN));
219 CCSPI.transfer(strobe);
220 digitalWrite(SS_PIN, HIGH);
221 SpiEnd();
222}
223/****************************************************************
224*FUNCTION NAME:SpiReadReg
225*FUNCTION :CC1101 read data from register
226*INPUT :addr: register address
227*OUTPUT :register value
228****************************************************************/
229byte ELECHOUSE_CC1101::SpiReadReg(byte addr)
230{
231 byte temp, value;
232 SpiStart();
233 temp = addr| READ_SINGLE;
234 digitalWrite(SS_PIN, LOW);
235 while(digitalRead(MISO_PIN));
236 CCSPI.transfer(temp);
237 value=CCSPI.transfer(0);
238 digitalWrite(SS_PIN, HIGH);
239 SpiEnd();
240 return value;
241}
242
243/****************************************************************
244*FUNCTION NAME:SpiReadBurstReg
245*FUNCTION :CC1101 read burst data from register
246*INPUT :addr: register address; buffer:array to store register value; num: number to read
247*OUTPUT :none
248****************************************************************/
249void ELECHOUSE_CC1101::SpiReadBurstReg(byte addr, byte *buffer, byte num)
250{
251 byte i,temp;
252 SpiStart();
253 temp = addr | READ_BURST;
254 digitalWrite(SS_PIN, LOW);
255 while(digitalRead(MISO_PIN));
256 CCSPI.transfer(temp);
257 for(i=0;i<num;i++)
258 {
259 buffer[i]=CCSPI.transfer(0);
260 }
261 digitalWrite(SS_PIN, HIGH);
262 SpiEnd();
263}
264
265/****************************************************************
266*FUNCTION NAME:SpiReadStatus
267*FUNCTION :CC1101 read status register
268*INPUT :addr: register address
269*OUTPUT :status value
270****************************************************************/
271byte ELECHOUSE_CC1101::SpiReadStatus(byte addr)
272{
273 byte value,temp;
274 SpiStart();
275 temp = addr | READ_BURST;
276 digitalWrite(SS_PIN, LOW);
277 while(digitalRead(MISO_PIN));
278 CCSPI.transfer(temp);
279 value=CCSPI.transfer(0);
280 digitalWrite(SS_PIN, HIGH);
281 SpiEnd();
282 return value;
283}
284/****************************************************************
285*FUNCTION NAME:SPI pin Settings
286*FUNCTION :Set Spi pins
287*INPUT :none
288*OUTPUT :none
289****************************************************************/
290void ELECHOUSE_CC1101::setSpi(void){
291 if (spi == 0){
292 #if defined __AVR_ATmega168__ || defined __AVR_ATmega328P__
293 SCK_PIN = 13; MISO_PIN = 12; MOSI_PIN = 11; SS_PIN = 10;
294 #elif defined __AVR_ATmega1280__ || defined __AVR_ATmega2560__
295 SCK_PIN = 52; MISO_PIN = 50; MOSI_PIN = 51; SS_PIN = 53;
296 #elif ESP8266
297 SCK_PIN = 14; MISO_PIN = 12; MOSI_PIN = 13; SS_PIN = 15;
298 #elif ESP32
299 SCK_PIN = 18; MISO_PIN = 19; MOSI_PIN = 23; SS_PIN = 5;
300 #else
301 SCK_PIN = 13; MISO_PIN = 12; MOSI_PIN = 11; SS_PIN = 10;
302 #endif
303}
304}
305/****************************************************************
306*FUNCTION NAME:COSTUM SPI
307*FUNCTION :set costum spi pins.
308*INPUT :none
309*OUTPUT :none
310****************************************************************/
311void ELECHOUSE_CC1101::setSpiPin(byte sck, byte miso, byte mosi, byte ss){
312 spi = 1;
313 SCK_PIN = sck;
314 MISO_PIN = miso;
315 MOSI_PIN = mosi;
316 SS_PIN = ss;
317}
318/****************************************************************
319*FUNCTION NAME:COSTUM SPI
320*FUNCTION :set costum spi pins.
321*INPUT :none
322*OUTPUT :none
323****************************************************************/
324void ELECHOUSE_CC1101::addSpiPin(byte sck, byte miso, byte mosi, byte ss, byte modul){
325 spi = 1;
326 SCK_PIN_M[modul] = sck;
327 MISO_PIN_M[modul] = miso;
328 MOSI_PIN_M[modul] = mosi;
329 SS_PIN_M[modul] = ss;
330}
331/****************************************************************
332*FUNCTION NAME:GDO Pin settings
333*FUNCTION :set GDO Pins
334*INPUT :none
335*OUTPUT :none
336****************************************************************/
337void ELECHOUSE_CC1101::setGDO(byte gdo0, byte gdo2){
338GDO0 = gdo0;
339GDO2 = gdo2;
340GDO_Set();
341}
342/****************************************************************
343*FUNCTION NAME:GDO0 Pin setting
344*FUNCTION :set GDO0 Pin
345*INPUT :none
346*OUTPUT :none
347****************************************************************/
348void ELECHOUSE_CC1101::setGDO0(byte gdo0){
349GDO0 = gdo0;
350GDO0_Set();
351}
352/****************************************************************
353*FUNCTION NAME:GDO Pin settings
354*FUNCTION :add GDO Pins
355*INPUT :none
356*OUTPUT :none
357****************************************************************/
358void ELECHOUSE_CC1101::addGDO(byte gdo0, byte gdo2, byte modul){
359GDO0_M[modul] = gdo0;
360GDO2_M[modul] = gdo2;
361gdo_set=2;
362GDO_Set();
363}
364/****************************************************************
365*FUNCTION NAME:add GDO0 Pin
366*FUNCTION :add GDO0 Pin
367*INPUT :none
368*OUTPUT :none
369****************************************************************/
370void ELECHOUSE_CC1101::addGDO0(byte gdo0, byte modul){
371GDO0_M[modul] = gdo0;
372gdo_set=1;
373GDO0_Set();
374}
375/****************************************************************
376*FUNCTION NAME:set Modul
377*FUNCTION :change modul
378*INPUT :none
379*OUTPUT :none
380****************************************************************/
381void ELECHOUSE_CC1101::setModul(byte modul){
382 SCK_PIN = SCK_PIN_M[modul];
383 MISO_PIN = MISO_PIN_M[modul];
384 MOSI_PIN = MOSI_PIN_M[modul];
385 SS_PIN = SS_PIN_M[modul];
386 if (gdo_set==1){
387 GDO0 = GDO0_M[modul];
388 }
389 else if (gdo_set==2){
390 GDO0 = GDO0_M[modul];
391 GDO2 = GDO2_M[modul];
392 }
393}
394/****************************************************************
395*FUNCTION NAME:CCMode
396*FUNCTION :Format of RX and TX data
397*INPUT :none
398*OUTPUT :none
399****************************************************************/
400void ELECHOUSE_CC1101::setCCMode(bool s){
401ccmode = s;
402if (ccmode == 1){
403SpiWriteReg(CC1101_IOCFG2, 0x0B);
404SpiWriteReg(CC1101_IOCFG0, 0x06);
405SpiWriteReg(CC1101_PKTCTRL0, 0x05);
406SpiWriteReg(CC1101_MDMCFG3, 0xF8);
407SpiWriteReg(CC1101_MDMCFG4,11+m4RxBw);
408}else{
409SpiWriteReg(CC1101_IOCFG2, 0x0D);
410SpiWriteReg(CC1101_IOCFG0, 0x0D);
411SpiWriteReg(CC1101_PKTCTRL0, 0x32);
412SpiWriteReg(CC1101_MDMCFG3, 0x93);
413SpiWriteReg(CC1101_MDMCFG4, 7+m4RxBw);
414}
415setModulation(modulation);
416}
417/****************************************************************
418*FUNCTION NAME:Modulation
419*FUNCTION :set CC1101 Modulation
420*INPUT :none
421*OUTPUT :none
422****************************************************************/
423void ELECHOUSE_CC1101::setModulation(byte m){
424if (m>4){m=4;}
425modulation = m;
426Split_MDMCFG2();
427switch (m)
428{
429case 0: m2MODFM=0x00; frend0=0x10; break; // 2-FSK
430case 1: m2MODFM=0x10; frend0=0x10; break; // GFSK
431case 2: m2MODFM=0x30; frend0=0x11; break; // ASK
432case 3: m2MODFM=0x40; frend0=0x10; break; // 4-FSK
433case 4: m2MODFM=0x70; frend0=0x10; break; // MSK
434}
435SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);
436SpiWriteReg(CC1101_FREND0, frend0);
437setPA(pa);
438}
439/****************************************************************
440*FUNCTION NAME:PA Power
441*FUNCTION :set CC1101 PA Power
442*INPUT :none
443*OUTPUT :none
444****************************************************************/
445void ELECHOUSE_CC1101::setPA(int p)
446{
447int a;
448pa = p;
449
450if (MHz >= 300 && MHz <= 348){
451if (pa <= -30){a = PA_TABLE_315[0];}
452else if (pa > -30 && pa <= -20){a = PA_TABLE_315[1];}
453else if (pa > -20 && pa <= -15){a = PA_TABLE_315[2];}
454else if (pa > -15 && pa <= -10){a = PA_TABLE_315[3];}
455else if (pa > -10 && pa <= 0){a = PA_TABLE_315[4];}
456else if (pa > 0 && pa <= 5){a = PA_TABLE_315[5];}
457else if (pa > 5 && pa <= 7){a = PA_TABLE_315[6];}
458else if (pa > 7){a = PA_TABLE_315[7];}
459last_pa = 1;
460}
461else if (MHz >= 378 && MHz <= 464){
462if (pa <= -30){a = PA_TABLE_433[0];}
463else if (pa > -30 && pa <= -20){a = PA_TABLE_433[1];}
464else if (pa > -20 && pa <= -15){a = PA_TABLE_433[2];}
465else if (pa > -15 && pa <= -10){a = PA_TABLE_433[3];}
466else if (pa > -10 && pa <= 0){a = PA_TABLE_433[4];}
467else if (pa > 0 && pa <= 5){a = PA_TABLE_433[5];}
468else if (pa > 5 && pa <= 7){a = PA_TABLE_433[6];}
469else if (pa > 7){a = PA_TABLE_433[7];}
470last_pa = 2;
471}
472else if (MHz >= 779 && MHz <= 899.99){
473if (pa <= -30){a = PA_TABLE_868[0];}
474else if (pa > -30 && pa <= -20){a = PA_TABLE_868[1];}
475else if (pa > -20 && pa <= -15){a = PA_TABLE_868[2];}
476else if (pa > -15 && pa <= -10){a = PA_TABLE_868[3];}
477else if (pa > -10 && pa <= -6){a = PA_TABLE_868[4];}
478else if (pa > -6 && pa <= 0){a = PA_TABLE_868[5];}
479else if (pa > 0 && pa <= 5){a = PA_TABLE_868[6];}
480else if (pa > 5 && pa <= 7){a = PA_TABLE_868[7];}
481else if (pa > 7 && pa <= 10){a = PA_TABLE_868[8];}
482else if (pa > 10){a = PA_TABLE_868[9];}
483last_pa = 3;
484}
485else if (MHz >= 900 && MHz <= 928){
486if (pa <= -30){a = PA_TABLE_915[0];}
487else if (pa > -30 && pa <= -20){a = PA_TABLE_915[1];}
488else if (pa > -20 && pa <= -15){a = PA_TABLE_915[2];}
489else if (pa > -15 && pa <= -10){a = PA_TABLE_915[3];}
490else if (pa > -10 && pa <= -6){a = PA_TABLE_915[4];}
491else if (pa > -6 && pa <= 0){a = PA_TABLE_915[5];}
492else if (pa > 0 && pa <= 5){a = PA_TABLE_915[6];}
493else if (pa > 5 && pa <= 7){a = PA_TABLE_915[7];}
494else if (pa > 7 && pa <= 10){a = PA_TABLE_915[8];}
495else if (pa > 10){a = PA_TABLE_915[9];}
496last_pa = 4;
497}
498if (modulation == 2){
499PA_TABLE[0] = 0;
500PA_TABLE[1] = a;
501}else{
502PA_TABLE[0] = a;
503PA_TABLE[1] = 0;
504}
505SpiWriteBurstReg(CC1101_PATABLE,PA_TABLE,8);
506}
507/****************************************************************
508*FUNCTION NAME:Frequency Calculator
509*FUNCTION :Calculate the basic frequency.
510*INPUT :none
511*OUTPUT :none
512****************************************************************/
513void ELECHOUSE_CC1101::setMHZ(float mhz){
514byte freq2 = 0;
515byte freq1 = 0;
516byte freq0 = 0;
517
518MHz = mhz;
519
520for (bool i = 0; i==0;){
521if (mhz >= 26){
522mhz-=26;
523freq2+=1;
524}
525else if (mhz >= 0.1015625){
526mhz-=0.1015625;
527freq1+=1;
528}
529else if (mhz >= 0.00039675){
530mhz-=0.00039675;
531freq0+=1;
532}
533else{i=1;}
534}
535if (freq0 > 255){freq1+=1;freq0-=256;}
536
537SpiWriteReg(CC1101_FREQ2, freq2);
538SpiWriteReg(CC1101_FREQ1, freq1);
539SpiWriteReg(CC1101_FREQ0, freq0);
540
541Calibrate();
542}
543/****************************************************************
544*FUNCTION NAME:Calibrate
545*FUNCTION :Calibrate frequency
546*INPUT :none
547*OUTPUT :none
548****************************************************************/
549void ELECHOUSE_CC1101::Calibrate(void){
550
551if (MHz >= 300 && MHz <= 348){
552SpiWriteReg(CC1101_FSCTRL0, map(MHz, 300, 348, clb1[0], clb1[1]));
553if (MHz < 322.88){SpiWriteReg(CC1101_TEST0,0x0B);}
554else{
555SpiWriteReg(CC1101_TEST0,0x09);
556int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);
557if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}
558if (last_pa != 1){setPA(pa);}
559}
560}
561else if (MHz >= 378 && MHz <= 464){
562SpiWriteReg(CC1101_FSCTRL0, map(MHz, 378, 464, clb2[0], clb2[1]));
563if (MHz < 430.5){SpiWriteReg(CC1101_TEST0,0x0B);}
564else{
565SpiWriteReg(CC1101_TEST0,0x09);
566int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);
567if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}
568if (last_pa != 2){setPA(pa);}
569}
570}
571else if (MHz >= 779 && MHz <= 899.99){
572SpiWriteReg(CC1101_FSCTRL0, map(MHz, 779, 899, clb3[0], clb3[1]));
573if (MHz < 861){SpiWriteReg(CC1101_TEST0,0x0B);}
574else{
575SpiWriteReg(CC1101_TEST0,0x09);
576int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);
577if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}
578if (last_pa != 3){setPA(pa);}
579}
580}
581else if (MHz >= 900 && MHz <= 928){
582SpiWriteReg(CC1101_FSCTRL0, map(MHz, 900, 928, clb4[0], clb4[1]));
583SpiWriteReg(CC1101_TEST0,0x09);
584int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2);
585if (s<32){SpiWriteReg(CC1101_FSCAL2, s+32);}
586if (last_pa != 4){setPA(pa);}
587}
588}
589/****************************************************************
590*FUNCTION NAME:Calibration offset
591*FUNCTION :Set calibration offset
592*INPUT :none
593*OUTPUT :none
594****************************************************************/
595void ELECHOUSE_CC1101::setClb(byte b, byte s, byte e){
596if (b == 1){
597clb1[0]=s;
598clb1[1]=e;
599}
600else if (b == 2){
601clb2[0]=s;
602clb2[1]=e;
603}
604else if (b == 3){
605clb3[0]=s;
606clb3[1]=e;
607}
608else if (b == 4){
609clb4[0]=s;
610clb4[1]=e;
611}
612}
613/****************************************************************
614*FUNCTION NAME:getCC1101
615*FUNCTION :Test Spi connection and return 1 when true.
616*INPUT :none
617*OUTPUT :none
618****************************************************************/
619bool ELECHOUSE_CC1101::getCC1101(void){
620setSpi();
621if (SpiReadStatus(0x31)>0){
622return 1;
623}else{
624return 0;
625}
626}
627/****************************************************************
628*FUNCTION NAME:getMode
629*FUNCTION :Return the Mode. Sidle = 0, TX = 1, Rx = 2.
630*INPUT :none
631*OUTPUT :none
632****************************************************************/
633byte ELECHOUSE_CC1101::getMode(void){
634return trxstate;
635}
636/****************************************************************
637*FUNCTION NAME:Set Sync_Word
638*FUNCTION :Sync Word
639*INPUT :none
640*OUTPUT :none
641****************************************************************/
642void ELECHOUSE_CC1101::setSyncWord(byte sh, byte sl){
643SpiWriteReg(CC1101_SYNC1, sh);
644SpiWriteReg(CC1101_SYNC0, sl);
645}
646/****************************************************************
647*FUNCTION NAME:Set ADDR
648*FUNCTION :Address used for packet filtration. Optional broadcast addresses are 0 (0x00) and 255 (0xFF).
649*INPUT :none
650*OUTPUT :none
651****************************************************************/
652void ELECHOUSE_CC1101::setAddr(byte v){
653SpiWriteReg(CC1101_ADDR, v);
654}
655/****************************************************************
656*FUNCTION NAME:Set PQT
657*FUNCTION :Preamble quality estimator threshold
658*INPUT :none
659*OUTPUT :none
660****************************************************************/
661void ELECHOUSE_CC1101::setPQT(byte v){
662Split_PKTCTRL1();
663pc1PQT = 0;
664if (v>7){v=7;}
665pc1PQT = v*32;
666SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);
667}
668/****************************************************************
669*FUNCTION NAME:Set CRC_AUTOFLUSH
670*FUNCTION :Enable automatic flush of RX FIFO when CRC is not OK
671*INPUT :none
672*OUTPUT :none
673****************************************************************/
674void ELECHOUSE_CC1101::setCRC_AF(bool v){
675Split_PKTCTRL1();
676pc1CRC_AF = 0;
677if (v==1){pc1CRC_AF=8;}
678SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);
679}
680/****************************************************************
681*FUNCTION NAME:Set APPEND_STATUS
682*FUNCTION :When enabled, two status bytes will be appended to the payload of the packet
683*INPUT :none
684*OUTPUT :none
685****************************************************************/
686void ELECHOUSE_CC1101::setAppendStatus(bool v){
687Split_PKTCTRL1();
688pc1APP_ST = 0;
689if (v==1){pc1APP_ST=4;}
690SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);
691}
692/****************************************************************
693*FUNCTION NAME:Set ADR_CHK
694*FUNCTION :Controls address check configuration of received packages
695*INPUT :none
696*OUTPUT :none
697****************************************************************/
698void ELECHOUSE_CC1101::setAdrChk(byte v){
699Split_PKTCTRL1();
700pc1ADRCHK = 0;
701if (v>3){v=3;}
702pc1ADRCHK = v;
703SpiWriteReg(CC1101_PKTCTRL1, pc1PQT+pc1CRC_AF+pc1APP_ST+pc1ADRCHK);
704}
705/****************************************************************
706*FUNCTION NAME:Set WHITE_DATA
707*FUNCTION :Turn data whitening on / off.
708*INPUT :none
709*OUTPUT :none
710****************************************************************/
711void ELECHOUSE_CC1101::setWhiteData(bool v){
712Split_PKTCTRL0();
713pc0WDATA = 0;
714if (v == 1){pc0WDATA=64;}
715SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);
716}
717/****************************************************************
718*FUNCTION NAME:Set PKT_FORMAT
719*FUNCTION :Format of RX and TX data
720*INPUT :none
721*OUTPUT :none
722****************************************************************/
723void ELECHOUSE_CC1101::setPktFormat(byte v){
724Split_PKTCTRL0();
725pc0PktForm = 0;
726if (v>3){v=3;}
727pc0PktForm = v*16;
728SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);
729}
730/****************************************************************
731*FUNCTION NAME:Set CRC
732*FUNCTION :CRC calculation in TX and CRC check in RX
733*INPUT :none
734*OUTPUT :none
735****************************************************************/
736void ELECHOUSE_CC1101::setCrc(bool v){
737Split_PKTCTRL0();
738pc0CRC_EN = 0;
739if (v==1){pc0CRC_EN=4;}
740SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);
741}
742/****************************************************************
743*FUNCTION NAME:Set LENGTH_CONFIG
744*FUNCTION :Configure the packet length
745*INPUT :none
746*OUTPUT :none
747****************************************************************/
748void ELECHOUSE_CC1101::setLengthConfig(byte v){
749Split_PKTCTRL0();
750pc0LenConf = 0;
751if (v>3){v=3;}
752pc0LenConf = v;
753SpiWriteReg(CC1101_PKTCTRL0, pc0WDATA+pc0PktForm+pc0CRC_EN+pc0LenConf);
754}
755/****************************************************************
756*FUNCTION NAME:Set PACKET_LENGTH
757*FUNCTION :Indicates the packet length
758*INPUT :none
759*OUTPUT :none
760****************************************************************/
761void ELECHOUSE_CC1101::setPacketLength(byte v){
762SpiWriteReg(CC1101_PKTLEN, v);
763}
764/****************************************************************
765*FUNCTION NAME:Set DCFILT_OFF
766*FUNCTION :Disable digital DC blocking filter before demodulator
767*INPUT :none
768*OUTPUT :none
769****************************************************************/
770void ELECHOUSE_CC1101::setDcFilterOff(bool v){
771Split_MDMCFG2();
772m2DCOFF = 0;
773if (v==1){m2DCOFF=128;}
774SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);
775}
776/****************************************************************
777*FUNCTION NAME:Set MANCHESTER
778*FUNCTION :Enables Manchester encoding/decoding
779*INPUT :none
780*OUTPUT :none
781****************************************************************/
782void ELECHOUSE_CC1101::setManchester(bool v){
783Split_MDMCFG2();
784m2MANCH = 0;
785if (v==1){m2MANCH=8;}
786SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);
787}
788/****************************************************************
789*FUNCTION NAME:Set SYNC_MODE
790*FUNCTION :Combined sync-word qualifier mode
791*INPUT :none
792*OUTPUT :none
793****************************************************************/
794void ELECHOUSE_CC1101::setSyncMode(byte v){
795Split_MDMCFG2();
796m2SYNCM = 0;
797if (v>7){v=7;}
798m2SYNCM=v;
799SpiWriteReg(CC1101_MDMCFG2, m2DCOFF+m2MODFM+m2MANCH+m2SYNCM);
800}
801/****************************************************************
802*FUNCTION NAME:Set FEC
803*FUNCTION :Enable Forward Error Correction (FEC)
804*INPUT :none
805*OUTPUT :none
806****************************************************************/
807void ELECHOUSE_CC1101::setFEC(bool v){
808Split_MDMCFG1();
809m1FEC=0;
810if (v==1){m1FEC=128;}
811SpiWriteReg(CC1101_MDMCFG1, m1FEC+m1PRE+m1CHSP);
812}
813/****************************************************************
814*FUNCTION NAME:Set PRE
815*FUNCTION :Sets the minimum number of preamble bytes to be transmitted.
816*INPUT :none
817*OUTPUT :none
818****************************************************************/
819void ELECHOUSE_CC1101::setPRE(byte v){
820Split_MDMCFG1();
821m1PRE=0;
822if (v>7){v=7;}
823m1PRE = v*16;
824SpiWriteReg(CC1101_MDMCFG1, m1FEC+m1PRE+m1CHSP);
825}
826/****************************************************************
827*FUNCTION NAME:Set Channel
828*FUNCTION :none
829*INPUT :none
830*OUTPUT :none
831****************************************************************/
832void ELECHOUSE_CC1101::setChannel(byte ch){
833chan = ch;
834SpiWriteReg(CC1101_CHANNR, chan);
835}
836/****************************************************************
837*FUNCTION NAME:Set Channel spacing
838*FUNCTION :none
839*INPUT :none
840*OUTPUT :none
841****************************************************************/
842void ELECHOUSE_CC1101::setChsp(float f){
843Split_MDMCFG1();
844byte MDMCFG0 = 0;
845m1CHSP = 0;
846if (f > 405.456543){f = 405.456543;}
847if (f < 25.390625){f = 25.390625;}
848for (int i = 0; i<5; i++){
849if (f <= 50.682068){
850f -= 25.390625;
851f /= 0.0991825;
852MDMCFG0 = f;
853float s1 = (f - MDMCFG0) *10;
854if (s1 >= 5){MDMCFG0++;}
855i = 5;
856}else{
857m1CHSP++;
858f/=2;
859}
860}
861SpiWriteReg(19,m1CHSP+m1FEC+m1PRE);
862SpiWriteReg(20,MDMCFG0);
863}
864/****************************************************************
865*FUNCTION NAME:Set Receive bandwidth
866*FUNCTION :none
867*INPUT :none
868*OUTPUT :none
869****************************************************************/
870void ELECHOUSE_CC1101::setRxBW(float f){
871Split_MDMCFG4();
872int s1 = 3;
873int s2 = 3;
874for (int i = 0; i<3; i++){
875if (f > 101.5625){f/=2; s1--;}
876else{i=3;}
877}
878for (int i = 0; i<3; i++){
879if (f > 58.1){f/=1.25; s2--;}
880else{i=3;}
881}
882s1 *= 64;
883s2 *= 16;
884m4RxBw = s1 + s2;
885SpiWriteReg(16,m4RxBw+m4DaRa);
886}
887/****************************************************************
888*FUNCTION NAME:Set Data Rate
889*FUNCTION :none
890*INPUT :none
891*OUTPUT :none
892****************************************************************/
893void ELECHOUSE_CC1101::setDRate(float d){
894Split_MDMCFG4();
895float c = d;
896byte MDMCFG3 = 0;
897if (c > 1621.83){c = 1621.83;}
898if (c < 0.0247955){c = 0.0247955;}
899m4DaRa = 0;
900for (int i = 0; i<20; i++){
901if (c <= 0.0494942){
902c = c - 0.0247955;
903c = c / 0.00009685;
904MDMCFG3 = c;
905float s1 = (c - MDMCFG3) *10;
906if (s1 >= 5){MDMCFG3++;}
907i = 20;
908}else{
909m4DaRa++;
910c = c/2;
911}
912}
913SpiWriteReg(16, m4RxBw+m4DaRa);
914SpiWriteReg(17, MDMCFG3);
915}
916/****************************************************************
917*FUNCTION NAME:Set Devitation
918*FUNCTION :none
919*INPUT :none
920*OUTPUT :none
921****************************************************************/
922void ELECHOUSE_CC1101::setDeviation(float d){
923float f = 1.586914;
924float v = 0.19836425;
925int c = 0;
926if (d > 380.859375){d = 380.859375;}
927if (d < 1.586914){d = 1.586914;}
928for (int i = 0; i<255; i++){
929f+=v;
930if (c==7){v*=2;c=-1;i+=8;}
931if (f>=d){c=i;i=255;}
932c++;
933}
934SpiWriteReg(21,c);
935}
936/****************************************************************
937*FUNCTION NAME:Split PKTCTRL0
938*FUNCTION :none
939*INPUT :none
940*OUTPUT :none
941****************************************************************/
942void ELECHOUSE_CC1101::Split_PKTCTRL1(void){
943int calc = SpiReadStatus(7);
944pc1PQT = 0;
945pc1CRC_AF = 0;
946pc1APP_ST = 0;
947pc1ADRCHK = 0;
948for (bool i = 0; i==0;){
949if (calc >= 32){calc-=32; pc1PQT+=32;}
950else if (calc >= 8){calc-=8; pc1CRC_AF+=8;}
951else if (calc >= 4){calc-=4; pc1APP_ST+=4;}
952else {pc1ADRCHK = calc; i=1;}
953}
954}
955/****************************************************************
956*FUNCTION NAME:Split PKTCTRL0
957*FUNCTION :none
958*INPUT :none
959*OUTPUT :none
960****************************************************************/
961void ELECHOUSE_CC1101::Split_PKTCTRL0(void){
962int calc = SpiReadStatus(8);
963pc0WDATA = 0;
964pc0PktForm = 0;
965pc0CRC_EN = 0;
966pc0LenConf = 0;
967for (bool i = 0; i==0;){
968if (calc >= 64){calc-=64; pc0WDATA+=64;}
969else if (calc >= 16){calc-=16; pc0PktForm+=16;}
970else if (calc >= 4){calc-=4; pc0CRC_EN+=4;}
971else {pc0LenConf = calc; i=1;}
972}
973}
974/****************************************************************
975*FUNCTION NAME:Split MDMCFG1
976*FUNCTION :none
977*INPUT :none
978*OUTPUT :none
979****************************************************************/
980void ELECHOUSE_CC1101::Split_MDMCFG1(void){
981int calc = SpiReadStatus(19);
982m1FEC = 0;
983m1PRE = 0;
984m1CHSP = 0;
985int s2 = 0;
986for (bool i = 0; i==0;){
987if (calc >= 128){calc-=128; m1FEC+=128;}
988else if (calc >= 16){calc-=16; m1PRE+=16;}
989else {m1CHSP = calc; i=1;}
990}
991}
992/****************************************************************
993*FUNCTION NAME:Split MDMCFG2
994*FUNCTION :none
995*INPUT :none
996*OUTPUT :none
997****************************************************************/
998void ELECHOUSE_CC1101::Split_MDMCFG2(void){
999int calc = SpiReadStatus(18);
1000m2DCOFF = 0;
1001m2MODFM = 0;
1002m2MANCH = 0;
1003m2SYNCM = 0;
1004for (bool i = 0; i==0;){
1005if (calc >= 128){calc-=128; m2DCOFF+=128;}
1006else if (calc >= 16){calc-=16; m2MODFM+=16;}
1007else if (calc >= 8){calc-=8; m2MANCH+=8;}
1008else{m2SYNCM = calc; i=1;}
1009}
1010}
1011/****************************************************************
1012*FUNCTION NAME:Split MDMCFG4
1013*FUNCTION :none
1014*INPUT :none
1015*OUTPUT :none
1016****************************************************************/
1017void ELECHOUSE_CC1101::Split_MDMCFG4(void){
1018int calc = SpiReadStatus(16);
1019m4RxBw = 0;
1020m4DaRa = 0;
1021for (bool i = 0; i==0;){
1022if (calc >= 64){calc-=64; m4RxBw+=64;}
1023else if (calc >= 16){calc -= 16; m4RxBw+=16;}
1024else{m4DaRa = calc; i=1;}
1025}
1026}
1027/****************************************************************
1028*FUNCTION NAME:RegConfigSettings
1029*FUNCTION :CC1101 register config //details refer datasheet of CC1101/CC1100//
1030*INPUT :none
1031*OUTPUT :none
1032****************************************************************/
1033void ELECHOUSE_CC1101::RegConfigSettings(void)
1034{
1035 SpiWriteReg(CC1101_FSCTRL1, 0x06);
1036
1037 setCCMode(ccmode);
1038 setMHZ(MHz);
1039
1040 SpiWriteReg(CC1101_MDMCFG1, 0x02);
1041 SpiWriteReg(CC1101_MDMCFG0, 0xF8);
1042 SpiWriteReg(CC1101_CHANNR, chan);
1043 SpiWriteReg(CC1101_DEVIATN, 0x47);
1044 SpiWriteReg(CC1101_FREND1, 0x56);
1045 SpiWriteReg(CC1101_MCSM0 , 0x18);
1046 SpiWriteReg(CC1101_FOCCFG, 0x16);
1047 SpiWriteReg(CC1101_BSCFG, 0x1C);
1048 SpiWriteReg(CC1101_AGCCTRL2, 0xC7);
1049 SpiWriteReg(CC1101_AGCCTRL1, 0x00);
1050 SpiWriteReg(CC1101_AGCCTRL0, 0xB2);
1051 SpiWriteReg(CC1101_FSCAL3, 0xE9);
1052 SpiWriteReg(CC1101_FSCAL2, 0x2A);
1053 SpiWriteReg(CC1101_FSCAL1, 0x00);
1054 SpiWriteReg(CC1101_FSCAL0, 0x1F);
1055 SpiWriteReg(CC1101_FSTEST, 0x59);
1056 SpiWriteReg(CC1101_TEST2, 0x81);
1057 SpiWriteReg(CC1101_TEST1, 0x35);
1058 SpiWriteReg(CC1101_TEST0, 0x09);
1059 SpiWriteReg(CC1101_PKTCTRL1, 0x04);
1060 SpiWriteReg(CC1101_ADDR, 0x00);
1061 SpiWriteReg(CC1101_PKTLEN, 0x00);
1062}
1063/****************************************************************
1064*FUNCTION NAME:SetTx
1065*FUNCTION :set CC1101 send data
1066*INPUT :none
1067*OUTPUT :none
1068****************************************************************/
1069void ELECHOUSE_CC1101::SetTx(void)
1070{
1071 SpiStrobe(CC1101_SIDLE);
1072 SpiStrobe(CC1101_STX); //start send
1073 trxstate=1;
1074}
1075/****************************************************************
1076*FUNCTION NAME:SetRx
1077*FUNCTION :set CC1101 to receive state
1078*INPUT :none
1079*OUTPUT :none
1080****************************************************************/
1081void ELECHOUSE_CC1101::SetRx(void)
1082{
1083 SpiStrobe(CC1101_SIDLE);
1084 SpiStrobe(CC1101_SRX); //start receive
1085 trxstate=2;
1086}
1087/****************************************************************
1088*FUNCTION NAME:SetTx
1089*FUNCTION :set CC1101 send data and change frequency
1090*INPUT :none
1091*OUTPUT :none
1092****************************************************************/
1093void ELECHOUSE_CC1101::SetTx(float mhz)
1094{
1095 SpiStrobe(CC1101_SIDLE);
1096 setMHZ(mhz);
1097 SpiStrobe(CC1101_STX); //start send
1098 trxstate=1;
1099}
1100/****************************************************************
1101*FUNCTION NAME:SetRx
1102*FUNCTION :set CC1101 to receive state and change frequency
1103*INPUT :none
1104*OUTPUT :none
1105****************************************************************/
1106void ELECHOUSE_CC1101::SetRx(float mhz)
1107{
1108 SpiStrobe(CC1101_SIDLE);
1109 setMHZ(mhz);
1110 SpiStrobe(CC1101_SRX); //start receive
1111 trxstate=2;
1112}
1113/****************************************************************
1114*FUNCTION NAME:RSSI Level
1115*FUNCTION :Calculating the RSSI Level
1116*INPUT :none
1117*OUTPUT :none
1118****************************************************************/
1119int ELECHOUSE_CC1101::getRssi(void)
1120{
1121int rssi;
1122rssi=SpiReadStatus(CC1101_RSSI);
1123if (rssi >= 128){rssi = (rssi-256)/2-74;}
1124else{rssi = (rssi/2)-74;}
1125return rssi;
1126}
1127/****************************************************************
1128*FUNCTION NAME:LQI Level
1129*FUNCTION :get Lqi state
1130*INPUT :none
1131*OUTPUT :none
1132****************************************************************/
1133byte ELECHOUSE_CC1101::getLqi(void)
1134{
1135byte lqi;
1136lqi=SpiReadStatus(CC1101_LQI);
1137return lqi;
1138}
1139/****************************************************************
1140*FUNCTION NAME:SetSres
1141*FUNCTION :Reset CC1101
1142*INPUT :none
1143*OUTPUT :none
1144****************************************************************/
1145void ELECHOUSE_CC1101::setSres(void)
1146{
1147 SpiStrobe(CC1101_SRES);
1148 trxstate=0;
1149}
1150/****************************************************************
1151*FUNCTION NAME:setSidle
1152*FUNCTION :set Rx / TX Off
1153*INPUT :none
1154*OUTPUT :none
1155****************************************************************/
1156void ELECHOUSE_CC1101::setSidle(void)
1157{
1158 SpiStrobe(CC1101_SIDLE);
1159 trxstate=0;
1160}
1161/****************************************************************
1162*FUNCTION NAME:goSleep
1163*FUNCTION :set cc1101 Sleep on
1164*INPUT :none
1165*OUTPUT :none
1166****************************************************************/
1167void ELECHOUSE_CC1101::goSleep(void){
1168 trxstate=0;
1169 SpiStrobe(0x36);//Exit RX / TX, turn off frequency synthesizer and exit
1170 SpiStrobe(0x39);//Enter power down mode when CSn goes high.
1171}
1172/****************************************************************
1173*FUNCTION NAME:Char direct SendData
1174*FUNCTION :use CC1101 send data
1175*INPUT :txBuffer: data array to send; size: number of data to send, no more than 61
1176*OUTPUT :none
1177****************************************************************/
1178void ELECHOUSE_CC1101::SendData(char *txchar)
1179{
1180int len = strlen(txchar);
1181byte chartobyte[len];
1182for (int i = 0; i<len; i++){chartobyte[i] = txchar[i];}
1183SendData(chartobyte,len);
1184}
1185/****************************************************************
1186*FUNCTION NAME:SendData
1187*FUNCTION :use CC1101 send data
1188*INPUT :txBuffer: data array to send; size: number of data to send, no more than 61
1189*OUTPUT :none
1190****************************************************************/
1191void ELECHOUSE_CC1101::SendData(byte *txBuffer,byte size)
1192{
1193 SpiWriteReg(CC1101_TXFIFO,size);
1194 SpiWriteBurstReg(CC1101_TXFIFO,txBuffer,size); //write data to send
1195 SpiStrobe(CC1101_SIDLE);
1196 SpiStrobe(CC1101_STX); //start send
1197 while (!digitalRead(GDO0)); // Wait for GDO0 to be set -> sync transmitted
1198 while (digitalRead(GDO0)); // Wait for GDO0 to be cleared -> end of packet
1199 SpiStrobe(CC1101_SFTX); //flush TXfifo
1200 trxstate=1;
1201}
1202/****************************************************************
1203*FUNCTION NAME:Char direct SendData
1204*FUNCTION :use CC1101 send data without GDO
1205*INPUT :txBuffer: data array to send; size: number of data to send, no more than 61
1206*OUTPUT :none
1207****************************************************************/
1208void ELECHOUSE_CC1101::SendData(char *txchar,int t)
1209{
1210int len = strlen(txchar);
1211byte chartobyte[len];
1212for (int i = 0; i<len; i++){chartobyte[i] = txchar[i];}
1213SendData(chartobyte,len,t);
1214}
1215/****************************************************************
1216*FUNCTION NAME:SendData
1217*FUNCTION :use CC1101 send data without GDO
1218*INPUT :txBuffer: data array to send; size: number of data to send, no more than 61
1219*OUTPUT :none
1220****************************************************************/
1221void ELECHOUSE_CC1101::SendData(byte *txBuffer,byte size,int t)
1222{
1223 SpiWriteReg(CC1101_TXFIFO,size);
1224 SpiWriteBurstReg(CC1101_TXFIFO,txBuffer,size); //write data to send
1225 SpiStrobe(CC1101_SIDLE);
1226 SpiStrobe(CC1101_STX); //start send
1227 delay(t);
1228 SpiStrobe(CC1101_SFTX); //flush TXfifo
1229 trxstate=1;
1230}
1231/****************************************************************
1232*FUNCTION NAME:Check CRC
1233*FUNCTION :none
1234*INPUT :none
1235*OUTPUT :none
1236****************************************************************/
1237bool ELECHOUSE_CC1101::CheckCRC(void){
1238byte lqi=SpiReadStatus(CC1101_LQI);
1239bool crc_ok = bitRead(lqi,7);
1240if (crc_ok == 1){
1241return 1;
1242}else{
1243SpiStrobe(CC1101_SFRX);
1244SpiStrobe(CC1101_SRX);
1245return 0;
1246}
1247}
1248/****************************************************************
1249*FUNCTION NAME:CheckRxFifo
1250*FUNCTION :check receive data or not
1251*INPUT :none
1252*OUTPUT :flag: 0 no data; 1 receive data
1253****************************************************************/
1254bool ELECHOUSE_CC1101::CheckRxFifo(int t){
1255if(trxstate!=2){SetRx();}
1256if(SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO){
1257delay(t);
1258return 1;
1259}else{
1260return 0;
1261}
1262}
1263/****************************************************************
1264*FUNCTION NAME:CheckReceiveFlag
1265*FUNCTION :check receive data or not
1266*INPUT :none
1267*OUTPUT :flag: 0 no data; 1 receive data
1268****************************************************************/
1269byte ELECHOUSE_CC1101::CheckReceiveFlag(void)
1270{
1271 if(trxstate!=2){SetRx();}
1272 if(digitalRead(GDO0)) //receive data
1273 {
1274 while (digitalRead(GDO0));
1275 return 1;
1276 }
1277 else // no data
1278 {
1279 return 0;
1280 }
1281}
1282/****************************************************************
1283*FUNCTION NAME:ReceiveData
1284*FUNCTION :read data received from RXfifo
1285*INPUT :rxBuffer: buffer to store data
1286*OUTPUT :size of data received
1287****************************************************************/
1288byte ELECHOUSE_CC1101::ReceiveData(byte *rxBuffer)
1289{
1290 byte size;
1291 byte status[2];
1292
1293 if(SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO)
1294 {
1295 size=SpiReadReg(CC1101_RXFIFO);
1296 SpiReadBurstReg(CC1101_RXFIFO,rxBuffer,size);
1297 SpiReadBurstReg(CC1101_RXFIFO,status,2);
1298 SpiStrobe(CC1101_SFRX);
1299 SpiStrobe(CC1101_SRX);
1300 return size;
1301 }
1302 else
1303 {
1304 SpiStrobe(CC1101_SFRX);
1305 SpiStrobe(CC1101_SRX);
1306 return 0;
1307 }
1308}
1309ELECHOUSE_CC1101 ELECHOUSE_cc1101;