{"id":8848,"date":"2020-10-13T11:54:25","date_gmt":"2020-10-13T11:54:25","guid":{"rendered":"https:\/\/wolles-elektronikkiste.de\/own-radio-protocols"},"modified":"2024-09-20T19:52:33","modified_gmt":"2024-09-20T19:52:33","slug":"own-radio-protocols","status":"publish","type":"post","link":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols","title":{"rendered":"Own radio protocols"},"content":{"rendered":"\n

About this post<\/h2>\n\n

In the last articles I have explained how to control radio modules<\/a> and radio sockets<\/a> with the Arduino or other microcontrollers by means of suitable libraries. But does 433 MHz radio work without a library? Is it complicated to develop your own (simple) radio protocol? When you pay attention to a few things, it’s not very difficult and it’s also a lot of fun. I will present two concepts. I use simple 433 MHz transmitter and receiver modules as in the previous posts. Please do not forget to attach antennas to the modules. I probably don’t have to recreate a connection scheme for the Arduino: GND is connected with GND, VCC with 5 V and the data pin of the module is used as per the instructions in the respective sketch. For the transmitter side I used an Arduino Nano, on the receiver side a UNO.\u00a0<\/p>\n\n

\"Simple<\/a>
Simple “one-way” modules for 433 MHz<\/figcaption><\/figure>\n\n

Speed is required<\/h2>\n\n

Before I start, I might have to explain few things about “C”. Radio technology is so fast that the speed needed at which a pin status (HIGH or LOW) can be queried becomes quite relevant. Normally you use the digitalRead command, here e.g. to query the pin 5:<\/p>\r\n

pinStatus = digitalRead(5);<\/code><\/p>\r\n

The “C” spelling is synonymous, much faster, but also much more cryptic:<\/p>\r\n

pinStatus = PIND & (1<<PD5);<\/code><\/p>\r\n

I will perhaps go into more detail on the subject of ‘C’ in another post because there are also many other occasions where the ‘C’ spelling makes sense. Here I will only briefly explain what that means. “PD5” is a predefined constant with a value of 5 and stands for pin 5 on the PORTD of the ATmega328. This pin happens to be the digital pin 5 on Arduino. For example, the pin “PB<\/strong>5″ is Digitalpin 13 on Arduino. “1<<PD5” is a binary operation and means: shift the one five digits to the left. So, the 1 (00000001), is turned into 00100000.\u00a0<\/p>\r\n

PIND is the status register of the PORTD. If all pins are “LOW” the value of the PIND register is “00000000”. If only PD5 is “HIGH”, it is “00100000”. “&” is a binary “AND”. It compares bitwise the values on both sides. If both are the same, the result is TRUE and 1, respectively. If both are unequal, the result is FALSE or 0. And thus both of the above commands lead to the same result.\u00a0<\/p>\r\n

The following sketch shows that the spelling in “C” is much faster. I have queried the status of pin 5 with both commands 100000 times and measured the time required in milliseconds. Here is the sketch and the result:<\/p>\n\n

unsigned long numberOfReads = 100000;\r\nunsigned long startTime = 0;\r\nunsigned long readTimeLength = 0;\r\nbool pinStatus;\r\n\r\nvoid setup() {\r\n  Serial.begin(9600); \r\n  pinMode(5,INPUT); \r\n}\r\n\r\nvoid loop() {\r\n  startTime = millis();\r\n  for(unsigned long i=0; i<numberOfReads; i++){\r\n    pinStatus = digitalRead(5);\r\n  }\r\n  readTimeLength = millis() - startTime;\r\n  Serial.print(\"digitalRead: \");\r\n  Serial.print(readTimeLength);\r\n  Serial.print(\" ms \");\r\n  Serial.print(\" \/ \");\r\n  delay(1000);\r\n  \r\n  startTime = millis();\r\n  for(unsigned long i=0; i<numberOfReads; i++){\r\n    pinStatus = (PIND & (1<<PD5));\r\n  }\r\n  readTimeLength = millis() - startTime;\r\n  Serial.print(\"PIND Abfrage: \"); \r\n  Serial.print(readTimeLength);\r\n  Serial.println(\" ms\");\r\n  delay(5000);\r\n}<\/pre>\r\n
 <\/p>\n\n
\"For<\/figure>\n\n
Thus, the “C” command is about eight times faster. Per single query, the result is 3.45 microseconds compared to 0.44 microseconds.<\/p>\n\n
Lots of noise in the air<\/h2>\n\n
Actually, it sounds simple at first: On the transmitter side, a “HIGH” on the data pin leads to the sending of a signal. This creates a “HIGH” on the receiver side on the data pin and this can be evaluated in terms of time period. We are therefore not using modulation methods<\/a> here. Simple, but works.\u00a0<\/p>\r\n
The following sketch for the receiver side captures signals and measures their duration at pin 5. To measure times, most people like to use the “millis()” or “micros()” command. Another method for measuring very short periods of time has proven its worth. In a loop, the condition for the measurement is queried. As long as the cancellation condition is not met, the sketch waits for a short time (resolution) in the loop and then a counter is incremented. In the end, counter times resolution provides the duration.\u00a0<\/p>\n\n
const int resolution = 5;\r\nunsigned int counter; \r\n\r\nvoid setup(){\r\n  Serial.begin(9600);\r\n  DDRD = 0x00; \/\/ Arduino Pins D0 - D7 as input, \"C\" spelling\r\n  PORTD = 0x00; \/\/ Arduino Pins D0 - D7 are LOW, \"C\" spelling\r\n }\r\n\r\nvoid loop(){\r\n  counter = 0;\r\n  while(!(PIND & (1<<PD5))){\/* Wait for High*\/}\r\n  while((PIND & (1<<PD5))){ \/* Count High *\/\r\n    delayMicroseconds(resolution);\r\n    counter++;\r\n  }\r\n  Serial.print(counter);\r\n  Serial.print(\", \"); \r\n}<\/pre>\n\n
If you let the sketch run without having a transmitter switched on, you are amazed how many signals are detected anyway. But how can you find your “real” signal in this “soup”?\u00a0<\/p>\n\n
\"\"
“Basic noise”<\/figcaption><\/figure>\n\n
The principle<\/h2>\n\n
You can mark a signal as a “real” signal by placing it in a clearly identifiable start and end signal (kind of ID) .<\/span> In my first test signal these are very “HIGH” continuous signals of 10000 \u00b5s. In between there are the “HIGH” information signals of 400, 600, 800,….., 2000 \u00b5s. These are separated by “LOW” phases of 600 \u00b5s<\/span>.\u00a0<\/p>\n\n
\"Own<\/figure>\n\n
The sketch looks like this and I don’t think I need any further explanation:<\/p>\n\n
int txPin = 10; \/* Transmitter Data Pin *\/\r\nconst int lowLength = 600; \/* constant Low Phase *\/\r\n \r\nvoid setup(){ \r\n  pinMode(txPin, OUTPUT); \r\n}\r\n \r\nvoid loop(){\r\n  unsigned int mcs;\r\n  startSequence(); \/*Send the startsequence*\/\r\n  for(int i=0; i<9; i++){ \/* Send nine signals; High: 400, 600, .... *\/\r\n    digitalWrite(txPin, HIGH);\r\n    mcs = i*200 + 400;\r\n    delayMicroseconds(mcs);\r\n    digitalWrite(txPin,LOW);\r\n    delayMicroseconds(lowLength); \r\n  }\r\n  endSequence(); \/* Send the end sequence *\/\r\n  delay(5000);\r\n}\r\n\r\nvoid startSequence(){\r\n  digitalWrite(txPin, HIGH);\r\n  delayMicroseconds(10000);\r\n  digitalWrite(txPin, LOW);\r\n  delayMicroseconds(lowLength);\r\n}\r\n\r\nvoid endSequence(){\r\n  digitalWrite(txPin, HIGH);\r\n  delayMicroseconds(10000);\r\n  digitalWrite(txPin, LOW); \r\n}<\/pre>\n\n
Let’s move on to receiversketch. At first the receiver is waiting for a valid start signal. If this is given, i.e. if a defined length is exceeded, the information signals are analyzed, i.e. the lengths of the “HIGH” and “LOW” phases are measured alternately. These values are stored in a two-dimensional array “signalLength” as “lowCounter” and “highCounter”. The length of the signals is then low- or highCounter x Resolution (here: 20 \u00b5s). If “highCounter” exceeds a defined value, it is the end signal. The sequence is thus fully transmitted and will be displayed on the serial monitor.\u00a0<\/p>\n\n
int resolution = 20;\r\n\r\nvoid setup(){\r\n  Serial.begin(9600);\r\n  DDRD = 0x00; \/\/ Arduino Pins D0 - D7 as input\r\n  PORTD = 0x00; \/\/ Arduino Pins D0 - D7 set LOW\r\n}\r\n\r\nvoid loop(){\r\n  waitForSignal();\r\n}\r\n\r\nvoid waitForSignal(){\r\n  while(!(PIND & (1<<PD5))){\/*Wait for valid signal*\/}\r\n  if(startSequence()){ \/\/ Is the signal a valid start sequence? *\/\r\n    analyseSignal(); \/* if yes, analyse the signal *\/\r\n  }\r\n}\r\n  \r\nvoid analyseSignal(){\r\n  int signalCounter = 0; \/* counter for High\/Low signal pairs *\/\r\n  int lowCounter = 0; \/* Low signal length = lowCounter * resolution; *\/\r\n  int highCounter = 0; \/* High signal length = highCounter * resolution; *\/\r\n  int signalLength[15][2]; \/* store the signals in a two-dimensional array *\/\r\n  bool msgCompleted = false;\r\n\r\n  while(!msgCompleted){ \/* while the message is not completed *\/\r\n    lowCounter = 0;\r\n    highCounter = 0; \r\n    \r\n    while(!(PIND & (1<<PD5))){ \/* Wait for HIGH, measure the length of the low signal *\/\r\n      delayMicroseconds(resolution);\r\n      lowCounter++;\r\n    }\r\n    while(PIND & (1<<PD5)){ \/* Wait for LOW, analyse the HIGH signal *\/\r\n      delayMicroseconds(resolution);\r\n      highCounter++;\r\n    }\r\n    if(highCounter < 200){ \/* a Low\/High pair has been received *\/ \r\n    signalLength[signalCounter][0] = lowCounter;\r\n    signalLength[signalCounter][1] = highCounter;\r\n    signalCounter++;\r\n  }\r\n  else if(highCounter < 5000){ \/* end of message received, the if is redundant *\/\r\n    msgCompleted = true;\r\n    }\r\n  }\r\n  \/* Following is the output *\/\r\n  Serial.println(\"low \/ high\");\r\n  for(int i=0; i<signalCounter; i++){\r\n    Serial.print(signalLength[i][0]);\r\n    Serial.print(\" \/ \");\r\n    Serial.println(signalLength[i][1]);\r\n  }\r\n  Serial.println(\"--------\");\r\n  delay(2000);\r\n}\r\n\r\nbool startSequence(){\r\n  int counter = 0;\r\n  while(PIND & (1<<PD5)){\r\n    delayMicroseconds(resolution);\r\n    counter++;\r\n  }\r\n  if(counter >400){ \/* the start signal has been received *\/\r\n    return true;\r\n  }\r\n  else{\r\n    return false;\r\n  }\r\n}<\/pre>\n\n
\"\"
The test signal on the receiver side<\/figcaption><\/figure>\n\n
And, behold, you get beautiful distinct signals. Since the resolution is 20 \u00b5s and the “LOW” signals are 600 \u00b5s long, the lowCounter should be 30. Strictly speaking, 29, as he counts starting at zero. So we measure about 100’s too much. And what is too much with the “LOW” signals is missing from the “HIGH” signals. Probably the receiver modules need a certain amount of time to set the data pin to “HIGH” when receiving a signal. In any case, you get a good impression from this at which speeds you can transfer data.\u00a0<\/p>\n\n
Protocol 1 – bitwise transmission<\/h2>\n\n
The basic idea<\/h3>\n\n
Now that we have seen that information can be coded by signal length, it is now time to develop our own radio protocols. In the first example, we transfer bits that are defined by the “HIGH” phase length. A “0” is a 600 \u00b5s signal and a “1” is a 1200 \u00b5s signal. In between there are fixed “LOW” signals of 600 \u00b5s. Assuming that zeros and ones occur equally often, the average signal length is 1500 microns, i.e. a transmission rate of “legendary” 0.666 kbit\/s. Through the basic experiment above, we have seen that even much shorter signals can still be clearly distinguished. So here’s still a lot of room for increasing the speed.\u00a0<\/p>\n\n
The transmittersketch<\/h3>\n\n
I have defined the information to be transmitted as a string. At first, you can easily break down a string into its individual characters: yourstring [ites Zeichen] . To break down the characters into their 8 bits, I use a binary operation in the “sendeByte” function, which you should understand if you have followed my explanations above. In essencet: the byte is gradually moved to the right. Then the logical “AND” checks whether the first bit is “1” or “0”. Accordingly, a short or long “HIGH” is sent in the sendeSignal() function. I have shortened the end signal to 5000 \u00b5s.<\/span><\/p>\n\n
int txPin = 10; \/* Transmitter Data Pin *\/\r\n\r\nvoid setup() {\r\n  pinMode(txPin, OUTPUT);\r\n  Serial.begin(9600);\r\n}\r\n\r\nvoid loop() {\r\n  String msgString = \"Hallo Welt, wie geht es dir heute?\"; \/\/ Hello world, how are you today?\r\n  sendeString(msgString);\r\n  delay(5000);\r\n}\r\n\r\nvoid sendeString(String msg) {\r\n  int len = msg.length();\r\n  initMsg(); \/* Send the initial signal *\/\r\n  for (int i = 0; i < len; i++) { \/* send bytewise *\/\r\n    sendeByte(byte(msg[i]));\r\n  }\r\n  closeMsg();\r\n}\r\n\r\nvoid sendeByte(byte msgByte) { \/*send bitwise *\/\r\n  bool msgBit = 0;\r\n  for (int i = 7; i >= 0; i--) { \/* \"Extraction\" of the bits *\/\r\n    msgBit = (msgByte >> i) & 1; \r\n    sendeSignal(msgBit);\r\n  }\r\n}\r\n\r\nvoid sendeSignal(bool sendBit) {\r\n  digitalWrite(txPin, HIGH);\r\n  if (sendBit == false) {\r\n    delayMicroseconds(600);\r\n  }\r\n  else {\r\n    delayMicroseconds(1200);\r\n  }\r\n  digitalWrite(txPin, LOW);\r\n  delayMicroseconds(1000);\r\n}\r\n\r\nvoid initMsg() { \/* Initialise *\/\r\n  digitalWrite(txPin, HIGH);\r\n  delayMicroseconds(10000);\r\n  digitalWrite(txPin, LOW);\r\n  delayMicroseconds(600);\r\n}\r\n\r\nvoid closeMsg() { \/*end signal *\/\r\n  digitalWrite(txPin, HIGH);\r\n  delayMicroseconds(5000);\r\n  digitalWrite(txPin, LOW);\r\n  delayMicroseconds(600);\r\n}<\/pre>\n\n
The receiver sketch<\/h3>\n\n
The Receiversketch is very similar to the Receiversketch for the test signal.\u00a0 First, a valid start signal is waited for, then the length of the following signals l are measured and interpreted as bits. The bits are combined into bytes via binary operations, the bytes are converted into characters and the string is reassembled from them. Since only whole bytes can be transferred, there should be no bit left at the end. And if so, then something has gone wrong and an error flag is set. \u00a0<\/p>\n\n
int resolution = 20;\r\nint error = 0; \/* error flag *\/\r\n\r\nvoid setup(){\r\n  Serial.begin(9600);\r\n  DDRD = 0x00;\r\n  PORTD = 0x00; \r\n  Serial.println(\"Warte auf Signal...\");\r\n}\r\n\r\nvoid loop(){\r\n  listenToSignal();\r\n}\r\n\r\n\r\nvoid listenToSignal(){\r\n  int lowPulse = 0;\r\n  int highPulse = 0;\r\n  byte bitNo = 0;\r\n  byte incomingByte = 0;\r\n  String msg = \"\";\r\n  int msgLen = 0;\r\n  bool msgCompleted = false;\r\n  error=0;\r\n  \r\n  while(!(PIND & (1<<PD5))){\/*Wait*\/}\r\n  if(startSequence()){\r\n       \r\n    while(!msgCompleted){\r\n      lowPulse = 0;\r\n      highPulse = 0;\r\n      \r\n      while(!(PIND & (1<<PD5))){\r\n        delayMicroseconds(resolution);\r\n        lowPulse++;\r\n      }\r\n      while(PIND & (1<<PD5)){\r\n        delayMicroseconds(resolution);\r\n        highPulse++;\r\n      }\r\n      if(highPulse < 45){\r\n        incomingByte = (incomingByte << 1);\r\n      }\r\n      else if(highPulse < 70){\r\n        incomingByte = (incomingByte << 1) + 1; \r\n      }\r\n      else if(highPulse >= 150){\r\n        msgCompleted = true;\r\n        if(bitNo!=0){\r\n          error = 1; \r\n        }\r\n      }\r\n      if(bitNo<7){\r\n        bitNo++;\r\n      }\r\n      else{\r\n        msg = msg + char(incomingByte);\r\n        bitNo = 0;\r\n        msgLen++;\r\n        incomingByte = 0;\r\n      }\r\n    }\r\n    if((!error)&&(msg.length()!=0)){\r\n      Serial.println(msg);\r\n    }\r\n \/\/   else{\r\n \/\/    Serial.println(\"error\");\r\n \/\/   }\r\n   }\r\n}\r\n\r\nbool startSequence(){\r\n  int counter = 0;\r\n  while(PIND & (1<<PD5)){\r\n    delayMicroseconds(resolution);\r\n    counter++;\r\n  }\r\n  if(counter > 300){\r\n    return true;\r\n  }\r\n  else{\r\n    return false;\r\n  }\r\n}<\/pre>\n\n
And look – it works!<\/p>\n\n
\"Own<\/figure>\n\n
Protocol 2 – Transfer numbers digitwise<\/h2>\n\n
The basic idea<\/h3>\n\n
I subsequently edited this chapter again in 2024.<\/p>\r\n
With this protocol, only integers are transmitted. To do this, we divide the number into its digits and encode them by their length. Each signal is given an offset so that we can also transmit zeros.<\/p>\r\n\n
The transmitter side<\/h3>\n\n
We define the number to be transferred as a character array. This makes it easy to cut it into digits. And we don’t have to worry about the maximum size of integer or long integer values. <\/p>\r\n\n
int dataPin =  5; \/* Transmitter data pin *\/\r\nconst int lowLength = 600; \/* low phase is constant *\/\r\nchar message[] = \"0123456789\"; \r\n \r\nvoid setup() {                \r\n  pinMode(dataPin, OUTPUT);   \r\n}\r\n \r\nvoid loop() {\r\n  unsigned int mcs;\r\n  sendStartSequence(); \r\n  for (unsigned int i=0; i < sizeof(message)-1; i++) { \/* *\/\r\n    \/* Make an integer from the char array element *\/\r\n    char element[1] = {message[i]}; \r\n    int digit = atoi(element);\r\n \r\n    mcs = digit * 200 + 250; \/\/ mcs: signal length in microseconds\r\n    digitalWrite(dataPin, HIGH);\r\n    delayMicroseconds(mcs);\r\n    digitalWrite(dataPin,LOW);\r\n    delayMicroseconds(lowLength); \r\n  }\r\n\r\n  sendEndSequence();  \/* Send the terminating sequence *\/\r\n  delay(5000);\r\n}\r\n\r\nvoid sendStartSequence() {\r\n  digitalWrite(dataPin, HIGH);\r\n  delayMicroseconds(10000);\r\n  digitalWrite(dataPin, LOW);\r\n  delayMicroseconds(lowLength);\r\n}\r\n\r\nvoid sendEndSequence() {\r\n  digitalWrite(dataPin, HIGH);\r\n  delayMicroseconds(10000);\r\n  digitalWrite(dataPin, LOW); \r\n}<\/pre>\r\n\n
The receiver sketch<\/h3>\n\n
The receiver first waits for the long start signal. Once it has received this, the incoming signals are evaluated in terms of their length. The sketch saves these values in an array. The digits are reconstructed from the lengths using a conversion factor. You may have to adjust the conversion factor in your case. The example of the transmission 0123456789 should make it easy to see whether the factor is correct.<\/p>\r\n\n
\r\n
int resolution = 15;\r\nint dataPin = 5;\r\n#define LEN_TO_NUMBER_DIVIDER 11 \/* Divider to calculate numbers from signal length *\/\r\n\r\nvoid setup() {\r\n  Serial.begin(115200);\r\n  pinMode(dataPin, INPUT);\r\n}\r\n\r\nvoid loop() {\r\n  waitForSignal();\r\n}\r\n\r\nvoid waitForSignal() {\r\n  while (!digitalRead(dataPin)) {\/*Wait until data pin receives a signal*\/}\r\n  if (startSignalReceived()) {      \/* Is the start sequence valid wrt its length? *\/\r\n    Serial.println(\"Received valid start signal\");\r\n    analyzeIncomingMessage();    \r\n  }\r\n}\r\n  \r\nvoid analyzeIncomingMessage(){\r\n  int signalCounter = 0; \/* Counter for the number of signals *\/\r\n  int signalLength[15];  \/* Signal length array*\/\r\n  bool msgCompleted = false;\r\n\r\n  while (!msgCompleted){ \r\n    signalLength[signalCounter] = 0; \r\n    \r\n    while (!digitalRead(dataPin)) { \/* Wait for high signal *\/\r\n      delayMicroseconds(resolution);\r\n    }\r\n    while (digitalRead(dataPin)) {   \/* Measure the length of the high signal *\/\r\n      delayMicroseconds(resolution);\r\n      signalLength[signalCounter]++;\r\n    }\r\n    if (signalLength[signalCounter] < 200) {    \/* Received message content *\/ \r\n      signalCounter++;\r\n    }\r\n    else { \/* Received the termnating signal *\/\r\n      msgCompleted = true;\r\n    }\r\n  }\r\n  \/* Es folgt die Ausgabe *\/\r\n  Serial.println(\"Signal length: \");\r\n  for (int i=0; i<signalCounter; i++) {\r\n    Serial.println(signalLength[i]);\r\n  }\r\n  Serial.print(\"Number received: \");\r\n  for (int i=0; i<signalCounter; i++) {\r\n    Serial.print(signalLength[i]\/LEN_TO_NUMBER_DIVIDER);\r\n  }\r\n  Serial.println();\r\n  Serial.println(\"--------\");\r\n  delay(1000);\r\n}\r\n\r\nbool startSignalReceived() {\r\n  int counter = 0;\r\n  while (digitalRead(dataPin)) {\r\n    delayMicroseconds(resolution);\r\n    counter++;\r\n  }\r\n  if (counter > 400) { \/* Start signal has been received *\/\r\n    return true;\r\n  }\r\n  else {\r\n    return false;\r\n  }\r\n}<\/pre>\r\n
\u00a0<\/p>\r\n<\/div>\r\n\n
Here is the output, so you see it works:<\/p>\r\n\n
\"Output<\/a>
Output protocol_2_receiver.ino<\/figcaption><\/figure>\n\n
You can take out the output of the signal lengths. <\/p>\r\n
And then you could develop your own protocols. How about Morse code, for example?<\/p>\r\n\r\n","protected":false},"excerpt":{"rendered":"
How to develop your own radio protocols for 433 MHz using Arduino and Co without libraries. Two concepts are introduced. <\/p>\n","protected":false},"author":1,"featured_media":7868,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[545,548],"tags":[551,556,589,586,588],"class_list":["post-8848","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-433-mhz-en","category-wireless","tag-433-mhz-en","tag-arduino-en-2","tag-own-radio-protocol","tag-radio-transmission-en","tag-without-library-en"],"yoast_head":"\nWolles Elektronikkiste • Own radio protocols<\/title>\n<meta name=\"description\" content=\"How to develop your own radio protocols for 433 MHz using Arduino and Co without libraries. Two concepts are introduced.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Wolles Elektronikkiste • Own radio protocols\" \/>\n<meta property=\"og:description\" content=\"How to develop your own radio protocols for 433 MHz using Arduino and Co without libraries. Two concepts are introduced.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols\" \/>\n<meta property=\"og:site_name\" content=\"Wolles Elektronikkiste\" \/>\n<meta property=\"article:published_time\" content=\"2020-10-13T11:54:25+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-09-20T19:52:33+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/10\/beitragsbild_eigene_funkprotokolle_eng.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"610\" \/>\n\t<meta property=\"og:image:height\" content=\"584\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Wolfgang Ewald\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Wolfgang Ewald\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"12 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols\"},\"author\":{\"name\":\"Wolfgang Ewald\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#\\\/schema\\\/person\\\/b774e4d64b4766889a2f7c6e5ec85b46\"},\"headline\":\"Own radio protocols\",\"datePublished\":\"2020-10-13T11:54:25+00:00\",\"dateModified\":\"2024-09-20T19:52:33+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols\"},\"wordCount\":1400,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#\\\/schema\\\/person\\\/b774e4d64b4766889a2f7c6e5ec85b46\"},\"image\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2020\\\/10\\\/beitragsbild_eigene_funkprotokolle_eng.jpg\",\"keywords\":[\"433 MHz\",\"Arduino\",\"own radio protocol\",\"Radio transmission\",\"without library\"],\"articleSection\":[\"433 MHz\",\"Wireless\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols\",\"url\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols\",\"name\":\"Wolles Elektronikkiste • Own radio protocols\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2020\\\/10\\\/beitragsbild_eigene_funkprotokolle_eng.jpg\",\"datePublished\":\"2020-10-13T11:54:25+00:00\",\"dateModified\":\"2024-09-20T19:52:33+00:00\",\"description\":\"How to develop your own radio protocols for 433 MHz using Arduino and Co without libraries. Two concepts are introduced.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols#primaryimage\",\"url\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2020\\\/10\\\/beitragsbild_eigene_funkprotokolle_eng.jpg\",\"contentUrl\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2020\\\/10\\\/beitragsbild_eigene_funkprotokolle_eng.jpg\",\"width\":610,\"height\":584},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\\\/own-radio-protocols#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Startseite\",\"item\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Own radio protocols\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#website\",\"url\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en\",\"name\":\"Wolles Elektronikkiste\",\"description\":\"Die wunderbare Welt der Elektronik\",\"publisher\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#\\\/schema\\\/person\\\/b774e4d64b4766889a2f7c6e5ec85b46\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":[\"Person\",\"Organization\"],\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/en#\\\/schema\\\/person\\\/b774e4d64b4766889a2f7c6e5ec85b46\",\"name\":\"Wolfgang Ewald\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2019\\\/03\\\/cropped-Logo-1.png\",\"url\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2019\\\/03\\\/cropped-Logo-1.png\",\"contentUrl\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2019\\\/03\\\/cropped-Logo-1.png\",\"width\":512,\"height\":512,\"caption\":\"Wolfgang Ewald\"},\"logo\":{\"@id\":\"https:\\\/\\\/wolles-elektronikkiste.de\\\/wp-content\\\/uploads\\\/2019\\\/03\\\/cropped-Logo-1.png\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Wolles Elektronikkiste • Own radio protocols","description":"How to develop your own radio protocols for 433 MHz using Arduino and Co without libraries. Two concepts are introduced.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols","og_locale":"en_US","og_type":"article","og_title":"Wolles Elektronikkiste • Own radio protocols","og_description":"How to develop your own radio protocols for 433 MHz using Arduino and Co without libraries. Two concepts are introduced.","og_url":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols","og_site_name":"Wolles Elektronikkiste","article_published_time":"2020-10-13T11:54:25+00:00","article_modified_time":"2024-09-20T19:52:33+00:00","og_image":[{"width":610,"height":584,"url":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/10\/beitragsbild_eigene_funkprotokolle_eng.jpg","type":"image\/jpeg"}],"author":"Wolfgang Ewald","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Wolfgang Ewald","Est. reading time":"12 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols#article","isPartOf":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols"},"author":{"name":"Wolfgang Ewald","@id":"https:\/\/wolles-elektronikkiste.de\/en#\/schema\/person\/b774e4d64b4766889a2f7c6e5ec85b46"},"headline":"Own radio protocols","datePublished":"2020-10-13T11:54:25+00:00","dateModified":"2024-09-20T19:52:33+00:00","mainEntityOfPage":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols"},"wordCount":1400,"commentCount":0,"publisher":{"@id":"https:\/\/wolles-elektronikkiste.de\/en#\/schema\/person\/b774e4d64b4766889a2f7c6e5ec85b46"},"image":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols#primaryimage"},"thumbnailUrl":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/10\/beitragsbild_eigene_funkprotokolle_eng.jpg","keywords":["433 MHz","Arduino","own radio protocol","Radio transmission","without library"],"articleSection":["433 MHz","Wireless"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols#respond"]}]},{"@type":"WebPage","@id":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols","url":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols","name":"Wolles Elektronikkiste • Own radio protocols","isPartOf":{"@id":"https:\/\/wolles-elektronikkiste.de\/en#website"},"primaryImageOfPage":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols#primaryimage"},"image":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols#primaryimage"},"thumbnailUrl":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/10\/beitragsbild_eigene_funkprotokolle_eng.jpg","datePublished":"2020-10-13T11:54:25+00:00","dateModified":"2024-09-20T19:52:33+00:00","description":"How to develop your own radio protocols for 433 MHz using Arduino and Co without libraries. Two concepts are introduced.","breadcrumb":{"@id":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols#primaryimage","url":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/10\/beitragsbild_eigene_funkprotokolle_eng.jpg","contentUrl":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/10\/beitragsbild_eigene_funkprotokolle_eng.jpg","width":610,"height":584},{"@type":"BreadcrumbList","@id":"https:\/\/wolles-elektronikkiste.de\/en\/own-radio-protocols#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Startseite","item":"https:\/\/wolles-elektronikkiste.de\/en"},{"@type":"ListItem","position":2,"name":"Own radio protocols"}]},{"@type":"WebSite","@id":"https:\/\/wolles-elektronikkiste.de\/en#website","url":"https:\/\/wolles-elektronikkiste.de\/en","name":"Wolles Elektronikkiste","description":"Die wunderbare Welt der Elektronik","publisher":{"@id":"https:\/\/wolles-elektronikkiste.de\/en#\/schema\/person\/b774e4d64b4766889a2f7c6e5ec85b46"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/wolles-elektronikkiste.de\/en?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":["Person","Organization"],"@id":"https:\/\/wolles-elektronikkiste.de\/en#\/schema\/person\/b774e4d64b4766889a2f7c6e5ec85b46","name":"Wolfgang Ewald","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/03\/cropped-Logo-1.png","url":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/03\/cropped-Logo-1.png","contentUrl":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/03\/cropped-Logo-1.png","width":512,"height":512,"caption":"Wolfgang Ewald"},"logo":{"@id":"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/03\/cropped-Logo-1.png"}}]}},"_links":{"self":[{"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/posts\/8848","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/comments?post=8848"}],"version-history":[{"count":0,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/posts\/8848\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/media\/7868"}],"wp:attachment":[{"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/media?parent=8848"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/categories?post=8848"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/wolles-elektronikkiste.de\/en\/wp-json\/wp\/v2\/tags?post=8848"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}