This thread has been locked.
If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.
Hello
I'm searching a working firmware for use CC1101 on Arduino
I have acquired Panstamp module but for now they do not work well..
Then I have found ELECHOUSE library that are more intuitive and I'm trying to develop firmware.
I need a TI ARDUINO class that work
Thankls
Hi
I have try to write the program following some example found on Google as you suggest http://labalec.fr/erwan/?p=497
It compile and seem to run but on SmartRF I don't see no segnal
Could you check if I send a working configuration?
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
#include <SPI.h>
//*********************************************************************************************
// INDIRIZZI REGISTRI DI COMUNICAZIONE E LORO SIGNIFICATO
//*********************************************************************************************
#define CC1101_IOCFG2 0x00 // GDO2 output pin configuration
#define CC1101_IOCFG1 0x01 // GDO1 output pin configuration
#define CC1101_IOCFG0 0x02 // GDO0 output pin configuration
#define CC1101_FIFOTHR 0x03 // RX FIFO and TX FIFO thresholds
#define CC1101_SYNC1 0x04 // Sync word, high INT8U
#define CC1101_SYNC0 0x05 // Sync word, low INT8U
#define CC1101_PKTLEN 0x06 // Packet length
#define CC1101_PKTCTRL1 0x07 // Packet automation control
#define CC1101_PKTCTRL0 0x08 // Packet automation control
#define CC1101_ADDR 0x09 // Device address
#define CC1101_CHANNR 0x0A // Channel number
#define CC1101_FSCTRL1 0x0B // Frequency synthesizer control
#define CC1101_FSCTRL0 0x0C // Frequency synthesizer control
#define CC1101_FREQ2 0x0D // Frequency control word, high INT8U
#define CC1101_FREQ1 0x0E // Frequency control word, middle INT8U
#define CC1101_FREQ0 0x0F // Frequency control word, low INT8U
#define CC1101_MDMCFG4 0x10 // Modem configuration
#define CC1101_MDMCFG3 0x11 // Modem configuration
#define CC1101_MDMCFG2 0x12 // Modem configuration
#define CC1101_MDMCFG1 0x13 // Modem configuration
#define CC1101_MDMCFG0 0x14 // Modem configuration
#define CC1101_DEVIATN 0x15 // Modem deviation setting
#define CC1101_MCSM2 0x16 // Main Radio Control State Machine configuration
#define CC1101_MCSM1 0x17 // Main Radio Control State Machine configuration
#define CC1101_MCSM0 0x18 // Main Radio Control State Machine configuration
#define CC1101_FOCCFG 0x19 // Frequency Offset Compensation configuration
#define CC1101_BSCFG 0x1A // Bit Synchronization configuration
#define CC1101_AGCCTRL2 0x1B // AGC control
#define CC1101_AGCCTRL1 0x1C // AGC control
#define CC1101_AGCCTRL0 0x1D // AGC control
#define CC1101_WOREVT1 0x1E // High INT8U Event 0 timeout
#define CC1101_WOREVT0 0x1F // Low INT8U Event 0 timeout
#define CC1101_WORCTRL 0x20 // Wake On Radio control
#define CC1101_FREND1 0x21 // Front end RX configuration
#define CC1101_FREND0 0x22 // Front end TX configuration
#define CC1101_FSCAL3 0x23 // Frequency synthesizer calibration
#define CC1101_FSCAL2 0x24 // Frequency synthesizer calibration
#define CC1101_FSCAL1 0x25 // Frequency synthesizer calibration
#define CC1101_FSCAL0 0x26 // Frequency synthesizer calibration
#define CC1101_RCCTRL1 0x27 // RC oscillator configuration
#define CC1101_RCCTRL0 0x28 // RC oscillator configuration
#define CC1101_FSTEST 0x29 // Frequency synthesizer calibration control
#define CC1101_PTEST 0x2A // Production test
#define CC1101_AGCTEST 0x2B // AGC test
#define CC1101_TEST2 0x2C // Various test settings
#define CC1101_TEST1 0x2D // Various test settings
#define CC1101_TEST0 0x2E // Various test settings
//*********************************************************************************************
//*********************************************************************************************
// INDIRIZZI STROBE COMMANDS E LORO SIGNIFICATO
//*********************************************************************************************
#define CC1101_SRES 0x30 // Reset chip.
#define CC1101_SFSTXON 0x31 // Enable and calibrate frequency synthesizer (if MCSM0.FS_AUTOCAL=1).
#define CC1101_SXOFF 0x32 // Turn off crystal oscillator.
#define CC1101_SCAL 0x33 // Calibrate frequency synthesizer and turn it off
#define CC1101_SRX 0x34 // Enable RX. Perform calibration first if coming from IDLE and
#define CC1101_STX 0x35 // In IDLE state: Enable TX. Perform calibration first if
#define CC1101_SIDLE 0x36 // Exit RX / TX, turn off frequency synthesizer and exit
#define CC1101_SAFC 0x37 // Perform AFC adjustment of the frequency synthesizer
#define CC1101_SWOR 0x38 // Start automatic RX polling sequence (Wake-on-Radio)
#define CC1101_SPWD 0x39 // Enter power down mode when CSn goes high.
#define CC1101_SFRX 0x3A // Flush the RX FIFO buffer.
#define CC1101_SFTX 0x3B // Flush the TX FIFO buffer.
#define CC1101_SWORRST 0x3C // Reset real time clock.
#define CC1101_SNOP 0x3D // No operation. May be used to pad strobe commands to two
//*********************************************************************************************
//*********************************************************************************************
// INDIRIZZI "STATUS REGISTER"
//*********************************************************************************************
#define CC1101_PARTNUM 0x30
#define CC1101_VERSION 0x31
#define CC1101_FREQEST 0x32
#define CC1101_LQI 0x33
#define CC1101_RSSI 0x34
#define CC1101_MARCSTATE 0x35
#define CC1101_WORTIME1 0x36
#define CC1101_WORTIME0 0x37
#define CC1101_PKTSTATUS 0x38
#define CC1101_VCO_VC_DAC 0x39
#define CC1101_TXBYTES 0x3A
#define CC1101_RXBYTES 0x3B
//*********************************************************************************************
//*********************************************************************************************
//INDIRIZZI DI: PATABLE - TXFIFO - RXFIFO
//*********************************************************************************************
#define CC1101_PATABLE 0x3E
#define CC1101_TXFIFO 0x3F
#define CC1101_RXFIFO 0x3F
//*********************************************************************************************
//*********************************************************************************************
//VALORE MASCHERE COMMAND TYPE
//*********************************************************************************************
#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
//*********************************************************************************************
//*********************************************************************************************
//CONFIGURAZIONE PIN ATMEGA 328
//*********************************************************************************************
#define SCK_PIN 13 //ATMega328p
#define MISO_PIN 12 //ATMega328p
#define MOSI_PIN 11 //ATMega328p
#define SS_PIN 10 //ATMega328p
#define GDO0 2 //CC1101
#define GDO2 9 //CC1101 (NON USATO)
//*********************************************************************************************
//***************************************************************
//Inizio File.h
//***************************************************************
class HILTRON_CC1101
{
/****************************************************************/
byte PaTabel[8] = {0x60 ,0x60 ,0x60 ,0x60 ,0x60 ,0x60 ,0x60 ,0x60};
/****************************************************************/
public:
void CONFIG_SPI(void); //Initialize SPI communication and GDO0 line
void CONFIG_GDO (void);
void CONFIG_CC1101_RF(void); //Initialize CC1101 with my specific configuration
void RESET_CC1101(void); //Reset our chip CC1101
void Strobe_CC1101(byte strobe);
void Write_CC1101_Register(byte addr, byte value);
void Write_CC1101_BurstRegister(byte addr, byte *buffer, byte num);
byte Read_CC1101_Register(byte addr);
void Read_CC1101_BurstRegister(byte addr, byte *buffer, byte num);
byte Read_CC1101_Status(byte addr);
void Send_Data(byte *txBuffer, byte size);
byte Receive_Data(byte *rxBuffer);
void SetReceive(void);
byte CheckReceiveFlag(void);
};
//***************************************************************
//Fine File.h
//***************************************************************
//###############################################################
//Inizio File cpp
//###############################################################
/****************************************************************
*FUNCTION NAME:SPI_Initialize
*FUNCTION :spi initialization
*INPUT :none
*OUTPUT :none
****************************************************************/
void HILTRON_CC1101::CONFIG_SPI(void)
{
pinMode(SS_PIN, OUTPUT);
SPI.setClockDivider(SPI_CLOCK_DIV128);
SPI.setDataMode(SPI_MODE0);
SPI.setBitOrder(MSBFIRST);
SPI.begin();
}
/****************************************************************
*FUNCTION NAME: GDO_Set()
*FUNCTION : set GDO0,GDO2 pin
*INPUT : none
*OUTPUT : none
****************************************************************/
void HILTRON_CC1101::CONFIG_GDO (void)
{
pinMode(GDO0, INPUT);
pinMode(GDO2, INPUT);
}
/****************************************************************
*FUNCTION NAME:Reset
*FUNCTION :CC1101 reset //details refer datasheet of CC1101/CC1100//
*INPUT :none
*OUTPUT :none
****************************************************************/
void HILTRON_CC1101::RESET_CC1101 (void)
{
digitalWrite(SS_PIN, LOW);
SPI.transfer(CC1101_SRES);
digitalWrite(SS_PIN, HIGH);
}
/****************************************************************
*FUNCTION NAME:SpiWriteReg
*FUNCTION :CC1101 write data to register
*INPUT :addr: register address; value: register value
*OUTPUT :none
****************************************************************/
void HILTRON_CC1101::Write_CC1101_Register(byte addr, byte value)
{
digitalWrite(SS_PIN, LOW);
SPI.transfer(addr);
SPI.transfer(value);
digitalWrite(SS_PIN, HIGH);
}
/****************************************************************
*FUNCTION NAME:SPI_WriteBurstRegister
*FUNCTION :CC1101 write burst data to register
*INPUT :addr: register address; buffer:register value array; num:number to write
*OUTPUT :none
****************************************************************/
void HILTRON_CC1101::Write_CC1101_BurstRegister(byte addr, byte *buffer, byte num)
{
byte i;
byte temp = addr | WRITE_BURST;
digitalWrite(SS_PIN, LOW);
SPI.transfer(temp);
for (i = 0; i < num; i++)
{
SPI.transfer(buffer[i]);
}
digitalWrite(SS_PIN, HIGH);
}
/****************************************************************
*FUNCTION NAME:SPI_Strobe
*FUNCTION :CC1101 Strobe
*INPUT :strobe: command; //refer define in CC1101.h//
*OUTPUT :none
****************************************************************/
void HILTRON_CC1101::Strobe_CC1101(byte strobe)
{
digitalWrite(SS_PIN, LOW);
SPI.transfer(strobe);
digitalWrite(SS_PIN, HIGH);
}
/****************************************************************
*FUNCTION NAME:SPI_ReadRegister
*FUNCTION :CC1101 read data from register
*INPUT :addr: register address
*OUTPUT :register value
****************************************************************/
byte HILTRON_CC1101::Read_CC1101_Register(byte addr)
{
byte value;
byte temp = addr|READ_SINGLE;
digitalWrite(SS_PIN, LOW);
Serial.println(temp);
SPI.transfer(temp);
value = SPI.transfer(0);
digitalWrite(SS_PIN, HIGH);
return value;
}
/****************************************************************
*FUNCTION NAME:SPI_ReadBurstRegister
*FUNCTION :CC1101 read burst data from register
*INPUT :addr: register address; buffer:array to store register value; num: number to read
*OUTPUT :none
****************************************************************/
void HILTRON_CC1101::Read_CC1101_BurstRegister(byte addr, byte *buffer, byte num)
{
byte i;
byte temp = addr | READ_BURST;
digitalWrite(SS_PIN, LOW);
SPI.transfer(temp);
for(i=0;i<num;i++)
{
buffer[i]= SPI.transfer(0);;
}
digitalWrite(SS_PIN, HIGH);
}
/****************************************************************
*FUNCTION NAME:SpiReadStatus
*FUNCTION :CC1101 read status register
*INPUT :addr: register address
*OUTPUT :status value
****************************************************************/
byte HILTRON_CC1101::Read_CC1101_Status(byte addr)
{
byte value;
byte temp = addr | READ_BURST;
digitalWrite(SS_PIN, LOW);
SPI.transfer(temp);
value= SPI.transfer(value);
digitalWrite(SS_PIN, HIGH);
return value;
}
/****************************************************************
*FUNCTION NAME:SET_my_RF_Configuration
*FUNCTION :CC1101 register config //details refer datasheet of CC1101/CC1100//
*INPUT :none
*OUTPUT :none
****************************************************************/
void HILTRON_CC1101::CONFIG_CC1101_RF(void)
{
/*
//ORIGINALE
Write_CC1101_Register(CC1101_FSCTRL1, 0x08);
Write_CC1101_Register(CC1101_FSCTRL0, 0x00);
Write_CC1101_Register(CC1101_FREQ2, 0x10);
Write_CC1101_Register(CC1101_FREQ1, 0xA7);
Write_CC1101_Register(CC1101_FREQ0, 0x62);
Write_CC1101_Register(CC1101_MDMCFG4, 0x5B);
Write_CC1101_Register(CC1101_MDMCFG3, 0xF8);
Write_CC1101_Register(CC1101_MDMCFG2, 0x03);
Write_CC1101_Register(CC1101_MDMCFG1, 0x22);
Write_CC1101_Register(CC1101_MDMCFG0, 0xF8);
Write_CC1101_Register(CC1101_CHANNR, 0x00);
Write_CC1101_Register(CC1101_DEVIATN, 0x47);
Write_CC1101_Register(CC1101_FREND1, 0xB6);
Write_CC1101_Register(CC1101_FREND0, 0x10);
Write_CC1101_Register(CC1101_MCSM0 , 0x18);
Write_CC1101_Register(CC1101_FOCCFG, 0x1D);
Write_CC1101_Register(CC1101_BSCFG, 0x1C);
Write_CC1101_Register(CC1101_AGCCTRL2, 0xC7);
Write_CC1101_Register(CC1101_AGCCTRL1, 0x00);
Write_CC1101_Register(CC1101_AGCCTRL0, 0xB2);
Write_CC1101_Register(CC1101_FSCAL3, 0xEA);
Write_CC1101_Register(CC1101_FSCAL2, 0x2A);
Write_CC1101_Register(CC1101_FSCAL1, 0x00);
Write_CC1101_Register(CC1101_FSCAL0, 0x11);
Write_CC1101_Register(CC1101_FSTEST, 0x59);
Write_CC1101_Register(CC1101_TEST2, 0x81);
Write_CC1101_Register(CC1101_TEST1, 0x35);
Write_CC1101_Register(CC1101_TEST0, 0x09);
Write_CC1101_Register(CC1101_IOCFG2, 0x0B);
Write_CC1101_Register(CC1101_IOCFG0, 0x06);
Write_CC1101_Register(CC1101_PKTLEN, 0x3D);
Write_CC1101_BurstRegister(CC1101_PATABLE,PaTabel,8);
*/
//DATA RATE 4.8 DEV 25.4 MOD GFSK BW 100k
Write_CC1101_Register(CC1101_IOCFG1, 0x1E);
Write_CC1101_Register(CC1101_IOCFG0, 0x06);
Write_CC1101_Register(CC1101_FIFOTHR, 0x40);
Write_CC1101_Register(CC1101_SYNC1, 0x0C);
Write_CC1101_Register(CC1101_SYNC0, 0x00);
Write_CC1101_Register(CC1101_PKTLEN, 0x00);
Write_CC1101_Register(CC1101_PKTCTRL0, 0x05);
Write_CC1101_Register(CC1101_FSCTRL1, 0x06);
Write_CC1101_Register(CC1101_FSCTRL0, 0x08);
Write_CC1101_Register(CC1101_FREQ2, 0x21);
Write_CC1101_Register(CC1101_FREQ1, 0x62);
Write_CC1101_Register(CC1101_FREQ0, 0x76);
Write_CC1101_Register(CC1101_MDMCFG4, 0xC7);
Write_CC1101_Register(CC1101_MDMCFG3, 0x83);
Write_CC1101_Register(CC1101_MDMCFG2, 0x13);
Write_CC1101_Register(CC1101_MDMCFG1, 0x03);
Write_CC1101_Register(CC1101_MDMCFG0, 0x38);
Write_CC1101_Register(CC1101_DEVIATN, 0x40);
Write_CC1101_Register(CC1101_MCSM2, 0xD4);
Write_CC1101_Register(CC1101_MCSM0, 0x18);
Write_CC1101_Register(CC1101_FOCCFG, 0x16);
Write_CC1101_Register(CC1101_BSCFG, 0xD4);
Write_CC1101_Register(CC1101_AGCCTRL2, 0x43);
Write_CC1101_Register(CC1101_AGCCTRL1, 0xF8);
Write_CC1101_Register(CC1101_AGCCTRL0, 0x9A);
Write_CC1101_Register(CC1101_WOREVT1, 0xD4);
Write_CC1101_Register(CC1101_WOREVT0, 0x03);
Write_CC1101_Register(CC1101_WORCTRL, 0xFB);
Write_CC1101_Register(CC1101_FREND1, 0x98);
Write_CC1101_Register(CC1101_FSCAL3, 0xE9);
Write_CC1101_Register(CC1101_FSCAL2, 0x2A);
Write_CC1101_Register(CC1101_FSCAL1, 0x00);
Write_CC1101_Register(CC1101_FSCAL0, 0x1F);
Write_CC1101_Register(CC1101_RCCTRL1, 0x03);
Write_CC1101_Register(CC1101_RCCTRL0, 0xF8);
Write_CC1101_Register(CC1101_FSTEST, 0x9B);
Write_CC1101_Register(CC1101_PTEST, 0xD4);
Write_CC1101_Register(CC1101_AGCTEST, 0x03);
Write_CC1101_Register(CC1101_TEST2, 0x81);
Write_CC1101_Register(CC1101_TEST1, 0x35);
Write_CC1101_Register(CC1101_TEST0, 0x09);
Write_CC1101_Register(CC1101_PARTNUM, 0x98);
Write_CC1101_Register(CC1101_VERSION, 0x1E);
Write_CC1101_Register(CC1101_RSSI, 0x0C);
//Write_CC1101_Register(CC1101_RCCTRL1_STATUS, 0x08);
}
/****************************************************************
*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 HILTRON_CC1101::Send_Data(byte *txBuffer,byte size)
{
Write_CC1101_Register(CC1101_TXFIFO,size);
Write_CC1101_BurstRegister(CC1101_TXFIFO,txBuffer,size); //write data to send
Strobe_CC1101(CC1101_STX); //start send
while (!digitalRead(GDO0));
Serial.println("Sync inviato"); // Wait for GDO0 to be set -> sync transmitted
while (digitalRead(GDO0)); // Wait for GDO0 to be cleared -> end of packet
Serial.println("Fine Pacchetto");
Strobe_CC1101(CC1101_SFTX); //flush TXfifo
}
/****************************************************************
*FUNCTION NAME:SetReceive
*FUNCTION :set CC1101 to receive state
*INPUT :none
*OUTPUT :none
****************************************************************/
void HILTRON_CC1101::SetReceive(void)
{
Strobe_CC1101(CC1101_SRX);
}
/****************************************************************
*FUNCTION NAME:CheckReceiveFlag
*FUNCTION :check receive data or not
*INPUT :none
*OUTPUT :flag: 0 no data; 1 receive data
****************************************************************/
byte HILTRON_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 HILTRON_CC1101::Receive_Data(byte *rxBuffer)
{
byte size;
byte status[2];
if(Read_CC1101_Status(CC1101_RXBYTES) & BYTES_IN_RXFIFO)
{
size=Read_CC1101_Register(CC1101_RXFIFO);
Read_CC1101_BurstRegister(CC1101_RXFIFO,rxBuffer,size);
Read_CC1101_BurstRegister(CC1101_RXFIFO,status,2);
Strobe_CC1101(CC1101_SFRX);
return size;
}
else
{
Strobe_CC1101(CC1101_SFRX);
return 0;
}
}
//###############################################################
//Inizio File cpp
//###############################################################
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
//MAIN PROGRAM
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
HILTRON_CC1101 HILTRON_cc1101;
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
#define size 8
byte TX_buffer[size];
void setup() {
Serial.begin(9600);
Serial.println("CONFIGURO LA SPI");
HILTRON_cc1101.CONFIG_SPI();
Serial.println("CONFIGURO GDO");
HILTRON_cc1101.CONFIG_GDO();
digitalWrite(SS_PIN, HIGH);
//digitalWrite(SCK_PIN, HIGH);
//digitalWrite(MOSI_PIN, LOW);
Serial.println("RESETTO CC1101");
HILTRON_cc1101.RESET_CC1101();
Serial.println("CONFIGURO LA PARTE RADIO");
HILTRON_cc1101.CONFIG_CC1101_RF();
Serial.println("PREPARIO IL PACCHETTO DATI");
TX_buffer[1]=1;
TX_buffer[2]=2;
TX_buffer[3]=3;
TX_buffer[4]=4;
TX_buffer[5]=5;
TX_buffer[6]=6;
TX_buffer[7]=7;
TX_buffer[8]=8;
}
void loop() {
HILTRON_cc1101.Send_Data(TX_buffer,size);
Serial.println("PACCHETTO DATI INVIATO");
Serial.println("");
delay(1000);
}
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
//FINE MAIN PROGRAM
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
