WebSVN - Projects - Blame - /FollowMe/uart0.c

Rev	Author	Line No.	Line
231	killagreg	1	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		2	// + Copyright (c) 04.2007 Holger Buss
		3	// + only for non-profit use
		4	// + www.MikroKopter.com
		5	// + see the File "License.txt" for further Informations
		6	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		7
		8	#include <avr/io.h>
		9	#include <avr/interrupt.h>
		10	#include <avr/wdt.h>
		11	#include <stdarg.h>
		12	#include <string.h>
		13
		14	#include "main.h"
		15	#include "menu.h"
		16	#include "timer0.h"
		17	#include "uart0.h"
		18	#include "ubx.h"
		19	#include "led.h"
		20
		21
		22	#define FC_ADDRESS 1
		23	#define NC_ADDRESS 2
		24	#define MK3MAG_ADDRESS 3
		25
		26	#define FM_ADDRESS 10 // FOLLOW ME
		27
		28	#define FALSE 0
		29	#define TRUE 1
		30
		31	//int8_t test __attribute__ ((section (".noinit")));
		32	uint8_t Request_VerInfo = FALSE;
		33	uint8_t Request_Display = FALSE;
		34	uint8_t Request_Display1 = FALSE;
		35	uint8_t Request_ExternalControl = FALSE;
		36	uint8_t Request_DebugData = FALSE;
		37	uint8_t Request_DebugLabel = 255;
		38	uint8_t DisplayLine = 0;
		39
		40	volatile uint8_t txd_buffer[TXD_BUFFER_LEN];
		41	volatile uint8_t rxd_buffer_locked = FALSE;
		42	volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];
		43	volatile uint8_t txd_complete = TRUE;
		44	volatile uint8_t ReceivedBytes = 0;
		45	volatile uint8_t *pRxData = 0;
		46	volatile uint8_t RxDataLen = 0;
		47
		48	uint8_t PcAccess = 100;
		49
		50	ExternControl_t ExternControl;
		51	DebugOut_t DebugOut;
		52	UART_VersionInfo_t UART_VersionInfo;
		53
		54	uint16_t DebugData_Timer;
		55	uint16_t DebugData_Interval = 500; // in 1ms
		56
		57
		58	const uint8_t ANALOG_LABEL[32][16] =
		59	{
		60	//1234567890123456
		61	"Debug0 ", //0
		62	"Debug1 ",
		63	"Debug2 ",
		64	"Debug3 ",
		65	"Debug4 ",
		66	"Debug5 ", //5
		67	"Debug6 ",
		68	"Debug7 ",
		69	"Debug8 ",
		70	"Debug9 ",
		71	"Debug10 ", //10
		72	"Debug11 ",
		73	"Debug12 ",
		74	"Debug13 ",
		75	"Debug14 ",
		76	"Debug15 ", //15
		77	"Debug16 ",
		78	"Debug17 ",
		79	"Debug18 ",
		80	"Debug19 ",
		81	"Debug20 ", //20
		82	"Debug21 ",
		83	"Debug22 ",
		84	"Debug23 ",
		85	"Debug24 ",
		86	"Debug25 ", //25
		87	"Debug26 ",
		88	"Debug27 ",
		89	"Debug28 ",
		90	"Debug29 ",
		91	"Debug30 ", //30
		92	"Debug31 "
		93	};
		94
		95
		96
		97	/****************************************************************/
		98	/* Initialization of the USART0 */
		99	/****************************************************************/
		100	void USART0_Init (void)
		101	{
		102	uint8_t sreg = SREG;
		103	uint16_t ubrr = (uint16_t) ((uint32_t) SYSCLK/(8 * USART0_BAUD) - 1);
		104
		105	// disable all interrupts before configuration
		106	cli();
		107
		108	// disable RX-Interrupt
		109	UCSR0B &= ~(1 << RXCIE0);
		110	// disable TX-Interrupt
		111	UCSR0B &= ~(1 << TXCIE0);
		112
		113	// set direction of RXD0 and TXD0 pins
		114	// set RXD0 (PD0) as an input pin
		115	PORTD \|= (1 << PORTD0);
		116	DDRD &= ~(1 << DDD0);
		117	// set TXD0 (PD1) as an output pin
		118	PORTD \|= (1 << PORTD1);
		119	DDRD \|= (1 << DDD1);
		120
		121	// USART0 Baud Rate Register
		122	// set clock divider
		123	UBRR0H = (uint8_t)(ubrr >> 8);
		124	UBRR0L = (uint8_t)ubrr;
		125
		126	// USART0 Control and Status Register A, B, C
		127
		128	// enable double speed operation in
		129	UCSR0A \|= (1 << U2X0);
		130	// enable receiver and transmitter in
		131	UCSR0B = (1 << TXEN0) \| (1 << RXEN0);
		132	// set asynchronous mode
		133	UCSR0C &= ~(1 << UMSEL01);
		134	UCSR0C &= ~(1 << UMSEL00);
		135	// no parity
		136	UCSR0C &= ~(1 << UPM01);
		137	UCSR0C &= ~(1 << UPM00);
		138	// 1 stop bit
		139	UCSR0C &= ~(1 << USBS0);
		140	// 8-bit
		141	UCSR0B &= ~(1 << UCSZ02);
		142	UCSR0C \|= (1 << UCSZ01);
		143	UCSR0C \|= (1 << UCSZ00);
		144
		145	// flush receive buffer
		146	while ( UCSR0A & (1<<RXC0) ) UDR0;
		147
		148	// enable interrupts at the end
		149	// enable RX-Interrupt
		150	UCSR0B \|= (1 << RXCIE0);
		151	// enable TX-Interrupt
		152	UCSR0B \|= (1 << TXCIE0);
		153
		154	// initialize the debug timer
		155	DebugData_Timer = SetDelay(DebugData_Interval);
		156
		157	// unlock rxd_buffer
		158	rxd_buffer_locked = FALSE;
		159	pRxData = 0;
		160	RxDataLen = 0;
		161
		162	// no bytes to send
		163	txd_complete = TRUE;
		164
		165	UART_VersionInfo.SWMajor = VERSION_MAJOR;
		166	UART_VersionInfo.SWMinor = VERSION_MINOR;
		167	UART_VersionInfo.SWPatch = VERSION_PATCH;
		168	UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;
		169	UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;
		170
		171	// restore global interrupt flags
		172	SREG = sreg;
		173	}
		174
		175	/****************************************************************/
		176	/* USART0 transmitter ISR */
		177	/****************************************************************/
		178	ISR(USART0_TX_vect)
		179	{
		180	static uint16_t ptr_txd_buffer = 0;
		181	uint8_t tmp_tx;
		182	if(!txd_complete) // transmission not completed
		183	{
		184	ptr_txd_buffer++; // die [0] wurde schon gesendet
		185	tmp_tx = txd_buffer[ptr_txd_buffer];
		186	// if terminating character or end of txd buffer was reached
		187	if((tmp_tx == '\r') \|\| (ptr_txd_buffer == TXD_BUFFER_LEN))
		188	{
		189	ptr_txd_buffer = 0; // reset txd pointer
		190	txd_complete = 1; // stop transmission
		191	}
		192	UDR0 = tmp_tx; // send current byte will trigger this ISR again
		193	}
		194	// transmission completed
		195	else ptr_txd_buffer = 0;
		196	}
		197
		198	/****************************************************************/
		199	/* USART0 receiver ISR */
		200	/****************************************************************/
		201	ISR(USART0_RX_vect)
		202	{
		203	static uint16_t crc;
		204	static uint8_t ptr_rxd_buffer = 0;
		205	uint8_t crc1, crc2;
		206	uint8_t c;
		207
		208	c = UDR0; // catch the received byte
		209
		210	if(rxd_buffer_locked) return; // if rxd buffer is locked immediately return
		211
		212	// the rxd buffer is unlocked
		213	if((ptr_rxd_buffer == 0) && (c == '#')) // if rxd buffer is empty and syncronisation character is received
		214	{
		215	rxd_buffer[ptr_rxd_buffer++] = c; // copy 1st byte to buffer
		216	crc = c; // init crc
		217	}
		218	#if 0
		219	else if (ptr_rxd_buffer == 1) // handle address
		220	{
		221	rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
		222	crc += c; // update crc
		223	}
		224	#endif
		225	else if (ptr_rxd_buffer < RXD_BUFFER_LEN) // collect incomming bytes
		226	{
		227	if(c != '\r') // no termination character
		228	{
		229	rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
		230	crc += c; // update crc
		231	}
		232	else // termination character was received
		233	{
		234	// the last 2 bytes are no subject for checksum calculation
		235	// they are the checksum itself
		236	crc -= rxd_buffer[ptr_rxd_buffer-2];
		237	crc -= rxd_buffer[ptr_rxd_buffer-1];
		238	// calculate checksum from transmitted data
		239	crc %= 4096;
		240	crc1 = '=' + crc / 64;
		241	crc2 = '=' + crc % 64;
		242	// compare checksum to transmitted checksum bytes
		243	if((crc1 == rxd_buffer[ptr_rxd_buffer-2]) && (crc2 == rxd_buffer[ptr_rxd_buffer-1]))
		244	{ // checksum valid
		245	rxd_buffer[ptr_rxd_buffer] = '\r'; // set termination character
		246	ReceivedBytes = ptr_rxd_buffer + 1;// store number of received bytes
		247	rxd_buffer_locked = TRUE; // lock the rxd buffer
		248	// if 2nd byte is an 'R' enable watchdog that will result in an reset
		249	if(rxd_buffer[2] == 'R') {wdt_enable(WDTO_250MS);} // Reset-Commando
		250	}
		251	else
		252	{ // checksum invalid
		253	rxd_buffer_locked = FALSE; // unlock rxd buffer
		254	}
		255	ptr_rxd_buffer = 0; // reset rxd buffer pointer
		256	}
		257	}
		258	else // rxd buffer overrun
		259	{
		260	ptr_rxd_buffer = 0; // reset rxd buffer
		261	rxd_buffer_locked = FALSE; // unlock rxd buffer
		262	}
		263
		264	}
		265
		266
		267	// --------------------------------------------------------------------------
		268	void AddCRC(uint16_t datalen)
		269	{
		270	uint16_t tmpCRC = 0, i;
		271	for(i = 0; i < datalen; i++)
		272	{
		273	tmpCRC += txd_buffer[i];
		274	}
		275	tmpCRC %= 4096;
		276	txd_buffer[i++] = '=' + tmpCRC / 64;
		277	txd_buffer[i++] = '=' + tmpCRC % 64;
		278	txd_buffer[i++] = '\r';
		279	txd_complete = FALSE;
		280	UDR0 = txd_buffer[0]; // initiates the transmittion (continued in the TXD ISR)
		281	}
		282
		283
		284
		285	// --------------------------------------------------------------------------
		286	void SendOutData(uint8_t cmd, uint8_t addr, uint8_t numofbuffers, ...) // uint8_t *pdata, uint8_t len, ...
		287	{
		288	va_list ap;
		289	uint16_t pt = 0;
		290	uint8_t a,b,c;
		291	uint8_t ptr = 0;
		292
		293	uint8_t *pdata = 0;
		294	int len = 0;
		295
		296	txd_buffer[pt++] = '#'; // Start character
		297	txd_buffer[pt++] = 'a' + addr; // Address (a=0; b=1,...)
		298	txd_buffer[pt++] = cmd; // Command
		299
		300	va_start(ap, numofbuffers);
		301	if(numofbuffers)
		302	{
		303	pdata = va_arg(ap, uint8_t*);
		304	len = va_arg(ap, int);
		305	ptr = 0;
		306	numofbuffers--;
		307	}
		308
		309	while(len)
		310	{
		311	if(len)
		312	{
		313	a = pdata[ptr++];
		314	len--;
		315	if((!len) && numofbuffers)
		316	{
		317	pdata = va_arg(ap, uint8_t*);
		318	len = va_arg(ap, int);
		319	ptr = 0;
		320	numofbuffers--;
		321	}
		322	}
		323	else a = 0;
		324	if(len)
		325	{
		326	b = pdata[ptr++];
		327	len--;
		328	if((!len) && numofbuffers)
		329	{
		330	pdata = va_arg(ap, uint8_t*);
		331	len = va_arg(ap, int);
		332	ptr = 0;
		333	numofbuffers--;
		334	}
		335	}
		336	else b = 0;
		337	if(len)
		338	{
		339	c = pdata[ptr++];
		340	len--;
		341	if((!len) && numofbuffers)
		342	{
		343	pdata = va_arg(ap, uint8_t*);
		344	len = va_arg(ap, int);
		345	ptr = 0;
		346	numofbuffers--;
		347	}
		348	}
		349	else c = 0;
		350	txd_buffer[pt++] = '=' + (a >> 2);
		351	txd_buffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));
		352	txd_buffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));
		353	txd_buffer[pt++] = '=' + ( c & 0x3f);
		354	}
		355	va_end(ap);
		356	AddCRC(pt); // add checksum after data block and initates the transmission
		357	}
		358
		359
		360	// --------------------------------------------------------------------------
		361	void Decode64(void)
		362	{
		363	uint8_t a,b,c,d;
		364	uint8_t x,y,z;
		365	uint8_t ptrIn = 3;
		366	uint8_t ptrOut = 3;
		367	uint8_t len = ReceivedBytes - 6;
		368
		369	while(len)
		370	{
		371	a = rxd_buffer[ptrIn++] - '=';
		372	b = rxd_buffer[ptrIn++] - '=';
		373	c = rxd_buffer[ptrIn++] - '=';
		374	d = rxd_buffer[ptrIn++] - '=';
		375	//if(ptrIn > ReceivedBytes - 3) break;
		376
		377	x = (a << 2) \| (b >> 4);
		378	y = ((b & 0x0f) << 4) \| (c >> 2);
		379	z = ((c & 0x03) << 6) \| d;
		380
		381	if(len--) rxd_buffer[ptrOut++] = x; else break;
		382	if(len--) rxd_buffer[ptrOut++] = y; else break;
		383	if(len--) rxd_buffer[ptrOut++] = z; else break;
		384	}
		385	pRxData = &rxd_buffer[3];
		386	RxDataLen = ptrOut - 3;
		387	}
		388
		389
		390	// --------------------------------------------------------------------------
		391	void USART0_ProcessRxData(void)
		392	{
		393	// if data in the rxd buffer are not locked immediately return
		394	if(!rxd_buffer_locked) return;
		395
		396	Decode64(); // decode data block in rxd_buffer
		397
		398
		399	switch(rxd_buffer[1] - 'a')
		400	{
		401	case FM_ADDRESS:
		402
		403	switch(rxd_buffer[2])
		404	{
		405	default:
		406	//unsupported command received
		407	break;
		408	} // case FC_ADDRESS:
		409
		410	default: // any Slave Address
		411
		412	switch(rxd_buffer[2])
		413	{
		414	case 'a':// request for labels of the analog debug outputs
		415	Request_DebugLabel = pRxData[0];
		416	if(Request_DebugLabel > 31) Request_DebugLabel = 31;
		417	PcAccess = 255;
		418	break;
		419
		420	case 'h':// request for display columns
		421	PcAccess = 255;
		422	RemoteKeys \|= pRxData[0];
		423	if(RemoteKeys) DisplayLine = 0;
		424	Request_Display = TRUE;
		425	break;
		426
		427	case 'l':// request for display columns
		428	PcAccess = 255;
		429	MenuItem = pRxData[0];
		430	Request_Display1 = TRUE;
		431	break;
		432
		433	case 'v': // request for version and board release
		434	Request_VerInfo = TRUE;
		435	break;
		436
		437	case 'd': // request for the debug data
		438	DebugData_Interval = (uint16_t) pRxData[0] * 10;
		439	if(DebugData_Interval > 0) Request_DebugData = TRUE;
		440	break;
		441
		442	case 'g':// get external control data
		443	Request_ExternalControl = TRUE;
		444	break;
		445
		446	default:
		447	LEDRED_TOGGLE;
		448	//unsupported command received
		449	break;
		450	}
		451	break; // default:
		452	}
		453	// unlock the rxd buffer after processing
		454	pRxData = 0;
		455	RxDataLen = 0;
		456	rxd_buffer_locked = FALSE;
		457	}
		458
		459	//############################################################################
		460	//Routine f�r die Serielle Ausgabe
		461	int16_t uart_putchar (int8_t c)
		462	//############################################################################
		463	{
		464	if (c == '\n')
		465	uart_putchar('\r');
		466	// wait until previous character was send
		467	loop_until_bit_is_set(UCSR0A, UDRE0);
		468	// send character
		469	UDR0 = c;
		470	return (0);
		471	}
		472
		473
		474	//---------------------------------------------------------------------------------------------
		475	void USART0_TransmitTxData(void)
		476	{
		477	if(!txd_complete) return;
		478
		479	if(Request_VerInfo && txd_complete)
		480	{
		481	SendOutData('V', FM_ADDRESS, 1, (uint8_t *) &UART_VersionInfo, sizeof(UART_VersionInfo));
		482	Request_VerInfo = FALSE;
		483	}
		484	if(Request_Display && txd_complete)
		485	{
		486	LCD_PrintMenu();
		487	SendOutData('H', FM_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), &DisplayBuff[DisplayLine * 20], 20);
		488	DisplayLine++;
		489	if(DisplayLine >= 4) DisplayLine = 0;
		490	Request_Display = FALSE;
		491	}
		492	if(Request_Display1 && txd_complete)
		493	{
		494	LCD_PrintMenu();
		495	SendOutData('L', FM_ADDRESS, 3, &MenuItem, sizeof(MenuItem), &MaxMenuItem, sizeof(MaxMenuItem), DisplayBuff, sizeof(DisplayBuff));
		496	Request_Display1 = FALSE;
		497	}
		498	if(Request_DebugLabel != 0xFF) // Texte f�r die Analogdaten
		499	{
		500	SendOutData('A', FM_ADDRESS, 2, (uint8_t *) &Request_DebugLabel, sizeof(Request_DebugLabel), ANALOG_LABEL[Request_DebugLabel], 16);
		501	Request_DebugLabel = 0xFF;
		502	}
		503	if(Request_ExternalControl && txd_complete)
		504	{
		505	SendOutData('G', FM_ADDRESS, 1,(uint8_t *) &ExternControl, sizeof(ExternControl));
		506	Request_ExternalControl = FALSE;
		507	}
		508	if( ((DebugData_Interval && CheckDelay(DebugData_Timer)) \|\| Request_DebugData) && txd_complete)
		509	{
		510	SendOutData('D', FM_ADDRESS, 1,(uint8_t *) &DebugOut, sizeof(DebugOut));
		511	DebugData_Timer = SetDelay(DebugData_Interval);
		512	Request_DebugData = FALSE;
		513	}
		514	}
		515

Subversion Repositories Projects

(root)/FollowMe/uart0.c @ 240 - Rev