User Tools

Site Tools


Short range radio network (not WiFi). SLAVE module. Uses cheapie 433MHz modules or HC-12

The following is a protocol I developed for a short range radio network without all the fluff associated with establishing and using a WiFi Ethernet presence. It is a simple star network with a master device initiating all communications to addressed slave modules. Messages may be passed back and forth-the content and interpretation of which is down to the application.

VB6 source code for the master is attached.

A note on using cheap 433MHz modules.

The code as written used slaves with HC-12 modules. These are very nice and provide two-way communications in a single module. Cheap, 99cent 433MHz modules will only provide comms in one direction; as this software expects slaves to respond - at least as part of discovery - you will need to use Rx/Tx module pairs in the slave units which pushes up cost, PCB real-estate, circuity requirements (possibly two antennae for longer range applications) and software complications. The HC-12s, although a bit more expensive (beware of fake parts), do look very attractive with their simplicity and enhanced features from the onboard controller. Cheap modules operate in isolation, meaning the slave module would “hear” any transmissions from itself (this is mitigated by the HC-12s controller). The software should handle this echo (because the destination will not be the slave's address and so be ignored), but the incoming buffer will likely have content after a transmit. Be aware also that serial comms normally rests in a marking state - a logic 1 on the data (or ATAD :o) pin will leave the Tx module transmitting constantly - probably jamming your network quite effectively! The serial port will need closing after use and the Tx pin taken LO - this in itself complicates Rx as with the comms closed, you won't hear inbound messages… you'll probably have to mess about with splitting the comms port - but this would be an ideal application of the SerialTX CSUB. Rx needs a proper comm port (you need the buffer because of the arbitrary nature of data arrival). With all these wrinkles, my recommendation is stick with HC-12s, they are only $5 for the genuine article. In this case, the code as shown here should work “out of the box”.

With all this in mind, even at 99c each the cheap modules come with headaches - at least in this application. I would gladly pay the other $3 to be without them!


Master is address 000
Slaves are address 1-998
Broadcast is address 999

Master initiates all communication and slaves only ever respond to Master requests for interaction (STAT or POLL).
Packets consist of a 4 character verb and then the payload.

All devices must be on the same "channel". It was explored that each slave might exist on its own channel but this was abandoned
early on because the cons outweighed the pros:

Separate channel: 	Pro    slave does not need to parse the addresses from the packet-if it hears the packet then it must be for that slave.
                        Con    Broadcast becomes impossible.
                               Device addresses limited to 127.
                               Cheap RxTx modules have no concept of channel.

Single channel:         Pro    Slave address is encoded as part of the packet header with a maximum of 998 slave devices. Different channels
                               permit single master with multiple slave zones if required, thus giving < 128000 devices (but broadcast and use of
                               cheapie modules will be impacted).
                               Broadcast is simple-all devices hear the broadcast and pick the addresses from the packet as normal.
                               Can use cheapie 433MHz TxRx pairs with no onboard processing (see preamble).
                        Con    HC-12 module is more expensive

Command		Source  Details
STAT:           Master	Master STATs address.
		        Slave MUST respond within 1.5 seconds and may send back data, thus a STAT contains an implicit POLL.
		        Nil response will result in the slave marked as not available in the status register (master will not POLL).
		        Slave must reply with ACK0 only-If the Slave has more to say, it must wait for a poll.
POLL:           Master	Master POLLs address.
		        Slave may respond but must do so within within 1.5 seconds if it has something to say but keeps quiet otherwise.
ACK0:           Slave	This is the terminating response to a STAT or POLL. This packet will cause the Master to accept the response and
		        move on to the next section of the cycle.
ACK1:           Slave	This is the response to a POLL only but signifies the slave has more to report. This packet will cause the
		        Master to accept the response and then immediately issue another POLL to the same slave. Multiple ACK1's may be
		        sent and the Master will continue to POLL and accept packets until receipt of ACK0 or a timeout occurs, at which
		        point the master will move on to the next section of the cycle. The slave must pause for 1.5 seconds between each
		        ACKx packet. An improvement would be to limit the amount of ACK1s to prevent a slave blocking the master.
INIT:		Master	The addressed slave must restart.
SAFE:		Master	The addressed slave must go to its safe mode state.

Broadcasts:	Any packet with destination address 999 is assumed to be a broadcast. Usually only the Master Broadcasts. Slaves must not reply to broadcasts.
TIME:		Master	The payload is hh:mm:ss,dd/mm/yyyy
		        All slaves will respond to this packet and synchronize their clocks to the payload.
INIT:		Master	All slaves must restart.
SAFE:		Master	All slaves must go to their safe mode state.
FIRE:		Master	All slaves must go to their FIRE mode state.

Slaves must respond to STAT. The response (or lack of it) updates the internal status register for that slave. Slaves that do not
respond to a STAT will be skipped in the POLL cycle. The master will attempt to discover all addresses continually.

Master: STAT (nn)
	Slave:	Must reply with ACK0 to the Master. The payload may be empty. Failure to respond will record that address as
	unavailable/empty in the slave register.

Master:	POLL (nn)
	Slave:	May reply with ACK0 (or ACK1 if there are multiple payloads) to the Master. The payload may be empty but it is
	recommended the slave not respond to a POLL if it has nothing to report. This reduces the cycle time and processing load.
	There is no advantage to replying with an empty payload.

The Packet format (all nodes):
Note the bracket forms below do not form part of the message and are here simply to logically group sections.
[optional preamble]STX<checksum>GS{RC4<dest address><src address><<Packet>}ETX

The data between the GS and ETX is encrypted before transmission. The checksum is for all bytes between {}
RC4 (elsewhere on this wiki) is a complex algorithm with a moderate data requirement (0.5K). A simpler encryption algorithm XORing a
variable length key is available if the simple nature of the slaves cannot support it i.e. simple PIC/Atmel chips.
Smaller Micromites can struggle to maintain timings with RC4 and large packets-use simple encryption or slow the cycle.

The payload must only contain "Printable" characters in the range 32-126. This avoids erroneous control characters interfering with network operation.

A typical Tx from the master to device 05 looks like

Preamble: When using cheap TxRx modules with no onboard processing, it is necessary to send a stream of 1's with occasional zero so the Rx
	can set it's levels before the actual data arrives.
	Without preamble, some bits may be lost while the Rx adjusts its levels. Anything to the left of the STX must be discarded.
	Chr FE has a large amount of "1" space and the trailing 0 ensures the levels are set on Rx devices
	immediately before they are required to be accurate. A string of at least 2 FE chars is effective.
	Using devices like HC-12 where there is onboard processing to assure data integrity, a preamble is not necessary as it is
	taken care of by the radio modem.

	[FE FE ...]

Packet structure
	02 = STX Start of Text, sync marker. This indicate the start of valid data.
	CHK_HI ascii Hex of checksum of packet between the following GS and ETX
	1D = GS group separator, start of the addressing and instruction details.
	30 = attention device 005 in ascii
	30 = from the master 000 in ascii
	50 Command verb, STAT, POLL, ACK0 etc...
	[ optional payload here ]
	03 = ETX End of Text, marks the end of the packet. No further data is permitted.

Any response must begin transmission in the next 1.5 seconds

Master module.

You need to add your own code to interpret the content of the packets (both master and slaves) but standardise functionality so the master and slaves know what each other is doing. The master does not have to be a MicroMite-I have working VB code which uses a HC-12 on a USB↔Serial adapter so a Windows server can control the network-this opens up all sorts of possibilities and is used in the Snooker Hall metering for club membership and time charging etc.

Slaves and (micromite)master log to their console but this may be disconnected in general use. The modules detect “first run” and will prompt for config (i.e. their address and name-which is usually the location) at the console, after that it stores it's config and just gets on with things. So use the console to set the thing up and then just leave it to run. The modules I built have their console connections brought to a 3.5mm stereo jack which goes to a USB↔Serial jobby plugged in the installers laptop, just plug in to each and turn on, configure and run then unplug and move on to the next.

The master STATs every address from 001 to 998 every so often and if a module responds, it is marked as “live” and recorded along with it's name. Live Slave modules are POLLed in order for any messages interspersed with the next discovery. So the cycle might look like:

Stat 1 (responds)
Poll 1
Stat 2
Poll 1
Stat 3 (responds)
Poll 3
Stat 4
Poll 1
Stat 5
Poll 3
Stat 6
Poll 1
Stat 998

Only known live salves are regularly polled and newly discovered slaves are added as they are discovered. This ensures that we discover all modules over time but do not delay polling known live modules.

Undiscovered addresses are polled continually in the above cycle allowing “live” addition of new modules without the need to re-initialize the master.

At the end of the cycle, a TIME packet is sent on the broadcast address and all slaves set their clocks.

INIT message can be sent to restart an individual module or broadcast to restart the entire network. SAFE message can be sent to individual or all modules to set them to their safe mode (maybe an engineer is about to open them up and doesn't want a mains circuit up his arm). FIRE message can be broadcast to set all modules in their default emergency mode - perhaps turn all the lights on, play a recorded message to evacuate the building etc…

Slave module.

You will need to adapt it as you see fit but it works really well and offers some nice features.

Slave modules listen to radio transmissions for their address or the broadcast address and respond accordingly. I have used this for a number of different projects: Snooker/Pool table light control, Customer feedback pods etc.

The Master initiates all communication and transmits structured and encrypted packets for specific slave addresses.

The Master is always address 000 and slaves can be any from 001 to 998 (doesn't have to be contiguous). 999 is the broadcast address. You could easily extend this but probably a thousand slave modules will cover most installations. You don't have to use them all and the master won't waste time trying to talk to addresses that don't respond to discovery.

The master also sends out TIME packets so slaves don't need RTCs (much cheapness!), only a single RTC on a network of 1000 modules!

Slave Module Code:

	Option Autorun On

	Print "Node boot"

	Option Base 0
	'Option Explicit

	Const KEY$=">4!1x4q3z4+7%4{9?5\3HhH^5$9=6@1~6,7_7|1)7'3]7[9:8<3*8S9I9l7Z1eT0r1"
	Const GS=&H1D
	Const STX=2
	Const ETX=3
	Const io=1
	Const DoPreamble=0	' No. of preamble bytes. Only for when using cheap dumb RxTx module pairs. Drop the baud rate right down (2400 ish) And set this value to 2 or more
	Const Link$="COM1:9600,260"

	Dim MyAddr As Integer
	Dim MyJob As String

	Dim a$, tm$, cmd$, pl$, R ' R is the serial buffer
	Dim Integer c,src,dst,n
	Dim Integer FLAGS=0  ' 0 STX
                             ' 1 GS
                             ' 2 ETX
                             ' 3 Init. device has restarted And never heard from the master
                             ' 4 in FIRE mode
                             ' 5 in SAFE mode
                             ' 6 just been configured
                             ' 7
                             ' 8
                             ' 9

	Var Restore

	FlagSet 3 ' just booted

	IF MyAddr=0 Then
				Input "Enter Node address (1-998) >", a$
			Loop Until MyAddr >0 And MyAddr<999

				Input "Enter Node Task Name       >", a$
			Loop Until MyJob<>""

			Print "Is This Correct? (Y/N)";
			Do:Input a$:a$=UCASE$(a$):Loop Until a$="Y" OR a$="N"
		Loop While a$="N"

		Var Save MyAddr,MyJob

		FlagSet 6 ' Just completed setup-need INIT

	Open Link$ As #io ' may need to drop this for cheap TxRx modules, HC12 etc do not require
	FlushIO io

	Print "Node";MyAddr;" up in";Timer;"mS Name ";MyJob

		If Loc(#io)<>0 Then
			Select Case C
				Case 2
					If FLAGS<>0 Then Goto SafeExit
					FlagSet 0
				Case &H1D	' test GS
					If Flagtest(0)<>1 And FlagTest(2)<>0 Then Goto SafeExit
					FlagSet 1
				Case 3
					If Flagtest(0)<>1 And FlagTest(2)<>1 Then Goto SafeExit
					FlagSet 2
				Case &H30 TO &h39
					If Flagtest(0)<>1 Then Goto SafeExit ' only accept chars after STX
				Case &h41 TO &H46
					If Flagtest(0)<>1 Then Goto SafeExit
				Case Else
					'ignore anything else
			End Select

		If (FLAGS And 7)=7 Then	'STX,GS,ETX

			' check GS position(5)
			If c<>5 Then Goto BadFrame '? "GS bad position":

			' data after GS should always be even count
			If (c And 1) Then Goto BadFrame '? "Data length is odd":GOTO BadFrame ' If bit0 set then odd number

			'calculate checksum of rec'd data
			a$=Mid$(R,6) 'payload

			For n=1 To Len(a$):c=c-Asc(Mid$(a$,n,1)):Next

			If c<>0 Then Goto BadFrame '? "bad checksum ";r:GOTO BadFrame
			' For some reason, slaves calculate bad checksums For each others reply packets.
			' haven't determined why but it gives a quick exit If the packet isn't For me

			'decode valid frame


			If dst=MyAddr Then ' specific
				Print Str$(dst,3);" ";TIME$;" ";cmd$;" ";pl$';Timer

				Select Case cmd$
					Case "STAT" ' must reply with info
						RadioSend src,MyAddr,"ACK0:STAT"+Bin$(FLAGS,32)+":NAME="+MyJob+":NTYP="+MM.Device$+","+Str$(MM.Ver)
					Case "POLL" ' may reply with data
						If FlagTest 6=0 Then 'If 1 we are waiting INIT so do not answer
							If int(Rnd*2))>0 Then ' decide To answer or not
								RadioSend src,MyAddr,"ACK0"
					Case "INIT"
						CPU Restart
					Case "SAFE"
						Mode 5,pl$
					' ignore anything else
				End Select

			ElseIf dst=999 Then ' broadcast only
				Print Str$(dst,3);" ";Time$;" ";cmd$;" ";pl$
				Select Case cmd$
					Case "TIME"
						If Len(pl$)=19 Then
							If Mid$(pl$,9,1)="," Then
								On Error Skip 1:Time$=Left$(pl$,8)
								On Error Skip 1:Date$=Right$(pl$,10)
					Case "INIT"
						CPU Restart
					Case "SAFE"	' safe mode For working on node
						Mode 5,pl$
					Case "FIRE" ' emergency mode-i.e. all nodes turn on lights
						Mode 4,pl$
					' other broadcast CASEs go here
				End Select

			Goto SafeExit

		Goto LoopEnd
	' ignore it

	Sub Mode(fg As Integer,x$)
		If x$="OFF" Then
			FlagRes fg
			FlagSet fg
	End Sub

	Function ZPad$(x As Integer)
		ZPad$=Right$("000"+Str$(x), 3)
	End Function

	Sub RadioSend(d As Integer,s As Integer,msg As String)
		Local qq$
		Local Integer chk,m
		For m=1 To Len(qq$):chk=chk+Asc(Mid$(qq$,m,1)):Next
		Print#io, String$(DoPreamble,Chr$(&HFE))+qq$;
		Pause Len(qq$)' wait For the packet To go
	End Sub

	Function ENCRYPT$(A$)
		Local Integer N,P
		Local B$
		For N=1 To Len(A$)
			B$=B$+HEX$(Asc(Mid$(A$,N,1),2) Xor Asc(Mid$(KEY$,P,1)),2)
			P=P+1:If P>Len(KEY$) Then P=1
	End Function

	Function DECRYPT$(A$)
		Local Integer N,P
		Local B$
		For N=1 To Len(A$) Step 2
			B$=B$+Chr$(Val("&H"+Mid$(A$,N,2)) Xor Asc(Mid$(KEY$,P,1)))
			P=P+1:If P>Len(KEY$) Then P=1
	End Function

	Sub FlagSet(bit As Integer)
		FLAGS=FLAGS Or (2^bit)
	End Sub

	Sub FlagRes(bit As Integer)
		FLAGS=(FLAGS Or (2^bit)) Xor (2^bit)
	End Sub

	Function FlagTest(bit As Integer) As Integer
		FlagTest=Abs(Sgn(FLAGS And (2^bit)))
	End Function

	Sub FlushIO(CH)
		Local A$
		Do While LOC(#CH)>0
			Pause 20
	End Sub

mmbasic/short_range_radio_network_not_wifi_slave_module_uses_cheapie_433mhz_modules_or_hc_12.txt · Last modified: 2024/02/24 17:24 by gerry