Increasing limit on 4 arguments with rpc
Page last updated 19 May 2010, by 
Mike Taylor.
0
replies
Mike Taylor.
0
replies
I've been trying to increase the number of arguments you can use with rpc. The reason for this was that I wanted to use rpc to send some numbers to other components using the I2C bus. The rpc_method_caller is overloaded to enable multiple argument types but this has only been limited up to 4 (which includes a function name).
Just FYI, I've been using the rpc class that was implemented here by Ilya - therefore I wanted to be able to browse to this address:
http://mbed_ip_address/rpc/myrpc1/i2c,160,1,2,3
Which ran the function called i2c and passed the 4 arguments. With 3 arguments it runs with no problem but more than that and the error message - No instance of overloaded function "mbed::rpc_method_caller" matches the required type (E386).
To increase you need to do the following....
1. Insert a modified Base.h file (we'll call it Base_extended.h) into your project and include that instead. Therefore, replace:
#include "Base.h"
with
#include "Base_extended.h"
within any project files. Create the file "Base_extended.h" and copy the modified code:
/* mbed Microcontroller Library - Base
* Copyright (c) 2006-2008 ARM Limited. All rights reserved.
* sford, jbrawn
*/
#ifndef MBED_BASE_H
#define MBED_BASE_H
#include "platform.h"
#include "PinNames.h"
#include "PeripheralNames.h"
#include
#include "DirHandle.h"
namespace mbed {
#ifdef MBED_RPC
struct rpc_function {
const char *name;
void (*caller)(const char*, char*);
};
struct rpc_class {
const char *name;
const rpc_function *static_functions;
struct rpc_class *next;
};
#endif
/* Class Base
* The base class for most things
*/
class Base {
public:
Base(const char *name = NULL);
virtual ~Base();
/* Function register_object
* Registers this object with the given name, so that it can be
* looked up with lookup. If this object has already been
* registered, then this just changes the name.
*
* Variables
* name - The name to give the object. If NULL we do nothing.
*/
void register_object(const char *name);
/* Function name
* Returns the name of the object, or NULL if it has no name.
*/
const char *name();
#ifdef MBED_RPC
/* Function rpc
* Call the given method with the given arguments, and write the
* result into the string pointed to by result. The default
* implementation calls rpc_methods to determine the supported
* methods.
*
* Variables
* method - The name of the method to call.
* arguments - A list of arguments separated by spaces.
* result - A pointer to a string to write the result into. May
* be NULL, in which case nothing is written.
*
* Returns
* true if method corresponds to a valid rpc method, or
* false otherwise.
*/
virtual bool rpc(const char *method, const char *arguments, char *result);
/* Function get_rpc_methods
* Returns a pointer to an array describing the rpc methods
* supported by this object, terminated by either
* RPC_METHOD_END or RPC_METHOD_SUPER(Superclass).
*
* Example
* > class Example : public Base {
* > int foo(int a, int b) { return a + b; }
* > virtual const struct rpc_method *get_rpc_methods() {
* > static const rpc_method rpc_methods[] = {
* > { "foo", generic_caller },
* > RPC_METHOD_SUPER(Base)
* > };
* > return rpc_methods;
* > }
* > };
*/
virtual const struct rpc_method *get_rpc_methods();
/* Function rpc
* Use the lookup function to lookup an object and, if
* successful, call its rpc method
*
* Variables
* returns - false if name does not correspond to an object,
* otherwise the return value of the call to the object's rpc
* method.
*/
static bool rpc(const char *name, const char *method, const char *arguments, char *result);
#endif
/* Function lookup
* Lookup and return the object that has the given name.
*
* Variables
* name - the name to lookup.
* len - the length of name.
*/
static Base *lookup(const char *name, unsigned int len);
static DirHandle *opendir();
friend class BaseDirHandle;
protected:
static Base *_head;
Base *_next;
const char *_name;
bool _from_construct;
private:
#ifdef MBED_RPC
static rpc_class *_classes;
static const rpc_function _base_funcs[];
static rpc_class _base_class;
#endif
void delete_self();
static void list_objs(const char *arguments, char *result);
static void clear(const char*,char*);
static char *new_name(Base *p);
public:
#ifdef MBED_RPC
/* Function add_rpc_class
* Add the class to the list of classes which can have static
* methods called via rpc (the static methods which can be called
* are defined by that class' get_rpc_class() static method).
*/
template
static void add_rpc_class() {
rpc_class *c = C::get_rpc_class();
c->next = _classes;
_classes = c;
}
template
static const char *construct() {
Base *p = new C();
p->_from_construct = true;
if(p->_name==NULL) {
p->register_object(new_name(p));
}
return p->_name;
}
template
static const char *construct(A1 arg1) {
Base *p = new C(arg1);
p->_from_construct = true;
if(p->_name==NULL) {
p->register_object(new_name(p));
}
return p->_name;
}
template
static const char *construct(A1 arg1, A2 arg2) {
Base *p = new C(arg1,arg2);
p->_from_construct = true;
if(p->_name==NULL) {
p->register_object(new_name(p));
}
return p->_name;
}
template
static const char *construct(A1 arg1, A2 arg2, A3 arg3) {
Base *p = new C(arg1,arg2,arg3);
p->_from_construct = true;
if(p->_name==NULL) {
p->register_object(new_name(p));
}
return p->_name;
}
template
static const char *construct(A1 arg1, A2 arg2, A3 arg3, A4 arg4) {
Base *p = new C(arg1,arg2,arg3,arg4);
p->_from_construct = true;
if(p->_name==NULL) {
p->register_object(new_name(p));
}
return p->_name;
}
/* extended by mjt (18/5/10) to allow more arguments */
template
static const char *construct(A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5) {
Base *p = new C(arg1,arg2,arg3,arg4,arg5);
p->_from_construct = true;
if(p->_name==NULL) {
p->register_object(new_name(p));
}
return p->_name;
}
template
static const char *construct(A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6) {
Base *p = new C(arg1,arg2,arg3,arg4,arg5, arg6);
p->_from_construct = true;
if(p->_name==NULL) {
p->register_object(new_name(p));
}
return p->_name;
}
#endif
};
/* Macro MBED_OBJECT_NAME_MAX
* The maximum size of object name (including terminating null byte)
* that will be recognised when using fopen to open a FileLike
* object, or when using the rpc function.
*/
#define MBED_OBJECT_NAME_MAX 32
/* Macro MBED_METHOD_NAME_MAX
* The maximum size of rpc method name (including terminating null
* byte) that will be recognised by the rpc function (in rpc.h).
*/
#define MBED_METHOD_NAME_MAX 32
} // namespace mbed
#endif
You'll notice towards the end of the file I've added 2 extra templates which handle 5 and 6 arguments - if you want more than this then just add further templates.
2. You're going to need to do a very similar thing with rpc.h. Create a new file called 'rpc_extended.h' within your project and paste the following code. You'll see the modified code about two thirds down which extends the rpc_method_caller. Remember to replace '#include rpc.h' with '#include rpc_extended.h' in all your project code
/* mbed Microcontroller Library - RPC
* Copyright (c) 2008-2009 ARM Limited. All rights reserved.
* sford
*/
#ifndef MBED_RPC_H
#define MBED_RPC_H
/* Section rpc
* Helpers for rpc handling.
*/
#include
#include
#include
#include
#include "Base.h"
#include "PinNames.h"
#include
namespace mbed {
/* Function parse_arg
* Parses and returns a value from a string.
*
* Variable
* arg - The string to pase
* next - If not NULL a pointer to after the last
* character parsed is written here
*/
template T parse_arg(const char *arg, const char **next);
inline char parse_char(const char *arg, const char **next) {
char c = *arg++;
if(c == '\\') {
c = *arg++;
switch(c) {
case 'a': c = '\a'; break;
case 'b': c = '\b'; break;
case 't': c = '\t'; break;
case 'n': c = '\n'; break;
case 'v': c = '\v'; break;
case 'f': c = '\f'; break;
case 'r': c = '\r'; break;
case 'x':
{
/* two-character hexadecimal */
char buf[3];
buf[0] = *arg++;
buf[1] = *arg++;
buf[2] = 0;
c = strtol(buf, NULL, 16);
}
break;
default:
if(isdigit(c)) {
/* three-character octal */
char buf[4];
buf[0] = c;
buf[1] = *arg++;
buf[2] = *arg++;
buf[3] = 0;
c = strtol(buf, NULL, 8);
}
break;
}
}
*next = arg;
return c;
}
/* signed integer types */
template<> inline int parse_arg(const char *arg, const char **next) {
if(arg[0] == '\'') {
char c = parse_char(arg+1, &arg);
if(next != NULL) *next = arg+1;
return c;
} else {
return strtol(arg, const_cast(next), 0);
}
}
template<> inline char parse_arg(const char *arg, const char **next) {
return parse_arg(arg,next);
}
template<> inline short int parse_arg(const char *arg, const char **next) {
return parse_arg(arg,next);
}
template<> inline long int parse_arg(const char *arg, const char **next) {
return parse_arg(arg,next);
}
template<> inline long long parse_arg(const char *arg, const char **next) {
return strtoll(arg, const_cast(next), 0);
}
/* unsigned integer types */
template<> inline unsigned int parse_arg(const char *arg, const char **next) {
if(arg[0] == '\'') {
char c = parse_char(arg+1, &arg);
if(next != NULL) *next = arg+1;
return c;
} else {
return strtoul(arg, const_cast(next), 0);
}
}
template<> inline unsigned char parse_arg(const char *arg, const char **next) {
return parse_arg(arg,next);
}
template<> inline unsigned short int parse_arg(const char *arg, const char **next) {
return parse_arg(arg,next);
}
template<> inline unsigned long int parse_arg(const char *arg, const char **next) {
return parse_arg(arg,next);
}
template<> inline unsigned long long parse_arg(const char *arg, const char **next) {
return strtoull(arg, const_cast(next), 0);
}
/* floating types */
template<> inline float parse_arg(const char *arg, const char **next) {
#if !defined(__ARMCC_VERSION) || __ARMCC_VERSION >= 410000
return strtof(arg,const_cast(next));
#elif __ARMCC_VERSION >= 310000
/* bug in header means no using declaration for strtof */
return std::strtof(arg,const_cast(next));
#else
/* strtof not supported */
return strtod(arg,const_cast(next));
#endif
}
template<> inline double parse_arg(const char *arg, const char **next) {
return strtod(arg,const_cast(next));
}
template<> inline long double parse_arg(const char *arg, const char **next) {
return strtod(arg,const_cast(next));
}
/* string */
template<> inline char *parse_arg(const char *arg, const char **next) {
const char *ptr = arg;
char *res = NULL;
if(*arg == '"') {
/* quoted string */
ptr = ++arg;
int len = 0;
/* find the end (and length) of the quoted string */
for(char c = *ptr; c != 0 && c != '"'; c = *++ptr) {
len++;
if(c == '\\') {
ptr++;
}
}
/* copy the quoted string, and unescape characters */
if(len != 0) {
res = new char[len+1];
char *resptr = res;
while(arg != ptr) {
*resptr++ = parse_char(arg, &arg);
}
*resptr = 0;
}
} else {
/* unquoted string */
while(isalnum(*ptr) || *ptr=='_') {
ptr++;
}
int len = ptr-arg;
if(len!=0) {
res = new char[len+1];
memcpy(res, arg, len);
res[len] = 0;
}
}
if(next != NULL) {
*next = ptr;
}
return res;
}
template<> inline const char *parse_arg(const char *arg, const char **next) {
return parse_arg(arg,next);
}
/* Pins */
inline PinName parse_pins(const char *str) {
const PinName pin_names[] = {p5, p6, p7, p8, p9, p10, p11, p12, p13, p14
, p15, p16, p17, p18, p19, p20, p21, p22, p23
, p24, p25, p26, p27, p28, p29, p30};
if(str[0] == 'P') { // Pn_n
uint32_t port = str[1] - '0';
uint32_t pin = str[3] - '0'; // Pn_n
uint32_t pin2 = str[4] - '0'; // Pn_nn
if(pin2 <= 9) {
pin = pin * 10 + pin2;
}
return (PinName)(LPC_GPIO0_BASE + port * 32 + pin);
} else if(str[0] == 'p') { // pn
uint32_t pin = str[1] - '0'; // pn
uint32_t pin2 = str[2] - '0'; // pnn
if(pin2 <= 9) {
pin = pin * 10 + pin2;
}
if(pin < 5 || pin > 30) {
return NC;
}
return pin_names[pin - 5];
} else if(str[0] == 'L') { // LEDn
switch(str[3]) {
case '1' : return LED1;
case '2' : return LED2;
case '3' : return LED3;
case '4' : return LED4;
}
} else if(str[0] == 'U') { // USB?X
switch(str[3]) {
case 'T' : return USBTX;
case 'R' : return USBRX;
}
}
return NC;
}
template<> inline PinName parse_arg(const char *arg, const char **next) {
const char *ptr = arg;
PinName pinname = NC;
while(isalnum(*ptr) || *ptr=='_') {
ptr++;
}
int len = ptr-arg;
if(len!=0) {
pinname = parse_pins(arg);
}
if(next != NULL) {
*next = ptr;
}
return pinname;
}
/* Function write_result
* Writes a value in to a result string in an appropriate manner
*
* Variable
* val - The value to write
* result - A pointer to the array to write the value into
*/
template void write_result(T val, char *result);
/* signed integer types */
template<> inline void write_result(char val, char *result) {
result[0] = val;
result[1] = '\0';
}
template<> inline void write_result(short int val, char *result) {
sprintf(result, "%hi", val);
}
template<> inline void write_result(int val, char *result) {
sprintf(result, "%i", val);
}
template<> inline void write_result(long int val, char *result) {
sprintf(result, "%li", val);
}
template<> inline void write_result(long long int val, char *result) {
sprintf(result, "%lli", val);
}
/* unsigned integer types */
template<> inline void write_result(unsigned char val, char *result) {
result[0] = val;
result[1] = '\0';
}
template<> inline void write_result(unsigned short int val, char *result) {
sprintf(result, "%hu", val);
}
template<> inline void write_result(unsigned int val, char *result) {
sprintf(result, "%u", val);
}
template<> inline void write_result(unsigned long int val, char *result) {
sprintf(result, "%lu", val);
}
template<> inline void write_result(unsigned long long int val, char *result) {
sprintf(result, "%llu", val);
}
/* floating types */
template<> inline void write_result(float val, char *result) {
sprintf(result, "%.17g", val);
}
template<> inline void write_result(double val, char *result) {
sprintf(result, "%.17g", val);
}
template<> inline void write_result(long double val, char *result) {
sprintf(result, "%.17Lg", val);
}
/* string */
template<> inline void write_result(char *val, char *result) {
if(val==NULL) {
result[0] = 0;
} else {
strcpy(result, val);
}
}
template<> inline void write_result(const char *val, char *result) {
if(val==NULL) {
result[0] = 0;
} else {
strcpy(result, val);
}
}
inline const char *next_arg(const char* next) {
while(*next == ' ') next++;
if(*next == ',' || *next == '?') next++;
while(*next == ' ') next++;
return next;
}
/* Function rpc_method_caller
*/
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
(static_cast(this_ptr)->*member)(arguments,result);
}
/* Function rpc_method_caller
*/
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
(static_cast(this_ptr)->*member)();
if(result != NULL) {
result[0] = '\0';
}
}
/* Function rpc_method_caller
*/
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),NULL);
(static_cast(this_ptr)->*member)(arg1);
if(result != NULL) {
result[0] = '\0';
}
}
/* Function rpc_method_caller
*/
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),&next);
A2 arg2 = parse_arg(next_arg(next),NULL);
(static_cast(this_ptr)->*member)(arg1,arg2);
if(result != NULL) {
result[0] = '\0';
}
}
/* Function rpc_method_caller
*/
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),&next);
A2 arg2 = parse_arg(next_arg(next),&next);
A3 arg3 = parse_arg(next_arg(next),NULL);
(static_cast(this_ptr)->*member)(arg1,arg2,arg3);
if(result != NULL) {
result[0] = '\0';
}
}
/* Function rpc_method_caller
added by mjt (18/5/10) to enable four arguments in rpc method call */
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),&next);
A2 arg2 = parse_arg(next_arg(next),&next);
A3 arg3 = parse_arg(next_arg(next),&next);
A4 arg4 = parse_arg(next_arg(next),NULL);
(static_cast(this_ptr)->*member)(arg1,arg2,arg3,arg4);
if(result != NULL) {
result[0] = '\0';
}
}
/* Function rpc_method_caller
added by mjt (18/5/10) to enable five arguments in rpc method call */
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),&next);
A2 arg2 = parse_arg(next_arg(next),&next);
A3 arg3 = parse_arg(next_arg(next),&next);
A4 arg4 = parse_arg(next_arg(next),&next);
A5 arg5 = parse_arg(next_arg(next),NULL);
(static_cast(this_ptr)->*member)(arg1,arg2,arg3,arg4,arg5);
if(result != NULL) {
result[0] = '\0';
}
}
/* Function rpc_method_caller
*/
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
R res = (static_cast(this_ptr)->*member)();
if(result != NULL) {
write_result(res, result);
}
}
/* Function rpc_method_caller
*/
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),NULL);
R res = (static_cast(this_ptr)->*member)(arg1);
if(result != NULL) {
write_result(res, result);
}
}
/* Function rpc_method_caller
*/
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),&next);
A2 arg2 = parse_arg(next_arg(next),NULL);
R res = (static_cast(this_ptr)->*member)(arg1,arg2);
if(result != NULL) {
write_result(res, result);
}
}
/* Function rpc_method_caller
*/
template
void rpc_method_caller(Base *this_ptr, const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),&next);
A2 arg2 = parse_arg(next_arg(next),&next);
A3 arg3 = parse_arg(next_arg(next),NULL);
R res = (static_cast(this_ptr)->*member)(arg1,arg2,arg3);
if(result != NULL) {
write_result(res, result);
}
}
/* Function rpc_function caller
*/
template
void rpc_function_caller(const char *arguments, char *result) {
R res = (*func)();
if(result != NULL) {
write_result(res, result);
}
}
/* Function rpc_function caller
*/
template
void rpc_function_caller(const char *arguments, char *result) {
A1 arg1 = parse_arg(next_arg(arguments),NULL);
R res = (*func)(arg1);
if(result != NULL) {
write_result(res, result);
}
}
/* Function rpc_function caller
*/
template
void rpc_function_caller(const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),&next);
A2 arg2 = parse_arg(next_arg(next),NULL);
R res = (*func)(arg1,arg2);
if(result != NULL) {
write_result(res, result);
}
}
/* Function rpc_function caller
*/
template
void rpc_function_caller(const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),&next);
A2 arg2 = parse_arg(next_arg(next),&next);
A3 arg3 = parse_arg(next_arg(next),NULL);
R res = (*func)(arg1,arg2,arg3);
if(result != NULL) {
write_result(res, result);
}
}
/* Function rpc_function caller
*/
template
void rpc_function_caller(const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),&next);
A2 arg2 = parse_arg(next_arg(next),&next);
A3 arg3 = parse_arg(next_arg(next),&next);
A4 arg4 = parse_arg(next_arg(next),NULL);
R res = (*func)(arg1,arg2,arg3,arg4);
if(result != NULL) {
write_result(res, result);
}
}
template
void rpc_function_caller(const char *arguments, char *result) {
const char *next = arguments;
A1 arg1 = parse_arg(next_arg(next),&next);
A2 arg2 = parse_arg(next_arg(next),&next);
A3 arg3 = parse_arg(next_arg(next),&next);
A4 arg4 = parse_arg(next_arg(next),&next);
A5 arg5 = parse_arg(next_arg(next),NULL);
R res = (*func)(arg1,arg2,arg3,arg4,arg5);
if(result != NULL) {
write_result(res, result);
}
}
struct rpc_method {
const char *name;
typedef void (*caller_t)(Base*, const char*, char*);
typedef const struct rpc_method *(*super_t)(Base*);
union {
caller_t caller;
super_t super;
};
};
template
const struct rpc_method *rpc_super(Base *this_ptr) {
return static_cast(this_ptr)->C::get_rpc_methods();
}
#define RPC_METHOD_END { NULL, NULL }
#define RPC_METHOD_SUPER(C) { NULL, (rpc_method::caller_t)(rpc_method::super_t)rpc_super }
/* Function rpc
* Parse a string describing a call and then do it
*
* Variables
* call - A pointer to a string describing the call, which has
* the form /object/method arg ... argn. Arguments are
* delimited by space characters, and the string is terminated
* by a null character.
* result - A pointer to an array to write the result into.
*/
bool rpc(const char *buf, char *result = 0);
} // namespace mbed
#endif
0 comments
You need to log in to post a comment
Increasing limit on 4 arguments with rpc
Page owner: Mike Taylor
Created 19 May 2010.
Last updated 19 May 2010