Aldo Bucio
Member
Greetings to all!
I have been trying to use the cc1101 module of texas instrument with my Teensy 4.0 through SPI, I have been based on the library proposed by ELECHOUSE
[https://github.com/simonmonk/CC1101_arduino]
I have read the instructions that you leave about the SPI library [https://www.pjrc.com/teensy/td_libs_SPI.html]
Because of this I know that I have to use the methods:
-SPI.beginTransaction ()
-SPI.transfer ()
-SPI.endTransaction ()
So I changed some lines from the ELECHOUSE library as I show below:
Transmitter code on Arduino:
Modified ELECHOUSE Library:
However, I have not managed to get it to work on the Teensy 4.0.
While debugging the code I noticed that the code hangs on the first call of SPI.transfer() on the Reset() function from ELECHOUSE library
I already read the following threads to try to fix my problem:
[https://forum.pjrc.com/threads/57507-SPI-on-Teensy-4]
[https://forum.pjrc.com/threads/61932-Different-SPI-Behavior-on-Teensy-4-0-and-4-1]
[https://forum.pjrc.com/threads/59906-SPI-MOSI-pulled-low-too-late-on-Teensy-4-0]
But I am still unsuccessful.
At the moment I do not have access to an oscilloscope due to the COVID-19 situation so I cannot do an analysis of the SPI signals.
It is worth mentioning that the library that I modified works on an Arduino nano and Arduino UNO, taking into account that the connections must be at 3.3v
It is also important to say that I am using the updated SPI library: [https://github.com/PaulStoffregen/SPI]
The connections on the Teensy 4.0 were direct due to the maximum voltage being 3.3v so I omitted the resistors
Please, help understand what I'm doing wrong
I have been trying to use the cc1101 module of texas instrument with my Teensy 4.0 through SPI, I have been based on the library proposed by ELECHOUSE
[https://github.com/simonmonk/CC1101_arduino]
I have read the instructions that you leave about the SPI library [https://www.pjrc.com/teensy/td_libs_SPI.html]
Because of this I know that I have to use the methods:
-SPI.beginTransaction ()
-SPI.transfer ()
-SPI.endTransaction ()
So I changed some lines from the ELECHOUSE library as I show below:
Transmitter code on Arduino:
Code:
#include <ELECHOUSE_CC1101.h>
#define size 2 //tamanio de buffer a mandar
const long int sgn = 32768; //0x8000; // B1000000000000000;// numero negativo
long int Byte1 = 0, Byte2 = 0;
byte data_Tx[size] = {0};
int tiempo = 20;
unsigned long timenow;
byte TX_buffer[size] = {0}; //inicializar
byte i;
//int x=0;
int x, y, z;
void setup() {
Serial.begin(9600);
pinMode(8,OUTPUT); // debugger
delay(1);
ELECHOUSE_cc1101.Init();
//Serial.println("Transmisor:");
}
void loop() {
Serial.println("EMPEZO");
x = -90;
Serial.println(x);
if (x < 0) {
x = (-1 * (x)) + sgn; // coloca el signo en el bit mas significativo
}
Byte1 = x & 255;//enmascaramiento de BYTE inferior
Byte2 = x & 65280; // enmascaramiento de BYTE superior
Byte2 = Byte2 >> 8; // haz un bitshift left de 8 posiciones para derechaM
data_Tx[0] = Byte1;//inferior
data_Tx[1] = Byte2;//superior
ELECHOUSE_cc1101.SendData(data_Tx, size);
delay(1000);
}
Modified ELECHOUSE Library:
Code:
/*
/*
This library was originally copyright of Michael at elechouse.com but permision was
granted by Wilson Shen on 2016-10-23 for me (Simon Monk) to uodate the code for Arduino 1.0+
and release the code on github under the MIT license.
Wilson Shen <elechouse@elechouse.com> 23 October 2016 at 02:08
To: Simon Monk
Thanks for your email.
You are free to put it in github and to do and change.
On Oct 22, 2016 10:07 PM, "Simon Monk" <srmonk@gmail.com> wrote:
Hi,
I'm Simon Monk, I'm currently writing the Electronics Cookbook for O'Reilly. I use your
ELECHOUSE_CC1101 library in a 'recipe'. Your library is by far the easiest to use of
the libraries for this device, but the .h and .cpp file both reference WProgram.h which
as replaced by Arduino.h in Arduino 1.0.
Rather than have to talk my readers through applying a fix to your library, I'd like
your permission to put the modified lib into Github and add an example from the book.
I would of course provide a link to your website in the book and mention that you can buy
the modules there. If its ok, I'd give the code an MIT OS license, to clarify its use.
Thanks for a great library,
Kind Regards,
Simon Monk.
*/
#include <ELECHOUSE_CC1101.h>
#include <Arduino.h>
#include <SPI.h> // For SPI functions
/****************************************************************/
#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
/****************************************************************/
byte PaTabel[8] = {0x60 ,0x60 ,0x60 ,0x60 ,0x60 ,0x60 ,0x60 ,0x60};
// byte PaTabel[8] = {0xC0 ,0xC0 ,0xC0 ,0xC0 ,0xC0 ,0xC0 ,0xC0 ,0xC0};
/****************************************************************
*FUNCTION NAME:SpiInit
*FUNCTION :spi communication initialization
*INPUT :none
*OUTPUT :none
****************************************************************/
void ELECHOUSE_CC1101::SpiInit(void)
{
// initialize the SPI pins
SPI.begin(); //
pinMode(SCK_PIN, OUTPUT);
pinMode(MOSI_PIN, OUTPUT);
pinMode(MISO_PIN, INPUT);
pinMode(SS_PIN, OUTPUT);
//Serial.println("SpiInit-CHECK");
// digitalWrite(8,1);
// enable SPI Master, MSB, SPI mode 0, FOSC/4
//SpiMode(0);
}
/****************************************************************
*FUNCTION NAME:SpiMode
*FUNCTION :set spi mode
*INPUT : config mode
(0<<CPOL) | (0 << CPHA) 0
(0<<CPOL) | (1 << CPHA) 1
(1<<CPOL) | (0 << CPHA) 2
(1<<CPOL) | (1 << CPHA) 3
*OUTPUT :none
****************************************************************/
void ELECHOUSE_CC1101::SpiMode(byte config)
{
byte tmp;
// enable SPI master with configuration byte specified
SPCR = 0;
SPCR = (config & 0x7F) | (1<<SPE) | (1<<MSTR);
tmp = SPSR;
tmp = SPDR;
}
/****************************************************************
*FUNCTION NAME:SpiTransfer
*FUNCTION :spi transfer
*INPUT :value: data to send
*OUTPUT :data to receive
****************************************************************/
byte ELECHOUSE_CC1101::SpiTransfer(byte value)
{
SPDR = value;
while (!(SPSR & (1<<SPIF))) ;
return SPDR;
}
/****************************************************************
*FUNCTION NAME: GDO_Set()
*FUNCTION : set GDO0,GDO2 pin
*INPUT : none
*OUTPUT : none
****************************************************************/
void ELECHOUSE_CC1101::GDO_Set (void)
{
pinMode(GDO0, INPUT);
pinMode(GDO2, INPUT);
//Serial.println("GDO_Set-CHECK");
// digitalWrite(8,1);
}
/****************************************************************
*FUNCTION NAME:Reset
*FUNCTION :CC1101 reset //details refer datasheet of CC1101/CC1100//
*INPUT :none
*OUTPUT :none
****************************************************************/
void ELECHOUSE_CC1101::Reset (void)
{
//digitalWrite(8,1);
digitalWrite(SS_PIN, LOW);
delay(1);
digitalWrite(SS_PIN, HIGH);
delay(1);
SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0)); //
digitalWrite(SS_PIN, LOW);
//delayMicroseconds(2); // delay doesn't work
while(digitalRead(MISO_PIN));
//digitalWrite(8,1); //Just for debugging purposes
SPI.transfer(CC1101_SRES);//SpiTransfer(CC1101_SRES); // STUCK IN HERE
digitalWrite(8,1); //Just for debugging purposes
while(digitalRead(MISO_PIN));
digitalWrite(SS_PIN, HIGH);
SPI.endTransaction(); //
//Serial.println("Reset-CHECK");
}
/****************************************************************
*FUNCTION NAME:Init
*FUNCTION :CC1101 initialization
*INPUT :none
*OUTPUT :none
****************************************************************/
void ELECHOUSE_CC1101::Init(void)
{
SpiInit(); //spi initialization
GDO_Set(); //GDO set
digitalWrite(SS_PIN, HIGH);
digitalWrite(SCK_PIN, HIGH);
digitalWrite(MOSI_PIN, LOW);
Reset(); //CC1101 reset
RegConfigSettings(F_433); //CC1101 register config
SpiWriteBurstReg(CC1101_PATABLE,PaTabel,8); //CC1101 PATABLE config
}
/****************************************************************
*FUNCTION NAME:Init
*FUNCTION :CC1101 initialization
*INPUT :none
*OUTPUT :none
****************************************************************/
void ELECHOUSE_CC1101::Init(byte f)
{
SpiInit(); //spi initialization
GDO_Set(); //GDO set
digitalWrite(SS_PIN, HIGH);
digitalWrite(SCK_PIN, HIGH);
digitalWrite(MOSI_PIN, LOW);
Reset(); //CC1101 reset
RegConfigSettings(f); //CC1101 register config
SpiWriteBurstReg(CC1101_PATABLE,PaTabel,8); //CC1101 PATABLE config
}
/****************************************************************
*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)
{
SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0)); //
digitalWrite(SS_PIN, LOW);
while(digitalRead(MISO_PIN));
SPI.transfer(addr); // SpiTransfer(addr);
SPI.transfer(value); // SpiTransfer(value);
digitalWrite(SS_PIN, HIGH);
SPI.endTransaction(); //
}
/****************************************************************
*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;
temp = addr | WRITE_BURST;
SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0)); //
digitalWrite(SS_PIN, LOW);
while(digitalRead(MISO_PIN));
SPI.transfer(temp); //SpiTransfer(temp);
for (i = 0; i < num; i++)
{
SPI.transfer(buffer[i]);//SpiTransfer(buffer[i]);
}
digitalWrite(SS_PIN, HIGH);
SPI.endTransaction(); //
// Serial.println("SpiWriteBurstReg-CHECK"); // NO PONERLO PORQUE DESEQUILIBRA LOS TIEMPOS
}
/****************************************************************
*FUNCTION NAME:SpiStrobe
*FUNCTION :CC1101 Strobe
*INPUT :strobe: command; //refer define in CC1101.h//
*OUTPUT :none
****************************************************************/
void ELECHOUSE_CC1101::SpiStrobe(byte strobe)
{
SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0)); //
digitalWrite(SS_PIN, LOW);
while(digitalRead(MISO_PIN));
SPI.transfer(strobe); //SpiTransfer(strobe);
digitalWrite(SS_PIN, HIGH);
SPI.endTransaction(); //
// Serial.println("SpiStrobe-CHECK");
}
/****************************************************************
*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;
temp = addr|READ_SINGLE;
SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0)); //
digitalWrite(SS_PIN, LOW);
while(digitalRead(MISO_PIN));
SPI.transfer(temp); //SpiTransfer(temp);
value = SPI.transfer(0); //SpiTransfer(0);
digitalWrite(SS_PIN, HIGH);
SPI.endTransaction(); //
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;
temp = addr | READ_BURST;
SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0)); //
digitalWrite(SS_PIN, LOW);
while(digitalRead(MISO_PIN));
SPI.transfer(temp); //SpiTransfer(temp);
for(i=0;i<num;i++)
{
buffer[i]=SPI.transfer(0); //SpiTransfer(0);
}
digitalWrite(SS_PIN, HIGH);
SPI.endTransaction(); //
}
/****************************************************************
*FUNCTION NAME:SpiReadStatus
*FUNCTION :CC1101 read status register
*INPUT :addr: register address
*OUTPUT :status value
****************************************************************/
byte ELECHOUSE_CC1101::SpiReadStatus(byte addr)
{
byte value,temp;
temp = addr | READ_BURST;
SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0)); //
digitalWrite(SS_PIN, LOW);
while(digitalRead(MISO_PIN));
SPI.transfer(temp); //SpiTransfer(temp);
value = SPI.transfer(0); //SpiTransfer(0);
digitalWrite(SS_PIN, HIGH);
SPI.endTransaction(); //
return value;
}
/****************************************************************
*FUNCTION NAME:RegConfigSettings
*FUNCTION :CC1101 register config //details refer datasheet of CC1101/CC1100//
*INPUT :none
*OUTPUT :none
****************************************************************/
void ELECHOUSE_CC1101::RegConfigSettings(byte f)
{
SpiWriteReg(CC1101_FSCTRL1, 0x08);
SpiWriteReg(CC1101_FSCTRL0, 0x00);
switch(f)
{
case F_868:
SpiWriteReg(CC1101_FREQ2, F2_868);
SpiWriteReg(CC1101_FREQ1, F1_868);
SpiWriteReg(CC1101_FREQ0, F0_868);
break;
case F_902:
SpiWriteReg(CC1101_FREQ2, F2_902);
SpiWriteReg(CC1101_FREQ1, F1_902);
SpiWriteReg(CC1101_FREQ0, F0_902);
break;
case F_433:
SpiWriteReg(CC1101_FREQ2, F2_433);
SpiWriteReg(CC1101_FREQ1, F1_433);
SpiWriteReg(CC1101_FREQ0, F0_433);
break;
default: // F must be set
break;
}
SpiWriteReg(CC1101_MDMCFG4, 0x5B);
SpiWriteReg(CC1101_MDMCFG3, 0xF8);
SpiWriteReg(CC1101_MDMCFG2, 0x03);
SpiWriteReg(CC1101_MDMCFG1, 0x22);
SpiWriteReg(CC1101_MDMCFG0, 0xF8);
SpiWriteReg(CC1101_CHANNR, 0x00);
SpiWriteReg(CC1101_DEVIATN, 0x47);
SpiWriteReg(CC1101_FREND1, 0xB6);
SpiWriteReg(CC1101_FREND0, 0x10);
SpiWriteReg(CC1101_MCSM0 , 0x18);
SpiWriteReg(CC1101_FOCCFG, 0x1D);
SpiWriteReg(CC1101_BSCFG, 0x1C);
SpiWriteReg(CC1101_AGCCTRL2, 0xC7);
SpiWriteReg(CC1101_AGCCTRL1, 0x00);
SpiWriteReg(CC1101_AGCCTRL0, 0xB2);
SpiWriteReg(CC1101_FSCAL3, 0xEA);
SpiWriteReg(CC1101_FSCAL2, 0x2A);
SpiWriteReg(CC1101_FSCAL1, 0x00);
SpiWriteReg(CC1101_FSCAL0, 0x11);
SpiWriteReg(CC1101_FSTEST, 0x59);
SpiWriteReg(CC1101_TEST2, 0x81);
SpiWriteReg(CC1101_TEST1, 0x35);
SpiWriteReg(CC1101_TEST0, 0x09);
SpiWriteReg(CC1101_IOCFG2, 0x0B); //serial clock.synchronous to the data in synchronous serial mode
SpiWriteReg(CC1101_IOCFG0, 0x06); //asserts when sync word has been sent/received, and de-asserts at the end of the packet
SpiWriteReg(CC1101_PKTCTRL1, 0x04); //two status bytes will be appended to the payload of the packet,including RSSI LQI and CRC OK
//No address check
SpiWriteReg(CC1101_PKTCTRL0, 0x05); //whitening off;CRC Enable\A3\BBvariable length packets, packet length configured by the first byte after sync word
SpiWriteReg(CC1101_ADDR, 0x00); //address used for packet filtration.
SpiWriteReg(CC1101_PKTLEN, 0x3D); //61 bytes max length
Serial.println("RegConfigSettings-CHECK");
}
/****************************************************************
*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_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
//Serial.println("SendData-CHECK");
}
/****************************************************************
*FUNCTION NAME:SetReceive
*FUNCTION :set CC1101 to receive state
*INPUT :none
*OUTPUT :none
****************************************************************/
void ELECHOUSE_CC1101::SetReceive(void)
{
SpiStrobe(CC1101_SRX);
}
/****************************************************************
*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(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);
return size;
}
else
{
SpiStrobe(CC1101_SFRX);
return 0;
}
}
ELECHOUSE_CC1101 ELECHOUSE_cc1101;
However, I have not managed to get it to work on the Teensy 4.0.
While debugging the code I noticed that the code hangs on the first call of SPI.transfer() on the Reset() function from ELECHOUSE library
I already read the following threads to try to fix my problem:
[https://forum.pjrc.com/threads/57507-SPI-on-Teensy-4]
[https://forum.pjrc.com/threads/61932-Different-SPI-Behavior-on-Teensy-4-0-and-4-1]
[https://forum.pjrc.com/threads/59906-SPI-MOSI-pulled-low-too-late-on-Teensy-4-0]
But I am still unsuccessful.
At the moment I do not have access to an oscilloscope due to the COVID-19 situation so I cannot do an analysis of the SPI signals.
It is worth mentioning that the library that I modified works on an Arduino nano and Arduino UNO, taking into account that the connections must be at 3.3v
It is also important to say that I am using the updated SPI library: [https://github.com/PaulStoffregen/SPI]
The connections on the Teensy 4.0 were direct due to the maximum voltage being 3.3v so I omitted the resistors
Please, help understand what I'm doing wrong
Attachments
Last edited: