modbus.c

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

//#include <avr/wdt.h>





#define SYNC 0x40

#define PARITY_EVEN 0x20

#define PARITY_ODD 0x30

#define STOP_2 0x04

#define DATA_5 0x00

#define DATA_6 0x02

#define DATA_7 0x04

#define DATA_8 0x06 //最高位置1，UMSELn设为0工作于异步模式

#define DATA_9 0x0c



#define FRAMING_ERROR (1<<FE)

#define PARITY_ERROR (1<<UPE)

#define DATA_OVERRUN (1<<DOR)

#define DATA_REGISTER_EMPTY (1<<UDRE)

#define RX_COMPLETE (1<<RXC)



#define SYSTEM_CLOCK 16000000L

#define BAUD_RATE 38400L//57600L测试通过



#define UART_RX_BUFFER_SIZE 1024

#define UART_RX_BUFFER_MASK (UART_RX_BUFFER_SIZE-1)

#if (UART_RX_BUFFER_SIZE & UART_RX_BUFFER_MASK)

#error RX buffer size is not a power of 2

#endif



#define UART_TX_BUFFER_SIZE 512

#define UART_TX_BUFFER_MASK (UART_TX_BUFFER_SIZE-1)//UART_RX_BUFFER_SIZE 128

#if (UART_TX_BUFFER_SIZE & UART_TX_BUFFER_MASK)

#error TX buffer size is not a power of 2

#endif



volatile static unsigned char UART_RxBuf[UART_RX_BUFFER_SIZE];//UART_RX_BUFFER_SIZE 128

volatile static unsigned char UART_RxHead;

volatile static unsigned char UART_RxTail;



volatile static unsigned char UART_TxBuf[UART_TX_BUFFER_SIZE];//UART_TX_BUFFER_SIZE 128

volatile static unsigned char UART_TxHead;

volatile static unsigned char UART_TxTail;



//volatile static 

unsigned char UART0_RxBuf[UART_RX_BUFFER_SIZE];//UART_RX_BUFFER_SIZE 128

volatile static unsigned char UART0_RxHead;

volatile static unsigned char UART0_RxTail;



volatile static unsigned int UART0_TxBuf[UART_TX_BUFFER_SIZE];//UART_TX_BUFFER_SIZE 128

volatile static unsigned char UART0_TxHead;

volatile static unsigned char UART0_TxTail;



//volatile static 

unsigned char UART1_RxBuf[UART_RX_BUFFER_SIZE];//UART_RX_BUFFER_SIZE 128

volatile static unsigned char UART1_RxHead;

volatile static unsigned char UART1_RxTail;



volatile static unsigned char UART1_TxBuf[UART_TX_BUFFER_SIZE];//UART_TX_BUFFER_SIZE 128

volatile static unsigned char UART1_TxHead;

volatile static unsigned char UART1_TxTail;



void Initialize(void);

void Serial_Initialize_UART0(unsigned long int baud);

void Serial_Initialize_UART1(unsigned long int baud);

void Timer0_Initialize(void);

void Timer3_Initialize(void);

unsigned char UART0_ReceiveByte(void);

void UART0_TransmitByte(unsigned char data);

unsigned char UART1_ReceiveByte(void);

void UART1_TransmitByte(unsigned char data);

void UART0_TransmitC(unsigned char c);

void UART0_TransmitString(unsigned char *ptr);

void UART1_TransmitC(unsigned char c);

void UART1_TransmitString(unsigned char *ptr);

void SendDataUp();

void SendDataDown(void);

extern unsigned char ReadTime(void);



unsigned char strCat(unsigned char *s1,unsigned char *s2);





void Initialize(void)

{

     //MCUCR=0x00;//PORTA,PORTC作普通口使用

	 Serial_Initialize_UART0(BAUD_RATE);

	 Serial_Initialize_UART1(BAUD_RATE);

	 //Timer0_Initialize();

	 Timer3_Initialize();

	 sei();	



}





void Serial_Initialize_UART0(unsigned long int baud)

{

	 unsigned short int ubrr0;

	 ubrr0=((SYSTEM_CLOCK/(16L*baud))-1);

	 UBRR0H=(unsigned char)(ubrr0>>8);//设置USART0波特率

	 UBRR0L=(unsigned char)ubrr0;

	 //UCSR0B=((1<<TXCIE0)|(1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0));//USART0接收结束中断使能，接收器发送器使能

	 UCSR0B=((1<<RXEN0)|(1<<TXEN0));	//初始化时先先进入定时中断，屏蔽接收发送中断，

	 UCSR0C=DATA_8; //异步，无奇偶校验，1位停止位，8数据位

	 

	 UART0_RxTail=0;

	 UART0_RxHead=0;

	 UART0_TxTail=0;

	 UART0_TxHead=0;

}





void Serial_Initialize_UART1(unsigned long int baud)

{

	 unsigned short int ubrr1;

	 ubrr1=((SYSTEM_CLOCK/(16L*baud))-1);

	 UBRR1H=(unsigned char)(ubrr1>>8);//设置USART1波特率

	 UBRR1L=(unsigned char)ubrr1;

	 //UCSR1B=((1<<TXCIE1)|(1<<RXCIE1)|(1<<RXEN1)|(1<<TXEN1));//USART1接收结束中断使能，接收器发送器使能

	 UCSR1B=((1<<RXEN1)|(1<<TXEN1));//初始化时先不打开接收发送中断

	 UCSR1C=DATA_8; //异步，无奇偶校验，1位停止位，8数据位

	 

	 UART1_RxTail=0;

	 UART1_RxHead=0;

	 UART1_TxTail=0;

	 UART1_TxHead=0;

}





void Timer0_Initialize(void)

{

	cli();

	TCNT0=0x63;//((0xff-0x63)+1)*1024*(1/16M)=10ms

	TCCR0=0x07;//定时器0 预分频比1024

	TIMSK=0x01;//开定时器0中断



}





void Timer3_Initialize(void)

{

	TCCR3B = 0x00;  //stop timer 



	//0.1s  0xffff+1-(16M/1024)*0.1=63973.5--0xf9e5

	//0.2s--0xf3cb

	//0.3s--0xEDB0



	//TCNT3H=0xff;

	//TCNT3L=0x64;

	//TCCR3B=0x05;//1024预分频



	TCNT3H=0xf3;

	TCNT3L=0xcb;

	TCCR3B=0x04;//256预分频



	ETIMSK|= (1 << TOIE3);//定时器3溢出中断



}





//由于单片机要实现和DTU与modbus模块的同时通讯，采用双串口CPU，

//串口0中断处理与DTU的数据通讯，串口1中断处理与modbus数据采集模块的通讯，

//串口0中断设置为高优先级中断，每接收到或发送完一个字节都进入中断处理，处理完毕立即退出中断

//通讯波特率都为38400 b/s，一个起始位,一个停止位。







//时间冲突问题，硬件接受或发送一个字节的时间为1 ms左右，而软件接受或发送一个字节的时间仅几μs。

//同时通讯实际上是将CPU时间分成很小的时间片，假设较快的串口发送或接受一个字节的最长时间为TRbyteMax，则CPU最长时间片一般应小于TRbyteMax/2，当然在接受或发送完一帧数据之后的间隙，CPU时间片可以适当延长，作一些必要的数据处理。





 //数据冲突问题，2个串口通讯分别使用各自的接受发送数据缓冲区和控制变量，

 //以减少中断保护数据量和防止数据冲突。

 //当主程序、串口2中断处理程序和其他中断处理程序往存储器中写数据时，

 //需在尽量短的时间内关闭串口1中断，关闭中断时间应小于几百μs，

 //防止其他程序数据没有写完之前串口1读此数据。





//UART0接收完成中断

SIGNAL(SIG_UART0_RECV)

{

     unsigned char data;

	 unsigned char tmphead;

	 

	 data=UDR0;//read the received data

	 //calculate buffer index

	 tmphead=(UART0_RxHead+1)&UART_RX_BUFFER_MASK;//UART_RX_BUFFER_MASK 127

	 UART0_RxHead=tmphead;//store new index

	 

     if(tmphead==UART0_RxTail)

	 	 {

		 	//ERROR! Receive buffer overflow

	     }

	 UART0_RxBuf[tmphead]=data; //store received data in buffer

	 //if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)

}





void UART0_ReceiveData(void)

{  

	 unsigned char UART0_RxBuf[UART_RX_BUFFER_SIZE] = {0};



	 UCSR0B |= (1<<RXCIE0);

}





//UART1接收完成中断

SIGNAL(SIG_UART1_RECV)

{

     unsigned char data;

	 unsigned char tmphead;

	 

	 data=UDR1;/* read the received data */

	 //calculate buffer index

	 tmphead=(UART1_RxHead+1)&UART_RX_BUFFER_MASK;//UART_RX_BUFFER_MASK 127

	 UART1_RxHead=tmphead;//store new index

	 

     if(tmphead==UART1_RxTail)

	 	 {

		 	/* ERROR! Receive buffer overflow */

	     }

	 UART1_RxBuf[tmphead]=data; //store received data in buffer

}





//UART0数据寄存器空中断

SIGNAL(SIG_UART0_DATA)

{

     unsigned char tmptail;

	 

	 if(UART0_TxHead!=UART0_TxTail)//check if all data is transmitted

	 	{

			/* calculate buffer index */

	     	tmptail=(UART0_TxTail+1)&UART_TX_BUFFER_MASK;//UART_TX_BUFFER_SIZE 128

		 	UART0_TxTail=tmptail;//store new index

		 	UDR0=UART0_TxBuf[tmptail];//start transmition

		 }

	 else

	 	{

	     	UCSR0B&=~(1<<UDRIE);//disable UDRE interrupt

		 }

}





//UART1数据寄存器空中断

SIGNAL(SIG_UART1_DATA)

//SIGNAL(SIG_UART1_TRANS)

{

     unsigned char tmptail;

	 

	 if(UART1_TxHead!=UART1_TxTail)//check if all data is transmitted

	 	{

		/* calculate buffer index */

	     tmptail=(UART1_TxTail+1)&UART_TX_BUFFER_MASK;//UART_TX_BUFFER_SIZE 128

		 UART1_TxTail=tmptail;//store new index

		 UDR1=UART1_TxBuf[tmptail];//start transmition

		 }

	 else

	 	{

	     	UCSR1B&=~(1<<UDRIE);//disable UDRE interrupt

		 }

}





unsigned char timer0count=0;

void ReadHoldRegister(void);



SIGNAL(SIG_OVERFLOW0)

{	

	TIMSK=0x00;//关定时器0中断



	timer0count++;



	//DDRA  |=(1<<3);//测试能否进入溢出中断

	//PORTA |=(1<<3);

	//_delay_ms(3000);

	//PORTA &=~(1<<3);

	//_delay_ms(3000);

	

	ReadHoldRegister();



	if(timer0count==15)	//150ms

	{

		//sendcommand(3,0x03,0x01);//读输入寄存器,startAddr,RegNum

		TIMSK=0x01;//开定时器0中断

	}

}





SIGNAL(SIG_OVERFLOW3)

{

	ETIMSK=0x00;//关定时器3溢出中断

	//DDRA  |=(1<<3);//测试能否进入溢出中断

	//PORTA ^=(1<<3);

	ReadHoldRegister();



	ETIMSK|= (1 << TOIE3);//开定时器3溢出中断

}







//将两个字符串连接起来

unsigned char strCat(unsigned char *s1,unsigned char *s2)

{

	int i=0,j=0;

	while(s1[i]!='\0')

		i++;

	while(s2[j]!='\0')

		s1[i++]=s2[j++];

	s1[i]='\0';

	return *s1;

}



	 

unsigned char UART0_ReceiveByte(void)

{

     unsigned char tmptail;

	 while(UART0_RxHead==UART0_RxTail);//wait for incoming data

	 //caculate buffer index

	 tmptail=(UART0_RxTail+1)&UART_RX_BUFFER_MASK;//UART_RX_BUFFER_MASK 127

	 UART0_RxTail=tmptail;//store new index

	 return UART0_RxBuf[tmptail];//return data

}





unsigned char UART1_ReceiveByte(void)

{

     unsigned char tmptail;

	 while(UART1_RxHead==UART1_RxTail);//wait for incoming data

	 //caculate buffer index

	 tmptail=(UART1_RxTail+1)&UART_RX_BUFFER_MASK;//UART_RX_BUFFER_MASK 127

	 UART1_RxTail=tmptail;//store new index

	 return UART1_RxBuf[tmptail];//return data

}





//发送采用查询方式

//USART0发送字符

unsigned char UART0_Receive(void) 

{

	/* 等待接收数据*/

	while ( !(UCSR0A & (1<<RXC0)) )

		;

	/* 从缓冲器中获取并返回数据*/

	return UDR0;

}







void UART0_TransmitByte(unsigned char data)

{

     unsigned char tmphead;

	 //caculate buffer index

	 tmphead=(UART0_TxHead+1)&UART_TX_BUFFER_MASK;//UART_TX_BUFFER_SIZE 128

	 while(tmphead==UART0_TxTail);//wait for free space in buffer

	 

	 UART0_TxBuf[tmphead]=data;//store new data in buffer

	 UART0_TxHead=tmphead;//store new index

	 UCSR0B|=(1<<UDRIE);//enable UDRIE interrupt

}



void UART1_TransmitByte(unsigned char data)

{

     unsigned char tmphead;

	 //caculate buffer index

	 tmphead=(UART1_TxHead+1)&UART_TX_BUFFER_MASK;//UART_TX_BUFFER_SIZE 128

	 while(tmphead==UART1_TxTail);//wait for free space in buffer

	 

	 UART1_TxBuf[tmphead]=data;//store new data in buffer

	 UART1_TxHead=tmphead;//store new index

	 UCSR1B|=(1<<UDRIE);//enable UDRIE interrupt

}





//发送采用查询方式

//USART0发送字符

void UART0_Transmit_c(unsigned char c) 

{

 	while(!(UCSR0A & (1<<UDRE)));//wait for empty transmit buffer

 	UDR0=c;

}



	 

//USART1发送字符

void UART1_Transmit_c(unsigned char c) //发送采用查询方式

{

 	while(!(UCSR1A & (1<<UDRE)));//wait for empty transmit buffer

 	UDR1=c;

}





void UART0_Transmit_String(unsigned char *ptr)

{

 	while (*ptr)

 	{

  		UART0_TransmitByte(*ptr++);

 	}

 	UART0_Transmit_c(0x0D);//结尾发送回车

 	UART0_Transmit_c(0x0A);//结尾发送换行

}





//USART1发送字符串

void UART1_Transmit_String(unsigned char *ptr)

{

 	while (*ptr)

 	{

  		UART1_TransmitByte(*ptr++);

 	}

 	UART1_Transmit_c(0x0D);//结尾发送回车

 	UART1_Transmit_c(0x0A);//结尾发送换行

}







void UART0_Transmit_HEX(unsigned char *ptr, int nLen)

{

 	for(int i=0; i<nLen; i++)

 	{

  		UART0_Transmit_c(ptr[i]);

 	}

}





void UART1_Transmit_HEX(unsigned char *ptr, int nLen)

{

 	for(int i=1; i<nLen; i++)

 	{

  		UART1_Transmit_c(ptr[i]);

 	}

}





/*

void wdt_init(void)

{

	asm("wdr");			//clr wdt

	WDTCR=0x0F;			//enable wdt,clk = 2048，1.8S

}



void watchdog_on(void) 

{

	//看门狗计数清零 

	asm("WDR");	

		

 	//WDTCR=0x1F;  	//使能watchdog,并且，采用1024K分频，典型溢出时间5V时1S 

 	WDTCR = (1 << WDE)|(1 << WDP2) | (1 << WDP1) | (1 << WDP0); // 启动看门狗定时, 复位周期为1S

} 





void WDT_off(void)

{

	//WDT复位

	asm("wdr");



	//置位WDCE 和 WDE

	WDTCR = (1<<WDCE) | (1<<WDE);



	//关闭WDT

	WDTCR = 0x00;

}

*/





unsigned short crc16(unsigned char* puchMsg, unsigned char usDataLen);



//往服务器发送数据

void ReadHoldRegister(void)

{	

	/*	

	unsigned char data_up;



	unsigned char CompayID[]={"shanghailianxun "};



	unsigned char DeviceCode[]={"DeviceCode "};



	unsigned char TransmitTimeStamp[]={"TimeStamp "};



	unsigned char DDC_Name[]={"DDC_0001 "};



	unsigned char NV_Name[]={"NV_001 "};



	unsigned char State[]={"State "};



	unsigned char Space[]={" "};



	unsigned char NVF[]={"NVF "};



	unsigned char CRCCode16[]={"CRCCode"};



	//TransmitTimeStamp[] = ReadTime();



				UCSR0B |=(1<<RXCIE0);//开USART0收中断

	

				UCSR1B |=(1<<TXCIE1);//开USART1发中断



								UART1_Transmit_String(CompayID);



								UART1_Transmit_String(DeviceCode);



								UART1_Transmit_String(TransmitTimeStamp);



								UART1_Transmit_String(DDC_Name);



								UART1_Transmit_String(NV_Name);



								UART1_Transmit_String(State);



								UART1_TransmitByte(data_up);



								//UART1_Transmit_String(UART0_RxBuf);



								UART1_Transmit_String(Space);



								UART1_Transmit_String(NVF);



								UART1_Transmit_String(CRCCode16);



								UART1_TransmitByte('\r');



								UART1_TransmitByte('\n');



				UCSR0B &=~(1<<RXCIE0); UCSR1B &=~(1<<TXCIE1);//关

		*/



     	unsigned char TransmitBuff[8] = {0};

	 	TransmitBuff[0] = 0x01;

     	TransmitBuff[1] = 0x03;

 		TransmitBuff[2] = 0x00;

 	 	TransmitBuff[3] = 0x00;



 	 	TransmitBuff[4] = 0x00;

     	TransmitBuff[5] = 0x0f;



		unsigned short wCrc = 0;

		wCrc = crc16(TransmitBuff, 6);



 	 	TransmitBuff[6] = (wCrc &0xFF00)>>8;

 	 	TransmitBuff[7] = (unsigned char)(wCrc &0x00FF);

		

		cli();//发送前清除所有中断



	 	UART0_Transmit_HEX(TransmitBuff,8);



		sei();//发送完成后打开中断



		//UCSR0B |= (1<<RXCIE0);

		UART0_ReceiveData();



		_delay_ms(30);

/*

		_delay_ms(20);

		_delay_ms(20);

		_delay_ms(20);

		_delay_ms(20);



		_delay_ms(20);

		_delay_ms(20);

		_delay_ms(20);

		_delay_ms(20);

*/



		cli();  



		UART1_Transmit_HEX(UART0_RxBuf,36); 



   		sei();  





	 	//_delay_ms(100);



	 //data_up=UART0_ReceiveByte();

/*

       unsigned char ReceiveBuff[128] = {0};



	 for (int n=0; n<35; n++)

	 	{

	 	    ReceiveBuff[n]=UART0_Receive();

	 	}

	 

	 UART1_Transmit_HEX(ReceiveBuff,35 );

*/

	 

}





//往设备发送数据

void SendDataDown(void)

{			

	

	//unsigned char data_down;



	//unsigned char CompayID[]={"shanghailianxun "};



	unsigned char DeviceCode[]={"DeviceCode "};



	unsigned char TransmitTimeStamp[]={"TimeStamp "};



	unsigned char DDC_Name[]={"DDC_0001 "};



	unsigned char NV_Name[]={"NV_001 "};



	unsigned char State[]={"State "};



	unsigned char Space[]={" "};



	unsigned char NVF[]={"NVF "};



	unsigned char CRCCode16[]={"CRCCode"};



					//data_down=UART1_ReceiveByte();

					//ReadTime();

					{

							UART0_Transmit_String(DeviceCode);



							UART0_Transmit_String(TransmitTimeStamp);



							UART0_Transmit_String(DDC_Name);



							UART0_Transmit_String(NV_Name);



							UART0_Transmit_String(State);



							//UART0_TransmitByte(data_down);



							UART0_Transmit_String(UART1_RxBuf);



							UART0_Transmit_String(Space);



							UART0_Transmit_String(NVF);



							UART0_Transmit_String(CRCCode16);



							UART0_TransmitByte('\r');



							UART0_TransmitByte('\n');



					}

}





int main(void)

{

	//unsigned char code str[] = "shanghailianxun";

	//unsigned char *pstr = str;

	//while(*pstr)

	//{

  		//send_a_char(*pstr);

  		//pstr ++;

	//}



     Initialize();

	 //PORTB=0xff;

	 //watchdog_on();



    //_delay_ms(100);

	//UART1_Transmit_String(string1);

	//UART1_TransmitByte('\n');

	while(1)

		{

			//data_down=UART1_ReceiveByte();

			;

			//ReadHoldRegister();

			//SendDataDown();

		}

}