rpc: rename header and singleton

facchinm · facchinm · commit 104cef4f254f · 2021-11-09T09:24:29.000+01:00
diff --git a/libraries/RPC/examples/RPC_m4/RPC_m4.ino b/libraries/RPC/examples/RPC_m4/RPC_m4.ino
@@ -1,5 +1,5 @@
 #include "Arduino.h"
-#include "RPC_internal.h"
+#include "RPC.h"
 
 using namespace rtos;
 
@@ -40,11 +40,11 @@ void callSubstractFromM4() {
     delay(700); // Wait 700ms with the next calculation
     int a = random(100); // Generate a random number
     int b = random(100); // Generate a random number
-    RPC1.println(currentCPU() + ": calling subtract with " + String(a) + " and " + String(b));
+    RPC.println(currentCPU() + ": calling subtract with " + String(a) + " and " + String(b));
     
-    auto result = RPC1.call("remoteSubtract", a, b).as<int>();
+    auto result = RPC.call("remoteSubtract", a, b).as<int>();
     // Prints the result of the calculation
-    RPC1.println(currentCPU() + ": Result is " + String(a) + " - " + String(b) + " = " + String(result));
+    RPC.println(currentCPU() + ": Result is " + String(a) + " - " + String(b) + " = " + String(result));
   }
 }
 
@@ -53,7 +53,7 @@ void setup() {
   pinMode(LED_BUILTIN, OUTPUT);
 
   // Initialize RPC library; this also boots the M4 core
-  RPC1.begin();
+  RPC.begin();
   Serial.begin(115200);
   //while (!Serial) {} // Uncomment this to wait until the Serial connection is ready
 
@@ -62,8 +62,8 @@ void setup() {
 
   if (currentCPU() == "M7") {
     // M7 CPU becomes the server, so it makes two functions available under the defined names
-    RPC1.bind("remoteAdd", addOnM7);
-    RPC1.bind("remoteSubtract", subtractOnM7);
+    RPC.bind("remoteAdd", addOnM7);
+    RPC.bind("remoteSubtract", subtractOnM7);
   } 
 
   if (currentCPU() == "M4") {
@@ -86,20 +86,20 @@ void loop() {
     int b = random(100);
     // PRC.print works like a Serial port, but it needs a receiver (in this case the M7) 
     // to actually print the strings to the Serial port
-    RPC1.println(currentCPU() + ": calling add with " + String(a) + " and " + String(b));
+    RPC.println(currentCPU() + ": calling add with " + String(a) + " and " + String(b));
     // Let's invoke addOnM7() and wait for a result.
     // This will be delayed by the forced delay() in addOnM7() function
     // Exercise: if you are not interested in the result of the operation, what operation would you invoke?
-    auto result = RPC1.call("remoteAdd", a, b).as<int>();    
-    RPC1.println(currentCPU() + ": Result is " + String(a) + " + " + String(b) + " = " + String(result));
+    auto result = RPC.call("remoteAdd", a, b).as<int>();    
+    RPC.println(currentCPU() + ": Result is " + String(a) + " + " + String(b) + " = " + String(result));
   }
   
   if (currentCPU() == "M7") {
     // On M7, let's print everything that is received over the RPC1 stream interface
     // Buffer it, otherwise all characters will be interleaved by other prints
     String buffer = "";
-    while (RPC1.available()) {
-      buffer += (char)RPC1.read(); // Fill the buffer with characters
+    while (RPC.available()) {
+      buffer += (char)RPC.read(); // Fill the buffer with characters
     }
 
     if (buffer.length() > 0) {
diff --git a/libraries/RPC/examples/SerialPassthrough_RPC/SerialPassthrough_RPC.ino b/libraries/RPC/examples/SerialPassthrough_RPC/SerialPassthrough_RPC.ino
@@ -1,15 +1,15 @@
 #include "Arduino.h"
-#include "RPC_internal.h"
+#include "RPC.h"
 
 void setup() {
   Serial.begin(115200);
-  RPC1.begin();
+  RPC.begin();
 }
 
 void loop() {
   String data = "";
-  while (RPC1.available()) {
-    data += (char)RPC1.read();
+  while (RPC.available()) {
+    data += (char)RPC.read();
   }
   if (data != "") {
     Serial.write(data.c_str(), data.length());
@@ -19,6 +19,6 @@ void loop() {
     data += (char)Serial.read();
   }
   if (data != "") {
-    RPC1.write(data.c_str(), data.length());
+    RPC.write(data.c_str(), data.length());
   }
 }
diff --git a/libraries/RPC/src/RPC.cpp b/libraries/RPC/src/RPC.cpp
@@ -1,4 +1,4 @@
-#include "RPC_internal.h"
+#include "RPC.h"
 
 static struct rpmsg_endpoint rp_endpoints[4];
 
@@ -16,10 +16,10 @@ static RingBufferN<256> intermediate_buffer_resp;
 //static uint8_t intermediate_buffer_resp[256];
 static rtos::Mutex rx_mtx;
 
-int RPC::rpmsg_recv_callback(struct rpmsg_endpoint *ept, void *data,
+int RPCClass::rpmsg_recv_callback(struct rpmsg_endpoint *ept, void *data,
                                        size_t len, uint32_t src, void *priv)
 {
-  RPC* rpc = (RPC*)priv;
+  RPCClass* rpc = (RPCClass*)priv;
 
   for (size_t i = 0; i < len; i++) {
     intermediate_buffer.store_char(((uint8_t*)data)[i]);
@@ -33,10 +33,10 @@ int RPC::rpmsg_recv_callback(struct rpmsg_endpoint *ept, void *data,
 
 static bool first_message = true;
 
-int RPC::rpmsg_recv_response_callback(struct rpmsg_endpoint *ept, void *data,
+int RPCClass::rpmsg_recv_response_callback(struct rpmsg_endpoint *ept, void *data,
                                        size_t len, uint32_t src, void *priv)
 {
-  RPC* rpc = (RPC*)priv;
+  RPCClass* rpc = (RPCClass*)priv;
 
 #ifdef CORE_CM4
       if (first_message) {
@@ -57,7 +57,7 @@ int RPC::rpmsg_recv_response_callback(struct rpmsg_endpoint *ept, void *data,
   return 0;
 }
 
-void RPC::new_service_cb(struct rpmsg_device *rdev, const char *name, uint32_t dest)
+void RPCClass::new_service_cb(struct rpmsg_device *rdev, const char *name, uint32_t dest)
 {
   if (strcmp(name, "raw") == 0) {
     OPENAMP_create_endpoint(&rp_endpoints[ENDPOINT_RAW], name, dest, rpmsg_recv_callback, NULL);
@@ -127,7 +127,7 @@ static void disableCM4Autoboot() {
   }
 }
 
-int RPC::begin() {
+int RPCClass::begin() {
 
 	OpenAMP_MPU_Config();
 
@@ -141,10 +141,10 @@ int RPC::begin() {
 	eventThread->start(&eventHandler);
 
   dispatcherThread = new rtos::Thread(osPriorityNormal);
-  dispatcherThread->start(mbed::callback(this, &RPC::dispatch));
+  dispatcherThread->start(mbed::callback(this, &RPCClass::dispatch));
 
   responseThread = new rtos::Thread(osPriorityNormal);
-  responseThread->start(mbed::callback(this, &RPC::response));
+  responseThread->start(mbed::callback(this, &RPCClass::response));
 
 	/* Initialize OpenAmp and libmetal libraries */
 	if (MX_OPENAMP_Init(RPMSG_MASTER, new_service_cb) !=  HAL_OK) {
@@ -182,16 +182,16 @@ int RPC::begin() {
 
 #ifdef CORE_CM4
 
-int RPC::begin() {
+int RPCClass::begin() {
 
   eventThread = new rtos::Thread(osPriorityHigh);
   eventThread->start(&eventHandler);
 
   dispatcherThread = new rtos::Thread(osPriorityNormal);
-  dispatcherThread->start(mbed::callback(this, &RPC::dispatch));
+  dispatcherThread->start(mbed::callback(this, &RPCClass::dispatch));
 
   responseThread = new rtos::Thread(osPriorityNormal);
-  responseThread->start(mbed::callback(this, &RPC::response));
+  responseThread->start(mbed::callback(this, &RPCClass::response));
 
   /* Initialize OpenAmp and libmetal libraries */
   if (MX_OPENAMP_Init(RPMSG_REMOTE, NULL) !=  0) {
@@ -221,7 +221,7 @@ int RPC::begin() {
 
 using raw_call_t = std::tuple<RPCLIB_MSGPACK::object>;
 
-void RPC::response() {
+void RPCClass::response() {
   responseThreadId = osThreadGetId();
 
   for (int i = 0; i< 10; i++) {
@@ -269,7 +269,7 @@ void RPC::response() {
   }
 }
 
-void RPC::dispatch() {
+void RPCClass::dispatch() {
 
   dispatcherThreadId = osThreadGetId();
 
@@ -322,16 +322,16 @@ void RPC::dispatch() {
 }
 
 
-size_t RPC::write(uint8_t c) {
+size_t RPCClass::write(uint8_t c) {
   write(&c, 1);
   return 1;
 }
 
-size_t RPC::write(const uint8_t* buf, size_t len) {
+size_t RPCClass::write(const uint8_t* buf, size_t len) {
   return write(ENDPOINT_RAW, buf, len);
 }
 
-size_t RPC::write(uint8_t ep, const uint8_t* buf, size_t len) {
+size_t RPCClass::write(uint8_t ep, const uint8_t* buf, size_t len) {
 
   std::vector<uint8_t> tx_buffer;
   for (size_t i = 0; i < len; i++) {
@@ -347,4 +347,4 @@ size_t RPC::write(uint8_t ep, const uint8_t* buf, size_t len) {
   return len;
 }
 
-arduino::RPC RPC1;
+arduino::RPCClass RPC;
diff --git a/libraries/RPC/src/RPC.h b/libraries/RPC/src/RPC.h
@@ -41,9 +41,9 @@ typedef struct _service_request {
 
 namespace arduino {
 
-class RPC : public Stream, public rpc::detail::dispatcher {
+class RPCClass : public Stream, public rpc::detail::dispatcher {
 	public:
-		RPC() {};
+		RPCClass() {};
 		int begin();
 		void end() {};
 		int available(void) {
@@ -132,7 +132,7 @@ class RPC : public Stream, public rpc::detail::dispatcher {
 };
 }
 
-extern arduino::RPC RPC1;
+extern arduino::RPCClass RPC;
 
 #endif
 #endif
diff --git a/libraries/RPC/src/RPC_client.h b/libraries/RPC/src/RPC_client.h
@@ -4,7 +4,7 @@
 
 //forward declaration
 namespace arduino {
-class RPC;
+class RPCClass;
 }
 
 namespace rpc {
@@ -62,7 +62,7 @@ class client {
 
   protected:
     osThreadId callThreadId;
-    friend class arduino::RPC;
+    friend class arduino::RPCClass;
     RPCLIB_MSGPACK::object_handle result;
 
   private:
diff --git a/libraries/RPC/src/SerialRPC.h b/libraries/RPC/src/SerialRPC.h
@@ -1,4 +1,4 @@
-#include "RPC_internal.h"
+#include "RPC.h"
 #include "Arduino.h"
 
 namespace arduino {
@@ -45,22 +45,22 @@ class SerialRPCClass : public Stream {
 		for (size_t i=0; i < len; i++) {
 			tx_buffer.push_back(buf[i]);
 		}
-		RPC1.call("on_write", tx_buffer);
+		RPC.call("on_write", tx_buffer);
 		return len;
 	}
 
 	using Print::write;
 
 	int begin() {
-		if (RPC1.begin() == 0) {
+		if (RPC.begin() == 0) {
 			return 0;
 		}
-		RPC1.bind("on_write", mbed::callback(this, &SerialRPCClass::onWrite));
+		RPC.bind("on_write", mbed::callback(this, &SerialRPCClass::onWrite));
 		return 1;
 	}
 
 	operator bool() {
-		return RPC1;
+		return RPC;
 	}
 
     void attach(void (*fptr)(void))

Original file line number	Diff line number	Diff line change
`@@ -1,15 +1,15 @@`
`1`	`1`	`#include "Arduino.h"`
`2`		`-#include "RPC_internal.h"`
	`2`	`+#include "RPC.h"`
`3`	`3`
`4`	`4`	`void setup() {`
`5`	`5`	`Serial.begin(115200);`
`6`		`- RPC1.begin();`
	`6`	`+ RPC.begin();`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`void loop() {`
`10`	`10`	`String data = "";`
`11`		`- while (RPC1.available()) {`
`12`		`- data += (char)RPC1.read();`
	`11`	`+ while (RPC.available()) {`
	`12`	`+ data += (char)RPC.read();`
`13`	`13`	`}`
`14`	`14`	`if (data != "") {`
`15`	`15`	`Serial.write(data.c_str(), data.length());`
`@@ -19,6 +19,6 @@ void loop() {`
`19`	`19`	`data += (char)Serial.read();`
`20`	`20`	`}`
`21`	`21`	`if (data != "") {`
`22`		`- RPC1.write(data.c_str(), data.length());`
	`22`	`+ RPC.write(data.c_str(), data.length());`
`23`	`23`	`}`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#include "RPC_internal.h"`
	`1`	`+#include "RPC.h"`
`2`	`2`	`#include "Arduino.h"`
`3`	`3`
`4`	`4`	`namespace arduino {`
`@@ -45,22 +45,22 @@ class SerialRPCClass : public Stream {`
`45`	`45`	`for (size_t i=0; i < len; i++) {`
`46`	`46`	`tx_buffer.push_back(buf[i]);`
`47`	`47`	`}`
`48`		`- RPC1.call("on_write", tx_buffer);`
	`48`	`+ RPC.call("on_write", tx_buffer);`
`49`	`49`	`return len;`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`using Print::write;`
`53`	`53`
`54`	`54`	`int begin() {`
`55`		`- if (RPC1.begin() == 0) {`
	`55`	`+ if (RPC.begin() == 0) {`
`56`	`56`	`return 0;`
`57`	`57`	`}`
`58`		`- RPC1.bind("on_write", mbed::callback(this, &SerialRPCClass::onWrite));`
	`58`	`+ RPC.bind("on_write", mbed::callback(this, &SerialRPCClass::onWrite));`
`59`	`59`	`return 1;`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`operator bool() {`
`63`		`- return RPC1;`
	`63`	`+ return RPC;`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`void attach(void (*fptr)(void))`