（STC15）Modbus-RTU 下位機編程

Modbus-RTU下位機的實作主要包括以下幾個部分：

• 串口資料收發
• 接收幀超時處理
• 請求命令決議
• 回應幀資料組裝
• 用戶協議資料點表

1、串口發送-回圈緩沖區

先從最簡單的串口發送資料開始，常見的串口發送程式如下：

void Uart_Send_Byte(uint8_t dat)
{
	SBUF = dat;
	while(!TI);
	TI = 0;
}

這個串口發送的代碼很簡單，但缺點也很明顯，發送資料太多，波特率較低時，等待時間太長，會影響主程式其他任務的回應，

需要優化一下發送模式，設定一個發送緩沖區，發送的資料放在緩沖區，每次需要發送時啟動發送即可，主程式就可以繼續執行其他任務，不必低效的死等了，主程式只啟動發送，后續的位元組由誰來發送？答案是中斷，

關鍵在于怎么啟動發送，這里要用到中斷的一個特性，在打開串口中斷的前提下，發送完了一個位元組，MCU會觸發進入中斷，即TI = 1，這個進入中斷的方式是異步的，而啟動是主程式“通知”串口中斷要開始發送資料了，這是同步的操作，那么就需要主程式主動置位TI，即賦值 TI = 1，主動觸發進入中斷，進行第一個位元組的發送，然后第二個位元組在第一個位元組發送完進入中斷后再開始發送，后續以此類推……

程式如下：

//485模式切換有關的宏
sbit UART1_485_DE_nRE = P2^0;	
#define SEND_MODE (bit)1
#define RECV_MODE (bit)0
#define UART1_485_SEND_MODE() {UART1_485_DE_nRE = SEND_MODE;}
#define UART1_485_RECV_MODE() {UART1_485_DE_nRE = RECV_MODE;}

//發送緩沖區資料定義
#define TX_MAX_SIZE 64
uint8_t UART1_TX_Buffer[TX_MAX_SIZE];	//發送緩沖區-回圈緩沖區
uint8_t TX_Start = 0;	//啟動發送標志
uint8_t TX_Write = 0;	//發送寫緩沖索引
uint8_t TX_Read = 0;	//中斷讀緩沖索引

//發送位元組函式
void Uart_Send_Byte(uint8_t dat)
{
	//寫緩沖太快，發送太慢，寫溢位，寫索引回圈了一圈追上了讀索引，就等待一會，防止資料覆寫，或者直接加大緩沖區
	while(TX_Write < TX_Read);	
	
	UART1_485_SEND_MODE();	//初始化是接收模式,每次發送切換為發送模式
	
	UART1_TX_Buffer[TX_Write++] = dat;
	if(TX_Write >= TX_MAX_SIZE)
		TX_Write = 0;
	
	if(TX_Start == 0){	//啟動發送
		TX_Start = 1;
		TI = 1;			//主動觸發進入中斷
	}
}
//串口1中斷服務程式
void Uart1_Isr(void) interrupt Vector_Uart1
{
	if(TI){
		TI = 0;
		if(TX_Read != TX_Write){
			SBUF = UART1_TX_Buffer[TX_Read++];
			if(TX_Read >= TX_MAX_SIZE)
				TX_Read = 0;
		} else {
			TX_Start = 0;	//最后一個位元組發送完了，清標志
			UART1_485_RECV_MODE();	//本次發送完切換為接收模式
		}
	}
	if(RI){
		RI = 0;
	}
}

//重定向putchar，就可以使用printf了
//最好把STDIO.H的putchar注釋掉
char putchar(char c)
{
	Uart_Send_Byte(c);
	return c;
}

//發送字串，用printf就足夠了，這個用處不大
void Uart_Send_String(uint8_t const* str)
{
	while(*str)
		Uart_Send_Byte(*str++);
}

//發送位元組流
void Uart_Send_Stream(uint8_t const* src, uint16_t len)
{
	while(len--)
		Uart_Send_Byte(*src++);
}

2、串口接收-RTU幀超時界定

由于Modbus RTU模式沒有固定的幀開始和結束符，只能以T1.5和T3.5的字符時間來鑒別兩個不同的幀，實際傳輸中，不用太在意T1.5這個時間，參考關于MODBUS RTU的T3.5 、T1.5的時序問題，因為連續的兩個位元組之間是停止位和起始位，位元組和位元組是緊密連接在一起的，

除非上位機發送期間轉到其他延時比較厲害的行程，再回來接著發送時，超過了T1.5字符時間，但是卻不到T3.5字符時間，按照Modbus RTU的定義，新的資料被認為是下一幀，之前的資料要丟棄處理，而新的一幀CRC校驗必定不通過，仍然無法進行正常的通信，這樣的上位機從設計之初就是有問題的，

因此只考慮T3.5的字符時間來界定不同幀，同時對上述的情況也有一定的包容性，（實際的上位機連續兩幀的間隔通常是遠遠大于T3.5的）

一般用定時器進行幀超時的判斷，具體來說分為兩種：

• 固定超時時間：
  例如對于波特率>19200bps時，應該使用2個定時的固定值，建議字符間的超時時間t1.5為750us；幀間超時時間為1.75ms
• 隨波特率變化的超時時間：
  即嚴格意義上的1.5個或3.5個字符時間，例如9600波特率，8資料位，1校驗位，1停止位，1BYTE傳輸用時約1.14ms，T1.5為1.7ms，T3.5為4ms，

1. 固定的超時時間

初始化定時器即可簡單實作，基本流程是：

1. 初始化定時器并開中斷，先不運行定時器
2. 串口接收完一幀資料的第一個位元組，通知定時器運行開始計時，并每次接收到資料時重裝載定時值，幀結束之前不會觸發中斷
3. 一旦進入定時器中斷，說明幀超時時間到了，認為一幀接收完成，然后關閉定時器，通知主程式處理資料，

這種方式的優缺點：

• 優點：定時器只需要在一幀結束后觸發一次中斷，額外引入的中斷時間短
• 缺點：需要占用一個定時器硬體資源，波特率變化時，多載值需要重新計算

程式略，

2. 隨波特率變化的超時時間

一般串口的可變波特率是由定時器溢位產生的（MSC-51架構），波特率 = 定時器溢位率 / 4

這個用于波特率發生器的定時器，一般用不到它的中斷，這里剛好可以利用起來，

串口的波特率設定好后，意味著使用的定時器也對應的設定好了，定時時間為1/4bit傳輸的用時，顯然只需使用一個計數器，在傳輸程序中打開定時器中斷，即可精確的判斷任意長度的字符超時時間，

以任意波特率，8資料位，1校驗位，1停止位為例，超時計數器用Timeout表示則：

T1.5時，Timeout>= 4 * 11 * 1.5 + 4 = 70
T3.5 時，Timeout>= 4 * 11 * 3.5 + 4 = 158

（加4是因為，MSC-51的串口收發時，第8bit資料位收/發完就會觸發中斷，而不是在停止位發送完后觸發中斷，實際使用時可以再多增加一點冗余）

則程式流程跟之前類似：

1. 初始化波特率發生器定時器，先關閉定時器中斷
2. 串口接收完一幀資料的第一個位元組，打開定時器中斷，并在每次接收到資料時清0超時計數器Timeout
3. 每次定時器中斷里Timeout++，并判斷 Timeout >= T3.5，當沒有新接收資料清零Timeout時，條件成立，說明幀超時時間到了，認為一幀接收完成，然后關閉定時器中斷，通知主程式處理資料，

這種方式的優缺點：

• 優點：波特率自適應，不需要計算波特率變化時不同的超時時間，不需要占用額外的定時器硬體資源
• 缺點：中斷太頻繁，會降低CPU效率，使用時中斷程式需優化，代碼越少越好，盡可能降低中斷時間，最好用于波特率較低的情況，

下面給出基于隨波特率變化的超時幀界定程式，實測使用STC15L2，11.0592MHz，波特率<=38400時通信完全沒問題，更高的波特率沒有測驗了，因為實際的modbus組網傳輸通常是長距離多機通信，也不可能用太高的波特率，

程式：

//定時器中斷和串口接收允許有關的宏
#define TIMER1_INT_ENABLE() {ET1 = 1;}
#define TIMER1_INT_DISABLE() {ET1 = 0;}
#define UART1_RECV_ENABLE() {REN = 1;}
#define UART1_RECV_DISABLE() {REN = 0;}

//超時時間定義
#define RECV_TIMEOUT_1_5  	70			//T1.5
#define RECV_TIMEOUT_3_5	158			//T3.5
#define RECV_TIMEOUT_1_Sec  (BAUD * 4)	//4倍波特率時間，約1秒，用于測驗，
										//例如9600波特率，超時1秒為38400，Timeout的資料型別也需要相應改為uint16_t

//接識訓沖區資料定義
#define RX_MAX_LEN 100
uint8_t Uart1_RX_Buffer[RX_MAX_LEN];	//接識訓沖區
uint8_t Recv_Cnt = 0;		//接收位元組個數，也是接識訓沖區索引
uint8_t Timeout = 0;		//超時計數器
uint8_t Recv_OK = 0;		//一幀接收完成標志
uint8_t Unitaddr = 1;		//本機地址

//串口1中斷服務程式里，補全接收部分
if(RI){
	RI = 0;
	//非本機地址資料不接收，總線上其他設備的通信資料不處理
	//廣播地址暫時不實作
	if(Recv_Cnt == 0 || *Uart1_RX_Buffer == Unitaddr){
		Uart1_RX_Buffer[Recv_Cnt++] = SBUF;
		if(Recv_Cnt >= RX_MAX_LEN)
			Recv_Cnt = 0;
		
		if(Recv_Cnt == 1)	//一幀的首位元組打開定時器中斷
			TIMER1_INT_ENABLE();
	}
	Timeout = 0;		//每次接收到資料，重新進行超時判斷
}

//定時器1中斷服務
void Timer1_Isr(void) interrupt Vector_Timer1 using 2
{
    if(++Timeout > RECV_TIMEOUT_T3_5){
    
        if(Recv_Cnt >= 8){  //常用標準請求幀最少8位元組
        
            Recv_OK  = 1;     //主程式處理接收資料
            UART1_RECV_DISABLE();   //先關閉接收
            
        }else Recv_Cnt = 0;	//否則丟棄該幀

        TIMER1_INT_DISABLE(); //超時關閉定時器中斷
    }
}

//modbus請求命令接收服務，運行于main主回圈中
void Modbus_Recv_Ser()
{
	if(Recv_OK){
		Recv_OK = 0;
		//……
		//CRC16校驗
		//modbus回應服務
		
		Recv_Cnt = 0;		//最后索引清零
		UART1_RECV_ENABLE();//應答完后才允許再次接收-半雙工
	}
}

至此，Modbus-RTU通信與硬體有關的底層驅動基本完成了，還需要增加部分GPIO和串口的初始化即可，

應用層的實作因人而異，下面的程式可以作為參考，

3、請求命令決議服務程式

//回應資料緩沖區，rsp_pdu在這里組裝
#define SEND_MAX_SIZE 200
uint8_t mb_rsp_buff[SEND_MAX_LEN];

//常用功能碼宏定義
#define READ_COIL          0x01   //讀線圈狀態       DO 例如繼電器、LED
#define READ_INPUT_COIL    0x02   //讀輸入線圈狀態   DI 例如外部開關狀態
#define READ_HOLD_REG      0x03   //讀保持暫存器值   AO 例如溫濕度設定值
#define READ_INPUT_REG     0x04   //讀輸入暫存器值   AI 例如4-20mA輸入 溫度測量值
#define WRITE_COIL         0x05   //寫單個線圈狀態   DO
#define WRITE_HOLD_REG     0x06   //寫單個保持暫存器 AO 
#define WRITE_MULTI_COIL   0x0F   //寫多個線圈狀態   DO
#define WRITE_MULTI_REG    0x10   //寫多個保持暫存器 AO

//錯誤碼宏定義
#define RECV_NO_ERROR      0x00   
#define ILLEGAL_FUNCTION   0x01   //非法的功能碼
#define ILLEGAL_DATA_ADDR  0x02   //非法起始地址 ADRR超界
#define ILLEGAL_DATA_LEN   0x03   //非法資料長度 ADDR+LEN超界
#define ILLEGAL_DATA_VALUE 0x03   //或寫入非法資料值 如溫度設定值超界
#define DEVICE_FAILURE     0x04   //設備服務故障


//補全之前的接收請求命令服務
//為了方便了解思路，按照倒敘貼出示例代碼

//Modbus接收資料處理服務
void Modbus_Recv_Ser()
{
	uint8_t crc[2];
	if(Recv_OK){
		Recv_OK = 0;
		
		CRC16(Uart1_RX_Buffer, Recv_Cnt, crc);
		if(memcmp(Uart1_RX_Buffer+Recv_Cnt-2, crc, 2)==0)
			//到了這里，必定是首位元組是從機地址且校驗通過
			Modbus_Resp_Ser(Uart1_RX_Buffer, Recv_Cnt, mb_rsp_buff);
			
		Recv_Cnt = 0;		//最后索引清零
		UART1_RECV_ENABLE();//應答完后才允許再次接收-半雙工
							//執行到這里回應幀還沒有發送完，但是不影響，此時485還是發送模式，上位機也處于監聽狀態
	}
}
//modbus回應服務
//鏈路層資料服務
//負責回應幀頭，幀尾校驗資料組裝，錯誤處理和發送資料
//收發緩沖區用引數傳遞，應用層和鏈路層分離
void Modbus_Resp_Ser(uint8_t *recv_buff, uint8_t recv_cnt, uint8_t *send_buff)
{
	uint8_t send_cnt;
    uint8_t err=RECV_NO_ERROR;
    
    memcpy(send_buff, recv_buff, 2);    //modbus addr + func code
    
    rsp_cnt = Modbus_Req_Func_Match(recv_buff+1, recv_cnt, send_buff+2,&err);
    
   if(rsp_cnt == 0)           //幀長度錯誤時，rsp_cnt為0，不處理
        return;

    if (err != RECV_NO_ERROR){
        send_buff[1] += 0x80;
        send_buff[2] = err;
        rsp_cnt = 3;
    }
    else rsp_cnt += 2;         //回傳pdu長度不包含地址和功能碼
    
    CRC16(send_buff, send_cnt, send_buff+send_cnt);
    Uart_Send_Stream(send_buff, send_cnt+2);
}

//Modbus命令請求功能碼匹配
/**
  *	  正常情況下回傳回應幀全部payload的位元組數，不包括幀頭的modbus地址，功能碼，和幀尾CRC校驗個數
  *   請求幀長度錯誤時，回傳0
  *   非法的請求地址、長度或資料值時和設備服務故障時，err不為0，回傳-1
 */
uint8_t Modbus_Req_Func_Match(uint8_t *recv_pdu, uint8_t recv_cnt, uint8_t *send_pdu, uint8_t *err)
{
    uint8_t rsp_cnt;
    uint8_t func_code;
    
    func_code = *recv_pdu++;

    switch(func_code){
        case READ_COIL://01、02功能碼使用時不作區分
        case READ_INPUT_COIL:*err = ILLEGAL_FUNCTION;break;  //不支持的功能碼先回傳01錯誤碼
        case READ_HOLD_REG://03、04功能碼使用時不作區分
        case READ_INPUT_REG:rsp_cnt=Read_Mb_Reg_Rsp(recv_pdu, recv_cnt, send_pdu, err);break;
        case WRITE_COIL:
        case WRITE_HOLD_REG:
        case WRITE_MULTI_COIL:
        case WRITE_MULTI_REG:
        default:*err = ILLEGAL_FUNCTION;break;              //不支持的功能碼先回傳01錯誤碼
    }
    return rsp_cnt;
}

3、回應幀資料組裝

例如現在用AD采集8路溫度值，AD轉換結果存放在一個陣列中，那么回應資料的組裝就很簡單了，一個for回圈搞定：

uint16_t ADC_Res[8]={	//模擬資料
	0x1111,
	0x2222,
	0x3333,
	0x4444,
	0x5555,
	0x6666,
	0x7777,
	0x8888
};
//功能碼0x04
uint8_t Read_Input_Reg_Rsp(uint8_t *req_pdu, uint8_t recv_cnt, uint8_t *send_pdu, uint8_t *err)
{
	uint16_t i,req_addr,req_len,pdu_len;
    uint16_t *pdu_ptr;
    
	if(recv_cnt != 8)           //功能碼03、04的請求長度只能為8byte
        return 0;
        
	pdu_ptr = (uint16_t *)req_pdu;
	req_addr = *pdu_ptr++;
	req_len  = *pdu_ptr;
	
    //data_addr -= INPUT_REG_OFFSET; //全域地址點表是1001，轉換為0

    if(data_addr > sizeof(ADC_Res)/sizeof(uint16_t)){	//請求地址限制
        *err = ILLEGAL_DATA_ADDR;
        return -1;
    }
    
    if(data_addr+data_len>sizeof(ADC_Res)/sizeof(uint16_t) ||
        data_len > (SEND_MAX_LEN-5)/2){	 //請求長度限制
        *err = ILLEGAL_DATA_LEN;
        return -1;
    }
    
	*send_pdu++ = pdu_len = 2 * req_len;
	pdu_ptr = (uint16_t *)send_pdu;
	
    for(i=req_addr; i<req_addr +req_len; i++)
    	*pdu_ptr++ = ADC_Res[i];
    return pdu_len+1;
}

有時modbus點表資料來源于多個不同模塊，比如溫度，電壓等，就需要把分散的資料點組織起來，也可以用一個指標陣列管理（需要額外的記憶體開銷），例如：

uint16_t *Modbus_Reg_Table[N]={
	&ADC_Result,
	   ……
};

上面的兩種方式，陣列和指標陣列，對于modbus點表資料比較少的情況，或者具有相同型別，有序的，有規律的資料，可以高效的組織和遍歷資料，

但是這種方式也有一定的局限性，modbus請求的地址必須是連續的，一般從0開始，最多加個偏移，當分散的資料點比較多時，不太方便后期維護和擴展，例如現在要增加一個特殊的擴展需求，在原有的陣列資料基礎上，要把10000開始的一段地址定義為modbus從機地址，差錯資訊統計等，20000開始的一段地址又用來定義其他的資料，等等，就很不方便了，

實際的工程往往是多個模塊協調作業的，modbus點表的資料來源于其他模塊，即使在工程一開始就預先決定好哪些資料需要作為modbus點表，但是隨著工程的推進，總是需要維護或增加新的點表，不同的模塊資料型別也不盡相同，常見的有bit，uint8_t，uint16_t，uint32_t，float等，這時modbus點表的設計，就是一件很棘手的事情，

很容易想到，可以定義一個結構體作為modbus點表，來容納所有的資料，但是這樣做有兩個問題，首先是記憶體的額外開銷，通常各個模塊已經有預先定義好的資料，為何不直接拿來用，其次，資料的更新，必須添加到各個模塊的內部，這是很麻煩的，另外，有些資料可能是通過介面函式獲得，不僅需要存盤空間來接受回傳值，還需要動態的運行一段程式，

考慮到modbus點表的維護和擴展方便，以及不同型別的資料和modbus請求地址的靈活性，把資料結構變成程序，即函式，用戶應用程式只需要與modbus點表的函式互動即可，這里參考了51單片機的MODBUS，

//讀單個暫存器值，功能碼0x03、0x04
uint8_t Read_Mb_Reg_Rsp(uint8_t *req_pdu, uint8_t recv_cnt, uint8_t *send_pdu, uint8_t *err)
{
    uint16_t req_addr,req_len,pdu_len;
    uint16_t *pdu_ptr;
	
    if(recv_cnt != 8)           //功能碼03、04的請求長度只能為8byte
        return 0;

	pdu_ptr = (uint16_t *)req_pdu;
	req_addr = *pdu_ptr++;
	req_len  = *pdu_ptr;
	
	if(req_len == 0 || req_len > 125    //標準請求幀讀出的總長度
    || req_len > (SEND_MAX_LEN-5)/2){	//本地發送限制
		*err = ILLEGAL_DATA_LEN;
		return -1;
	}

	*send_pdu++ = pdu_len = 2 * req_len;
	pdu_ptr = (uint16_t *)send_pdu;
	while(req_len--){
		*pdu_ptr++ = Read_Modbus_Reg(req_addr++, err);
		if(*err != RECV_NO_ERROR)
			return -1;
	}
    return pdu_len+1;
}

//讀modbus暫存器點表,功能碼0x03，0x04呼叫
uint16_t Read_Modbus_Reg(uint16_t req_addr, uint8_t *err)
{
	uint16_t reg = 0xFFFF;   //預留的modbus地址，給個特定回傳值以示區別，也可以為0
	
	switch(req_addr){
        case 0:reg=Get_PWM_LED_Brightness();break;              //API 
        case 1:reg=PWM.Duty;break;	                //uint8_t
		case 2:reg=ADC.ADC_Value;break;					        //uint16_t
		case 3:reg=*(uint16_t*)&NTC.NTC_Temperature;break;  	//float
		case 4:reg=*((uint16_t*)&NTC.NTC_Temperature+1);break;		   
        case 5:break;
        case 6:reg=*(uint16_t*)&NTC.NTC_Voltage;break;
        case 7:reg=*((uint16_t*)&NTC.NTC_Voltage+1);break;
        case 8:break;                                           //預留
        case 9:break;                                           
        case 10:break;                                           
		case 1001:reg=Modbus.uintaddr;break;                    //modbus從機地址
        
        case 1002:*err = DEVICE_FAILURE;break;                  //模擬讀暫存器失敗,錯誤碼04
		default:*err=ILLEGAL_DATA_ADDR;break;                   //非法地址
	}
	return reg;
}

//獲取PWM LED燈亮度 回傳值范圍:0~100 單位:%
uint8_t Get_PWM_LED_Brightness()
{
    return PWM.LED_Brightness;
}

這樣我們就有了自己的Modbus對外點表（簡易版）：

再封裝一下代碼，使用同樣的方式，撰寫其他功能碼即可完成基本的modbus下位機框架，
這樣就可以任意的擴展其他應用程式的資料到modbus點表了，
程式略，