Adding a layer 2 protocol

mic159 · mic159 · commit f7e0506e32cd · 2012-11-08T00:49:33.000+11:00
diff --git a/MeshBase.cpp b/MeshBase.cpp
@@ -37,7 +37,7 @@ void MeshBase::Update()
 	// Periodic sends
 	if (millis() - last_broadcast_time > PEER_DISCOVERY_TIME)
 	{
-    		if (!IsReady())
+		if (!IsReady())
 			ChooseAddress();
 		SendPeerDiscovery();
 	}
@@ -51,11 +51,18 @@ void MeshBase::Update()
 			uint8_t len = radio.getDynamicPayloadSize();
 			uint8_t buff[40];
 			done = radio.read(buff, min(len, sizeof(buff)));
-			if (pipe_num == 0)
-			{
-				HandleMessage(0, buff, len);
-			} else if (pipe_num == 1) {
-				HandlePeerDiscovery(buff, len);
+			
+			const MeshBase::Message* msg = (struct MeshBase::Message*)buff;
+			uint8_t payload_length = len - sizeof(Message);
+			const uint8_t* payload = buff + sizeof(Message);
+			
+			switch(msg->type) {
+				case type_peer_discovery:
+					HandlePeerDiscovery(msg, payload, payload_length);
+				break;
+				default:
+					OnMessage(msg, payload, payload_length);
+				break;
 			}
 		} while (!done);
 	}
@@ -80,22 +87,21 @@ void MeshBase::Update()
 	}
 }
 
-void MeshBase::HandlePeerDiscovery(void* buff, uint8_t length)
+void MeshBase::HandlePeerDiscovery(const MeshBase::Message* msg, const void* buff, uint8_t length)
 {
 	if (length != sizeof(PeerDiscoveryMessage))
 		return;
-	PeerDiscoveryMessage from = *(PeerDiscoveryMessage*)buff;
-	// Dont know why, but this keeps happening?
-	/*if (from == 0)
-		return;*/
+	const PeerDiscoveryMessage* pd = (struct PeerDiscoveryMessage*)buff;
+	//if (msg.protocol_version != 1)
+	//	return;
 
-	Peer* peer = GetPeer(from.address);
+	Peer* peer = GetPeer(msg->address_from);
 	if (peer == NULL)
 	{
 		// Found a new peer
 		Serial.print("New Peer: ");
-		Serial.println(from.address, DEC);
-		Peer* p = new Peer(from.address);
+		Serial.println(msg->address_from, DEC);
+		Peer* p = new Peer(msg->address_from);
 		peers.Add(p);
 		OnNewPeer(p);
 	} else {
@@ -107,27 +113,37 @@ void MeshBase::HandlePeerDiscovery(void* buff, uint8_t length)
 void MeshBase::SendPeerDiscovery()
 {
 	last_broadcast_time = millis();
-	MeshBase::PeerDiscoveryMessage msg;
-	msg.version = 1;
-	msg.address = address;
-	msg.num_peers = peers.length;
-	SendBroadcastMessage(PEER_DISCOVERY, &msg, sizeof(MeshBase::PeerDiscoveryMessage));
+	MeshBase::PeerDiscoveryMessage payload;
+	payload.protocol_version = 1;
+	payload.network_capabilities = 0;
+	payload.application_capabilities = 0;
+	payload.num_peers = peers.length;
+	payload.uptime = millis() / 1000;
+	SendMessage(PEER_DISCOVERY, type_peer_discovery, &payload, sizeof(MeshBase::PeerDiscoveryMessage), true);
 }
 
-void MeshBase::SendBroadcastMessage(uint32_t to, const void* data, uint8_t length)
+void MeshBase::SendMessage(uint32_t to, uint8_t type, const void* data, uint8_t length, bool is_broadcast)
 {
+	uint8_t buff[32];
+	Message* msg = (struct Message*)buff;
+	msg->protocol_version = 1;
+	msg->ttl = 0;
+	msg->type = type;
+	msg->address_from = address;
+	msg->split_enabled = 0;
+	msg->split_part = 0;
 	radio.stopListening();
-	radio.openWritingPipe(TO_BROADCAST(to));
+	if (is_broadcast)
+		radio.openWritingPipe(TO_BROADCAST(to));
+	else
+		radio.openWritingPipe(TO_ADDRESS(to));
 	radio.write(data, length);
 	radio.startListening();
 }
 
-void MeshBase::SendMessage(uint32_t to, const void* data, uint8_t length)
+void MeshBase::SendMessage(uint32_t to, uint8_t type, const void* data, uint8_t length)
 {
-	radio.stopListening();
-	radio.openWritingPipe(TO_ADDRESS(to));
-	radio.write(data, length);
-	radio.startListening();
+	SendMessage(to, type_user, data, length, false);
 }
 
 void MeshBase::ChooseAddress()
diff --git a/MeshBase.h b/MeshBase.h
@@ -16,13 +16,30 @@ class MeshBase
 		Peer(uint32_t address) : address(address), time(0) {}
 	};
 	
+	struct Message
+	{
+		uint8_t		protocol_version;
+		uint8_t		ttl;
+		uint8_t		type;
+		bool		split_enabled :  1;
+		uint8_t		split_part : 7;
+		uint32_t	address_from;
+	};
+
+	// -- Message types --
+	enum message_type {
+		type_peer_discovery,
+		type_peer_list,
+		type_user,
+	};
+
 	void			Begin();
 	void			Update();
-	void			SendMessage(uint32_t address, const void* data, uint8_t length);
+	void			SendMessage(uint32_t address, uint8_t type, const void* data, uint8_t length);
 	uint32_t		GetAddress() const { return address; }
 	bool			IsReady() const { return address != 0; }
 protected:
-	virtual void	HandleMessage(uint32_t sender, const void* data, uint8_t length) = 0;
+	virtual void	OnMessage(const MeshBase::Message* meta, const void* data, uint8_t length) = 0;
 	virtual void	OnNewPeer(Peer*) {}
 	virtual void	OnLostPeer(Peer*) {}
 private:
@@ -32,8 +49,9 @@ class MeshBase
 	unsigned long	last_peer_check_time;
 
 	void			SendPeerDiscovery();
-	void			SendBroadcastMessage(uint32_t address, const void* data, uint8_t length);
-	void			HandlePeerDiscovery(void* buff, uint8_t length);
+	void			SendMessage(uint32_t address, uint8_t type, const void* data, uint8_t length, bool is_broadcast);
+	void			HandlePeerDiscovery(const Message* msg, const void* buff, uint8_t length);
+	void			HandleMessage(const Message* msg, const void* data, uint8_t length);
 	void			ChooseAddress();
 	
 	LinkedList<Peer>	peers;
@@ -42,9 +60,11 @@ class MeshBase
 	
 	struct PeerDiscoveryMessage
 	{
-		uint8_t		version;
-		uint32_t	address;
-		uint16_t	num_peers;
+		uint8_t		protocol_version;
+		uint8_t		network_capabilities; // What routing/networking can I do for the network
+		uint8_t		application_capabilities; // What type of data do I expose
+		uint16_t	num_peers; // Number of direct peers
+		uint32_t	uptime; // Seconds since boot
 	};
 
 };
diff --git a/RF_test.ino b/RF_test.ino
@@ -7,9 +7,9 @@ class App : public MeshBase
 public:
     App() : MeshBase(9, 10) {}
 protected:
-    virtual void	HandleMessage(uint32_t sender, const void* data, uint8_t length)
+    virtual void	OnMessage(const MeshBase::Message* meta, const void* data, uint8_t length)
     {
-        Serial.print(sender, DEC);
+        Serial.print(meta->address_from, DEC);
         Serial.print(" : ");
         Serial.println((const char*)data);
     }
@@ -20,7 +20,7 @@ protected:
         int len = snprintf(buff, 255, "Hello %u from %u", p->address, GetAddress());
         Serial.print("Sending message: ");
         Serial.println(buff);
-        SendMessage(p->address, buff, len + 1);
+        SendMessage(p->address, type_user, buff, len + 1);
     }
 };
 

Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,9 @@ class App : public MeshBase`
`7`	`7`	`public:`
`8`	`8`	`App() : MeshBase(9, 10) {}`
`9`	`9`	`protected:`
`10`		`- virtual void HandleMessage(uint32_t sender, const void* data, uint8_t length)`
	`10`	`+ virtual void OnMessage(const MeshBase::Message* meta, const void* data, uint8_t length)`
`11`	`11`	`{`
`12`		`- Serial.print(sender, DEC);`
	`12`	`+ Serial.print(meta->address_from, DEC);`
`13`	`13`	`Serial.print(" : ");`
`14`	`14`	`Serial.println((const char*)data);`
`15`	`15`	`}`
`@@ -20,7 +20,7 @@ protected:`
`20`	`20`	`int len = snprintf(buff, 255, "Hello %u from %u", p->address, GetAddress());`
`21`	`21`	`Serial.print("Sending message: ");`
`22`	`22`	`Serial.println(buff);`
`23`		`- SendMessage(p->address, buff, len + 1);`
	`23`	`+ SendMessage(p->address, type_user, buff, len + 1);`
`24`	`24`	`}`
`25`	`25`	`};`
`26`	`26`