Krolyxon
Commit a42feeb

Branches

Tags

Refs →

orion-rflibELECHOUSE_CC1101ELECHOUSE_CC1101_SRC_DRV.cpp

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