CC1101 async. mode
Zum Empfang / Senden und analysieren diverser Funkprotokolle im 433/868Mhz Band brauchte ich eine geeignete Hardware.
Da noch diverse ESP8266 und CC1101 Funkmodule vorhanden waren, wurden diese genutzt.
Der asynchronous transparent mode ist nötig, um an die Rohdaten des empfangenen Signals zu kommen. Der CC1101 ist somit nicht für das Packethandling (Länge, Preamble, Sync etc.) zuständig, sondern er leitet die Daten einfach nur durch oder sendet die anliegenden Daten direkt aus.
Die eigentliche Datenverarbeitung muss also im ESP geschehen. So lassen sich eigene / herstellerspezifische Protokolle selber implementieren.
Um den Transceiver am ESP nutzen zu können verwende ich diese Library
Sketches schreibe ich in der Arduino IDE.
Man muss in der cc1101.h Datei die Register des Moduls konfigurieren um den asynchronous Mode nutzen zu können.
Pin GDO0 ist TX Input, GDO2 ist RX Output.
Maßgeblich sind folgende Register zu nennen:
#define CC1101_DEFVAL_IOCFG2 0x0D // GDO2 Output Pin Configuration / TX #define CC1101_DEFVAL_IOCFG1 0x2E // GDO1 Output Pin Configuration #define CC1101_DEFVAL_IOCFG0 0x2D // GDO0 Output Pin Configuration / RX
Schaltplan:
So sieht das ganze im Moment als Versuchsaufbau aus. Das ESP dev.Board ist ein „Witty-Cloud Modul“.
Hi!
Do you have a working arduino sketch of a cc1101 receiving (433Mhz) raw data in async mode?
I can’t manage to get it to work!
/ Alexander
You can easily modify this code:
*/// connect data pin of rx433 module to a pin that can handle hardware interrupts
// with an Arduino UNO this is digital I/O pin 2 or 3 only
#define RX433DATAPIN 2
// hardware interrupt connected to the pin
// with Arduino UNO interrupt-0 belongs to pin-2, interrupt-1 to pin-3
#define RX433INTERRUPT 0
// Set speed of serial in Arduino IDE to the following value
#define SERIALSPEED 115200
// Now make some suggestions about pulse lengths that may be detected
// minimum duration (microseconds) of the start pulse
#define MINSTARTPULSE 740
// minimum duration (microseconds) of a short bit pulse
#define MINBITPULSE 250
// minimum duration (microseconds) of a HIGH pulse between valid bits
#define MINHITIME 50
// variance between pulses that should have the same duration
#define PULSEVARIANCE 250
// minimum count of data bit pulses following the start pulse
#define MINPULSECOUNT 40
// maximum count of data bit pulses following the start pulse
#define MAXPULSECOUNT 70
// buffer sizes for buffering pulses in the interrupt handler
#define PBSIZE 216
void setup()
{
Serial.begin(115200);
Serial.println();
Serial.println("Start!");
pinMode(RX433DATAPIN, INPUT);
attachInterrupt(RX433INTERRUPT, rx433Handler, CHANGE);
}
volatile unsigned int pulsbuf[PBSIZE]; // ring buffer storing LOW pulse lengths
volatile unsigned int hibuf[PBSIZE]; // ring buffer storing HIGH pulse lengths
unsigned int validpulsbuf[MAXPULSECOUNT]; // linear buffer storing valid LOW pulses
unsigned int validhibuf[MAXPULSECOUNT]; // linear buffer storing valid HIGH pulses
volatile byte pbread,pbwrite; // read and write index into ring buffer
void rx433Handler()
{
static long rx433LineUp, rx433LineDown;
long LowVal, HighVal;
int rx433State = digitalRead(RX433DATAPIN); // current pin state
if (rx433State) // pin is now HIGH
{
rx433LineUp=micros(); // line went HIGH after being LOW at this time
LowVal=rx433LineUp - rx433LineDown; // calculate the LOW pulse time
if (LowVal>MINBITPULSE)
{ // store pulse in ring buffer only if duration is longer than MINBITPULSE
// To be able to store startpulses of more than Maxint duration, we dont't store the actual time,
// but we store MINSTARTPULSE+LowVal/10, be sure to calculate back showing the startpulse length!
if (LowVal>MINSTARTPULSE) LowVal=MINSTARTPULSE+LowVal/10; // we will store this as unsigned int, so do range checking
pulsbuf[pbwrite]=LowVal; // store the LOW pulse length
pbwrite++; // advance write pointer in ringbuffer
if (pbwrite>=PBSIZE) pbwrite=0; // ring buffer is at its end
}
}
else
{
rx433LineDown=micros(); // line went LOW after being HIGH
HighVal=rx433LineDown - rx433LineUp; // calculate the HIGH pulse time
if (HighVal>31999) HighVal=31999; // we will store this as unsigned int
hibuf[pbwrite]=HighVal; // store the HIGH pulse length
}
}
boolean counting;
byte i,counter;
int startBitDurationL,startBitDurationH,shortBitDuration,longBitDuration;
void showBuffer()=PBSIZE) pbread=0;shortBitDuration)&&(lowtime
// this function will show the results on the serial monitor
// output will be shown if more bits than MINPULSECOUNT have been collected
{
long sum;
int avg;
sum=0;
if (counter>=MINPULSECOUNT)
{ // only show buffer contents if it has enough bits in it
Serial.println();
Serial.print("Start Bit L: "); Serial.print((startBitDurationL-MINSTARTPULSE)*10L);
Serial.print(" H: ");Serial.println(startBitDurationH);
Serial.print("Data Bits: ");Serial.println(counter);
Serial.print("L: ");
for (i=0;i
sei(); // Interrupts on again
if (lowtime>MINSTARTPULSE) // we found a valid startbit!
{
if (counting) showBuffer(); // new buffer starts while old is still counting, show it first
startBitDurationL=lowtime;
startBitDurationH=hitime;
counting=true; // then start collecting bits
counter=0; // no data bits yet
}
else if (counting && (counter==0)) // we now see the first data bit
{ // this may be a 0-bit or a 1-bit, so make some assumption about max/min lengths of data bits that will follow
shortBitDuration=lowtime/2;
if (shortBitDuration
I used it, with my cc1101 wiring for decoding jarolift messages.
Hi Steffen,
der Sketch ausschnitt von Dir ist leider abgeschnitten.
Könntest DU den bitte vervollständigen oder evtl sogar zum Download anbieten ?
Ich habe hier ein Funklichtschalter (livolo) auf 433mhz und da möchte ich die SIgnale mir anschauen.
sduino mit fhem kann dieses leider nicht, da habe ich am laufen.
Es gibt eine Lösung auf Arduino Nano mit RX/TX Module.
Aber der ESP mit CC1101 wäre viel schicker 😉
Wäre cool von Dir.
Danke und Gruß Andreas
Hallo,
ich wäre auch an dem Gesamtcode interessiert.
Gruss – Pewei
Ich bin auch daran interessiert, den vollständigen Code zu sehen. Vor allem, wenn die Möglichkeit besteht, die gespeicherten Rohdaten zu senden.
Ich habe ein automatisiertes Garagentor, das ich vom Smartphone aus steuern möchte, ich möchte nicht die Zeit damit verbringen, das Übertragungsprotokoll zu analysieren und anzuwenden, es wäre toll, das Signal direkt kopieren zu können.
Hallo,
Ich wäre auch sehr sehr am Code Interessiert könntest Du Ihn bitte freigeben