Linux 上串口PRC 协议的实现

最新推荐文章于 2024-01-22 22:29:43 发布
最新推荐文章于 2024-01-22 22:29:43 发布
阅读量1.6k 收藏 4
点赞数
分类专栏： mbed linux C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaojiawan/article/details/90599289
版权
linux 同时被 3 个专栏收录
46 篇文章 4 订阅
订阅专栏
C++
46 篇文章 6 订阅
订阅专栏
mbed
22 篇文章 6 订阅
订阅专栏

      最近一直在研究如何实高性能Cortex-A 处理器在工业控制，物联网领域的应用。Cortex-A 内核的SOC 芯片通常运行linux OS ，直接支持的硬件接口不多，而且不够灵活。我们倾向采用cortex-M 单片机作为Cortex-A的扩展IO来使用。为了提高软件研发的效率cortex-M 运行Arm 公司的Mbed OS。

那么问题来了，Cortex-M 和Cortex-A 之间如何通信和控制呢？硬件方面我们尝试果Ethernet，SPI 和UART。软件方面采用各种自定义的交换协议。本文介绍如何在USB 串口上实现RPC 协议。

    RPC 的全称是远程过程调用（Remote procedure call），它是一个比较古老的协议。伴随着TCP/IP 协议的出现就出现了。 RPC 是request/response的架构。

   

        现在RPC 协议可以在许多协议上实现，例如HTTP。当然也可以在串口上实现。

信息格式更加倾向于XML和json格式。例如在json rpc 协议中：

--> {"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}

<-- {"jsonrpc": "2.0", "result": 19, "id": 1}

    我在另一篇博文《关于jsonrpc》一文中有关于jsonrpc比较详细的介绍。

RPC 在串口上的实现

    在cortex-M 的串口上实现json 格式的PRC 开销比较大，需要进行json 的解析。涉及数据格式转换，传输的时间也占有比较大，所以我们并不倾向使用jsonrpc 来实现cotex-M上的RPC协议，而是采纳了类似MODBUS RTU帧结构的形式来实现

请求（Request）

Address（1 Byte）

method（1 Byte）

length（2 Byte）

parameters（N Byte)

LRC(2 Byte)

响应（Response）

 

Address(1 Byte)

method(1 Byte)

length(2 Byte)

results(N Byte)

LRC(2 Byte)

 address，method 是1 个字节，length 为两个字节，高位在前，低位在后。

 results和parameters 是长度为length 的字节。而LRC是2个字节。

serialRPC 类

 下面是serial PRC类的实现。

linux 端(serialRPC.hpp)

#include "serialPort.hpp"
#include <stdint.h>
class serialRPC 
{
private:
   
	uint8_t _method;
	uint8_t _address;
	uint8_t sbuf[32];
    uint8_t rbuf[32];
	unsigned int calculateCRC16( uint8_t *puchMsg,unsigned int  usDataLen);
public:
    serialRPC();
    bool init(const char * dev);	
    bool callMethod(uint8_t address,uint8_t Method,uint8_t *data,int length );
	bool waitResult(uint8_t * data);
};

serialRPC.cpp

#include "serialRPC.hpp"
#include <iostream>
#define    DEFAULT_BAUD_RATE   9600
 serialPort serial;
      const  uint8_t auchCRCHi[256]={
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
    0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
    0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
    0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
    0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
    0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
    0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
    0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
    0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
    0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
    0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
    0x40
};
const  uint8_t auchCRCLo[256]={
    0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
    0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
    0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
    0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
    0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
    0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
    0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
    0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
    0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
    0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
    0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
    0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
    0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
    0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
    0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
    0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
    0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
    0x40
};
 serialRPC::serialRPC() 
			{
			_method=-1;
			}
 bool serialRPC::init(const char * dev)
 {            cout<<"seerial init:"<< endl;
	         serial.OpenPort(dev);
             cout<<"serial Setup"<< endl;			 
	   return  serial.setup(19200,0,8,1,'N');  
 
			 
 } 
 bool serialRPC::callMethod(uint8_t address,uint8_t method,uint8_t *data,int length )
 {
	  int index,i;
    index=0;
	 _address=address;
     _method=method;
    sbuf[index++]=address;
    sbuf[index++]=method;
    sbuf[index++]=(length>>8)&0xff;
    sbuf[index++]=length&0xff;
	for (i=0;i<length;i++)
		sbuf[index++]=data[i];
    unsigned short resultCRC =  calculateCRC16(sbuf,index); 
    sbuf[index++]=(resultCRC>>8)&0xff;
    sbuf[index++]=resultCRC&0xff; 
	serial.writeBuffer(sbuf, index);
    return true;
 }
 bool serialRPC::waitResult(uint8_t * data)
 {
	   unsigned short resultCRC ,recCRC;
    
    int state,index,i;
	uint16_t len,cnt;
    uint8_t ch;
    bool flag;
     flag=true;
     state=0;
     index=0;
     while(flag)
     { 
         ch=serial.getchar();
        
         switch(state)
         {
             case 0:{
                 if (ch==_address)
                   {state=1;
                   rbuf[index++]=ch;}
                 break;
                 }
            case 1:{
               
              if (ch==_method)
                   {state=2;rbuf[index++]=ch;}
                   else if(ch==(_method+0x80))
                     state=10;
                     else 
                     return 0;
                 break;
                 }
             case 2:{
                    len=ch;
                    rbuf[index++]=ch;
                    state=3;
                    break;
                    } 
			case 3:{
				   len=(len<<8)&0xff00+ch;cnt=len;
				    rbuf[index++]=ch;
					if (cnt>0)
                    state=4;
				else 
					 state=5;
                    break;
			}		
             case 4:{
                    rbuf[index++]=ch;
                    cnt--;
                    if (cnt==0)
                      { 
                      state=5;
                     
                      }
                    break;
                    }
              case 5:{
                     recCRC=ch;
                     state=6;
                     break;
                     } 
              case 6:{
                     recCRC=(recCRC<<8)|ch;
                      resultCRC =  calculateCRC16(rbuf,index);  
                   //  printf("CRC=%02x,%02x\n",recCRC,resultCRC);
                     if (recCRC==resultCRC) {
                         for (i=0;i<len;i++)
                           data[i]=rbuf[4+i];
                         return len;
                         }
                     else return 0;
                     }
               case 10:{
                       len=0;
                       flag=false;
                       break;
                       }                            
             }
         } 
    
        return len;
 }
 unsigned int  serialRPC::calculateCRC16( uint8_t *puchMsg,unsigned int  usDataLen)
{
    unsigned char uchCRCHi,uchCRCLo;
    unsigned char uIndex=0 ;                             /* will index into CRC lookup table */
    unsigned char tempp=0;
    unsigned int CRCHL=0;
    uchCRCHi=0xFF ;                             // high byte of CRC initialized 
    uchCRCLo=0xFF ; 
    tempp=0;                           // low byte of CRC initialized 
    while(usDataLen--)                       // pass through message buffer 
    {
        uIndex=uchCRCHi^*puchMsg++ ; // calculate the CRC high byte         
        tempp++;
        uchCRCHi=uchCRCLo^auchCRCHi[uIndex] ;//01-auchCRCHi[254]:0x81;02-0x01;03-0x80;04-0xC0
        uchCRCLo=auchCRCLo[uIndex] ;               
    }
    CRCHL=uchCRCHi;
    CRCHL=CRCHL<<8;
    CRCHL|=uchCRCLo;        
    return CRCHL;//(uchCRCHi<<8|uchCRCLo) ;//uchCRCHi:0xa1;uchCRCLo:2B
}

mbed 端

serialRPC.h

#include "mbed.h"
#include "USBSerial.h"
class serialRPC
{
    public :
    serialRPC();
    bool connect();
    uint8_t waitCall(uint8_t *data);
     bool sendResult(uint8_t *data,int length);
    private:
      USBSerial serial;
      int _method;
      int _address;
      uint8_t sbuf[32];
      uint8_t rbuf[32];
      void readBuffer(uint8_t * buf,int length);
      void writeBuffer(uint8_t * buf,int length);
      unsigned int  calculateCRC16( uint8_t *puchMsg,unsigned int  usDataLen);
    };

serialRPC.cpp(mbed OS）

#include "serialRPC.h"
#define   DEFAULT_BAUD_RATE   115200
    const  char auchCRCHi[256]={
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
    0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
    0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
    0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
    0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
    0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
    0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
    0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
    0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
    0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
    0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
    0x40
};
const  char auchCRCLo[256]={
    0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
    0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
    0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
    0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
    0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
    0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
    0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
    0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
    0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
    0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
    0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
    0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
    0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
    0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
    0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
    0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
    0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
    0x40
};

serialRPC::serialRPC() 
:serial(false,0x1f00,0x2012,0x0001) 
{   
   
    serial.init();
    _address=0x00;
}
bool serialRPC::connect()
{
   serial.connect();
   serial. wait_ready();
    return true;
    }
uint8_t  serialRPC::waitCall(uint8_t *data)
{  
      unsigned short resultCRC ,recCRC,len,cnt;    
    int state,index,i;
    uint8_t ch;
    bool flag;
     flag=true;
     state=0;
     index=0;
     while(flag)
     { 
     while(! serial.readable()){};
      ch=serial.getc();
        printf("0x%2.2X ",ch);
         switch(state)
         {
             case 0:{
                    _address=ch;
                if (_address==0x00)
                 {  
                  state=1;
                   rbuf[index++]=ch; 
                   }
                 break;
                 }
            case 1:{                            
                   _method=ch;
                   state=2;
                   rbuf[index++]=ch;                  
                 break;
                 }
             case 2:{
                    len=ch;
                    rbuf[index++]=ch;
                    state=3;
                    break;
                    }
             case 3:{
                    len=(len<<8)&0xff00|ch;
                    rbuf[index++]=ch;
                    if (len>0)
                    {
                        cnt=len;
                        state=4;
                      } else state=5;
                     break; 
                    }        
             case 4:{
                    rbuf[index++]=ch;
                    cnt--;
                    if (cnt==0)
                      { 
                      state=5;
                     
                      }
                    break;
                    }
              case 5:{
                     recCRC=ch;
                     state=6;
                     break;
                     } 
              case 6:{
                     recCRC=(recCRC<<8)|ch;
                      resultCRC =  calculateCRC16(rbuf,index);  
                     printf("CRC=0x%2.2X 0x%2.2X\n",recCRC,resultCRC);
                     if (recCRC==resultCRC) {
                         for (i=0;i<len;i++)
                           data[i]=rbuf[4+i];                         
                         return _method;
                         }
                     else return 0;
                     }                          
             }
         } 
  
        return _method;
    }
bool   serialRPC::sendResult(uint8_t *data,int length)
{
  unsigned short resultCRC;
  int index,i;
  index=0;
     sbuf[index++]=_address;
     sbuf[index++]=_method;
     sbuf[index++]= (length>>8)&0xff;
      sbuf[index++]= length&0xff;
    for (i=0;i<length;i++)
     sbuf[index++]=data[i];
     resultCRC =  calculateCRC16(rbuf,index);  
     sbuf[index++]=(resultCRC>>8)&0xff;
     sbuf[index++]=resultCRC &0xff;
     writeBuffer(sbuf,index);
      return true;
    }
 void serialRPC::readBuffer(uint8_t * buf,int length)
{
    int i;
    for (i=0;i<length;i++)
     {
        while(!serial.readable()){};
        buf[i]=serial._getc();
        
         }
}
void serialRPC::writeBuffer(uint8_t * buf,int length)
{
    int i;
    for (i=0;i<length;i++)
     {
        while(!serial.writeable()){};
       serial._putc(buf[i]);
         }
}   
unsigned int  serialRPC::calculateCRC16( uint8_t *puchMsg,unsigned int  usDataLen)
{
    unsigned char uchCRCHi,uchCRCLo;
    unsigned char uIndex=0 ;                             /* will index into CRC lookup table */
    unsigned char tempp=0;
    unsigned int CRCHL=0;
    uchCRCHi=0xFF ;                             // high byte of CRC initialized 
    uchCRCLo=0xFF ; 
    tempp=0;                           // low byte of CRC initialized 
    while(usDataLen--)                       // pass through message buffer 
    {
        uIndex=uchCRCHi^*puchMsg++ ; // calculate the CRC high byte         
        tempp++;
        uchCRCHi=uchCRCLo^auchCRCHi[uIndex] ;//01-auchCRCHi[254]:0x81;02-0x01;03-0x80;04-0xC0
        uchCRCLo=auchCRCLo[uIndex] ;               
    }
    CRCHL=uchCRCHi;
    CRCHL=CRCHL<<8;
    CRCHL|=uchCRCLo;        
   return CRCHL;//(uchCRCHi<<8|uchCRCLo) ;//uchCRCHi:0xa1;uchCRCLo:2B
}

测试程序

该测试软件由linux 程序调用mbed OS 上的flipflop 程序，控制LED1 灯翻转。

Mbed  端

#include "mbed.h"
#include "serialRPC.h"
#include "method.h"
DigitalOut led1(LED1);
DigitalOut led2(LED2);
uint8_t buf[32];
serialRPC rpc;
int main()
{ 
uint8_t Method;
uint8_t val;
 led1=1;
 led2=1;
  printf("RPC over Serial Test\n");
  rpc.connect();
  printf("connected\n");
    while (true) {
     Method=rpc.waitCall(buf);
     switch (Method)
     {
       case DegitalOut_Write:{
           switch(buf[0])
           {
            case 1:{led1=buf[1];break;}
            case 2:{led2=buf[1];break;}
            }
            buf[0]=OK;
            rpc.sendResult(buf,1);
            break;
            }
       case DegitalOut_Read:{
               switch(buf[0])
           {
            case 1:{val=led1;break;}
            case 2:{val=led2;break;}
            }
            buf[0]=val;
            rpc.sendResult(buf,1);
            break;
            } 
       case DegitalOut_Filpflop:{
             switch(buf[0])
           {
            case 1:{led1=!led1;break;}
            case 2:{led2=!led2;break;}
            }
            buf[0]=OK;
          rpc.sendResult(buf,1);
            break;
            }  
        }
     }   
}

linux 端（serialRPCTest）

#include "serialRPC.hpp"
#include <iostream>
#include <iomanip>
#define DigitalOut_Write  	   0
#define DigitalOut_Read    	   1
#define DigitalOut_Filpflop    2  
  serialRPC interface;
class DigitalOut
{   private:
    
	  int _gpio;
	  bool _value;
	  uint8_t buf[32];
	public:
	   DigitalOut(int gpio)
	   {
		  _gpio= gpio;
		  
	   }

	   void write(bool value)	
	   {   
	       buf[0]=_gpio;
		   buf[1]=value;
		   interface.callMethod(0,DigitalOut_Write,buf,2);
		   interface.waitResult(buf);
		   _value=value;
	   }
	   bool read ()
	   {
		    buf[0]=_gpio;
		   interface.callMethod(0,DigitalOut_Read,buf,1);
		    interface.waitResult(buf);
		   return _value;
	   }
	 char  flipflops()
	  {    cout<<"Send Flipflop"<< endl;
		   buf[0]=_gpio;
		   interface.callMethod(0,DigitalOut_Filpflop,buf,1);		   
		   interface.waitResult(buf);
		   cout <<"result:0x"<< std::setfill('0') << std::setw(2);
		   cout<<hex<<(unsigned int)buf[0]<<endl;
		  _value=!_value;
		  return buf[0];
	  }
};
int main()
{
 DigitalOut LED(1);
 cout<<"serialRPC Test"<<endl;
  interface.init("/dev/ttyS36");
  while (true)
  {
	 LED.flipflops();
	
	   sleep(1);
  }
}

实现 LED 闪烁，也可以写成：

  

bool val;

  val=!LED.read();
   LED.write(val);

但是交互的数据多了一点。所以我设计了一个Flipflop。

 

姚家湾
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux prc 时区,授时时区问题解决
weixin_42425334的博客
05-14 1371
授时时区问题解决Zone is 'EST',zone number=18000PRC：Zone is 'CST',zone number=4294938496TaiWan：Zone is 'CST',zone number=4294938496提示1標準時區經度時差GMT , Greenwich Mean Time0 W/E標準時間CET , Central European15 E+1 ...
RPC（远程过程调用）基于单片机的极简实现
Ranchaun的博客
05-13 2081
目录一、定义二、应用场景三、验证1、实验条件2、制定协议1）数据传输协议2）函数调用协议3、传输层4、RPC协议解析程序1）从机端程序2）主机端程序5、编写RPC函数1）从机端函数编写2）主机端函数编写6、RPC函数调用示例四、现象 一、定义 RPC（Remote Procedure Call）远程过程调用。假设一个系统中有两个cpu，暂且称为A和B，分别运行着自己的应用程序，当A执行到某功能时需要B配合才能完成，这在程序里就体现为A需要调用B中的方法。RPC就是实现这种CPU间方法调用的协议。 二、应用场
erpc(EmbeddedRPC)入门笔记
10km的专栏
04-18 6621
RPC 最近在忙一个IOT设备的项目，想设计一个通信系统通过串口控制设备(freertos)的运行。按照传统的设计思路，先要定义一套串口通信协议，在这套协议中传输层协议、应用层协议一个都不能少。每一层协议都要自己实现。数据编码/解码，数据校验，容错，这些非常基础的东西都要自己实现。 等这些协议都实现了，才是能开始设计真正的业务逻辑。 和同事商议后，一致认为要是照这么干，黄花菜都凉了。我们的生命不能...
【代码分享】写一个RPC批量调用支持（支持串行和并行模式）
weixin_34411563的博客
08-26 432
      我在做项目过程中遇到这方面的问题，于是自己封装了一个组件来解决RPC的批量调用问题（需要获取每个RPC的返回结果），批量中的量最好也别太大，否则不是等待时间很长就是耗费很多线程。       问题描述：对外需要提供一个异步RPC接口，但是对方要求是可以批量查询某些数据，内部也有类似的异步RPC接口，但是是单条查询。我这里需要做一个转换，需要将批量的拆分路由给单条的。而且类似这种需求的...
NFS服务
m0_49569199的博客
10-18 682
NFS服务简介 什么是NFS？ NFS就是Network File System的缩写，它最大的功能就是可以通过网络，让不同的机器、不同的操作系统可以共享彼此的文件。 NFS服务器可以让PC将网络中的NFS服务器共享的目录挂载到本地端的文件系统中，而在本地端的系统中来看，那个远程主机的目录就好像是自己的一个磁盘分区一样，在使用上相当便利； NFS一般用来存储共享视频，图片等静态数据。 NFS挂载原理： 如上图示： 当我们在NFS服务器设置好一个共享目录/home/public后，其他的有权访问NFS服务器的
linux prc进程,linux内核中RPC任务调度
weixin_42516967的博客
04-29 333
为了高效的调度各个RPC请求，Linux的PRC调度实际上是一个事件驱动模型。C/S结构，大多使用多进程服务模型，这种模型的优点是编程简单，因为操作系统都是基于进程调度的，可以直接使用操作系统的接口。缺点是不适用于大规模的服务。服务进程或者线程的数目越多，用于切换调度的开销就越多，一旦进程或者线程的个数超过一定值，系统就会变的响应异常缓慢。而事件驱动模型正好相反，由于缺乏通用的事件调度接口，只有全...
RPC协议
vanturman的博客
08-14 1010
rpc是远程程序调用，调用协议通常包含 1）传输协议 和 2）编码协议 传输协议（用于数据传输）：grpc使用HTTP2协议，dubbo使用自定义报文的TCP协议，还有 MQ 编码协议（用于数据序列化）：基于文本编码的xml、json，基于二进制编码protobuf等 feature1： 通用定义的 http1.1 协议的 tcp 报文中有效编码占比比较少，一个 POST 协议的格式大...
prc.gz_PRC
09-19
Palm OS是历史上著名的掌上电脑操作系统，广泛应用于早期的PDA（个人数字助手）和一些智能手机。Palm开发涉及创建和管理资源文件，这些文件是构成Palm应用程序的基础组件。 标题中的"prc.gz_PRC"暗示了我们正在处理...
JAVA - PRC automate compilation (Linux)-开源
04-24
这个名为"JAVA - PRC automate compilation (Linux)"的项目是专为Linux用户设计的，旨在利用开源工具简化PDA（个人数字助手）和Palm设备上的Java应用程序的编译流程，生成PRC文件。PRC文件是Palm OS设备上运行的应用...
/usr/share/zoneinfo/PRC
08-17
/usr/share/zoneinfo/PRC
串口通信是MCU跟PC通信经常用到的一种通信方式
07-23
串口通信是MCU跟PC通信经常用到的一种通信方式
工具查询PRC公交网IP查询系统PHP版 v1.0-prc-chaip.rar
最新发布
04-08
对于有一定基础或热衷于研究的人来说，可以在这些基础代码上进行修改和扩展，实现其他功能。【沟通交流】：有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。鼓励下载和使用，并欢迎大家互相学习，共同进步...
RPC接口实现
lannister_awalys_pay的博客
04-16 1733
1.RPC作用 以目前的认识，RPC的作用：多个工程之间数据传输。 2.逐步完成RPC接口实现 第一步： 编写thrift文件，语法格式和java不同。 在布局分层里安排在了client层
网络编程中的协议格式
lzjsqn的专栏
12-12 1131
数据包封装 传输层及其以下的机制由内核提供，应用层由用户进程提供（后面将介绍如何使用socket API编写应用程序），应用程序对通讯数据的含义进行解释，而传输层及其以下处理通讯的细节，将数据从一台计算机通过一定的路径发送到另一台计算机。应用层数据通过协议栈发到网络上时，每层协议都要加上一个数据首部（header），称为封装（Encapsulation），如下图所示：
java prc 协议_Java RPC协议设计
weixin_36302331的博客
02-24 150
调用流程motan的协议设计包括 request 级别的 header 和 body，request 的 body 中又包含了 header 和 body; 其中 requestId, request/response 的标记是冗余的dubbo的协议设计Server参数的优化bootstrap.option(ChannelOption.SO_BACKLOG, 128); // 3次握手连接队列bo...
PRC接口
jingshajava的博客
08-03 1263
一.RPC接口： RPC（Remote Procedure Call Protocol）远程过程调用协议。一个通俗的描述是：客户端在不知道调用细节的情况下，调用存在于远程计算机上的某个对象，就像调用本地应用程序中的对象一样。比较正式的描述是：一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。 优点： 1. 传输效率高(二进制传输) 2. 发起调用的一方无需知道RPC的具体实现，如同调用本地函数般调用 缺点： 1. 通用性不如HTTP好(HTTP是标准协议) 总结：RPC适合...
什么是RPC协议
12-11 963
英文原义：Remote Procedure Call Protocol中文释义：（RFC-1831）远过程调用协议        注解：一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间 携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程
JSON-RPC笔记
qq_45445740的博客
01-22 1080
json-rpc是一种非常轻量级的跨语言远程调用协议，使用简单，仅需几十行代码，即可实现一个远程调用的客户端，方便语言扩展客户端的实现。
我是这样学习Linux下C语言编程的-利用RPC快速实现分布式系统
10-27 1479
我是这样学习Linux下C语言编程的-利用RPC快速实现分布式系统 一、概述 在传统的编程概念中，过程是由程序员在本地编译完成，并只能局限在本地运行的一段代码，也即其主程序和过程之间的运行关系是本地调用关系。因此这种结构在网络日益发展的今天已无法适应实际需求。总而言之，传统过
TCP/IP协议、prc协议、
05-17
TCP/IP协议是一种网络协议，它是互联网的基础协议之一。它是一个分层协议，包括应用层、传输层、网络层和链路层四个部分。TCP/IP协议定义了网络中计算机之间通信的规则和格式，使得不同类型的计算机可以互相通信。 RPC协议（Remote Procedure Call Protocol）是一种远程过程调用协议，它可以使得一个计算机上的程序可以调用另一个计算机上的程序，就像调用本地程序一样。RPC协议定义了一套标准的远程过程调用机制，包括编码格式、消息传递等规则，在不同平台之间可以实现跨语言、跨平台的远程过程调用。RPC协议常用于分布式系统中，用于实现分布式计算和分布式服务。 需要注意的是，TCP/IP协议和RPC协议是不同的协议，它们解决的问题和应用场景也不同。TCP/IP协议用于定义网络中计算机之间的通信规则和格式，而RPC协议用于实现分布式系统中的远程过程调用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值