WebSVN - Projects - Diff - Rev 389 and 514


/****************************************************************************
 *   Copyright (C) 2009 by Claas Anders "CaScAdE" Rathje                    *
 *   admiralcascade@gmail.com                                               *
 *   Project-URL: http://www.mylifesucks.de/oss/c-osd/                      *
 *                                                                          *
 *   This program is free software; you can redistribute it and/or modify   *
 *   it under the terms of the GNU General Public License as published by   *
 *   the Free Software Foundation; either version 2 of the License.         *
 *                                                                          *
 *   This program is distributed in the hope that it will be useful,        *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *   GNU General Public License for more details.                           *
 *                                                                          *
 *   You should have received a copy of the GNU General Public License      *
 *   along with this program; if not, write to the                          *
 *   Free Software Foundation, Inc.,                                        *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.              *
 ****************************************************************************/
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "main.h"
#include "usart1.h"
 
#if !(ALLCHARSDEBUG|(WRITECHARS != -1))
 
volatile uint8_t rxd_buffer_locked = 0;
volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];
volatile uint8_t txd_buffer[TXD_BUFFER_LEN];
volatile uint8_t ReceivedBytes = 0;
volatile uint8_t *pRxData = 0;
volatile uint8_t RxDataLen = 0;
 
/* ##########################################################################
 * USART stuff
 * ##########################################################################*/
 
/**
 * init usart1
 */
void usart1_init() {
    UBRR1H = ((F_CPU / (16UL * baud)) - 1) >> 8;
    UBRR1L = (F_CPU / (16UL * baud)) - 1;
 
    // Enable receiver and transmitter; enable RX interrupt
    UCSR1B = (1 << RXEN1) | (1 << TXEN1) | (1 << RXCIE1);
 
    //asynchronous 8N1
    UCSR1C = (1 << URSEL1) | (3 << UCSZ10);
}
 
/**
 * disable the txd pin of usart1
 */
void usart1_DisableTXD(void) {
        UCSR1B &= ~(1 << TXCIE1); // disable TX-Interrupt
        UCSR1B &= ~(1 << TXEN1); // disable TX in USART
        DDRB &= ~(1<<DDB3); // set TXD pin as input
        PORTB &= ~(1 << PORTB3); // disable pullup on TXD pin
}
 
/**
 * enable the txd pin of usart1
 */
void usart1_EnableTXD(void) {
        DDRB |= (1<<DDB3); // set TXD pin as output
        PORTB &= ~(1 << PORTB3); // disable pullup on TXD pin
        UCSR1B |= (1 << TXEN1); // enable TX in USART
        UCSR1B |= (1 << TXCIE1); // enable TX-Interrupt
}
 
/**
 * send a single <character> through usart1
 */
void usart1_putc(unsigned char character) {
    // wait until UDR ready
    while (!(UCSR1A & (1 << UDRE1)));
    UDR1 = character;
}
 
/**
 * send a <string> throught usart1
 */
void usart1_puts(char *s) {
    while (*s) {
        usart1_putc(*s);
        s++;
    }
}
 
/**
 * transmit interrupt handler
 * unused
 */
ISR(SIG_USART1_DATA) {
}
 
/**
 * receive data through usart1
 * portions taken and adapted from
 * http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Fbranches%2FV0.72p+Code+Redesign+killagreg%2Fuart0.c
 */
ISR(SIG_USART1_RECV) {
    if (rxd_buffer_locked) return; // if rxd buffer is locked immediately return
    LED1_ON
            static uint16_t crc;
    static uint8_t ptr_rxd_buffer = 0;
    uint8_t crc1, crc2;
    uint8_t c;
 
    c = UDR1; // catch the received byte
 
    // the rxd buffer is unlocked
    if ((ptr_rxd_buffer == 0) && (c == '#')) // if rxd buffer is empty and syncronisation character is received
    {
                /*
                // skip other datasets
        if (ptr_rxd_buffer == 2 && rxd_buffer[ptr_rxd_buffer] != 'O') {
                        ptr_rxd_buffer = 0; // reset rxd buffer
                rxd_buffer_locked = 0; // unlock rxd buffer
                }*/
                rxd_buffer[ptr_rxd_buffer++] = c; // copy 1st byte to buffer
        crc = c; // init crc
    } else if (ptr_rxd_buffer < RXD_BUFFER_LEN) // collect incomming bytes
    {
        if (c != '\r') // no termination character
        {
            rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
            crc += c; // update crc
        } else // termination character was received
        {
            // the last 2 bytes are no subject for checksum calculation
            // they are the checksum itself
            crc -= rxd_buffer[ptr_rxd_buffer - 2];
            crc -= rxd_buffer[ptr_rxd_buffer - 1];
            // calculate checksum from transmitted data
            crc %= 4096;
            crc1 = '=' + crc / 64;
            crc2 = '=' + crc % 64;
            // compare checksum to transmitted checksum bytes
            if ((crc1 == rxd_buffer[ptr_rxd_buffer - 2]) && (crc2 == rxd_buffer[ptr_rxd_buffer - 1])) { // checksum valid
                rxd_buffer[ptr_rxd_buffer] = '\r'; // set termination character
                ReceivedBytes = ptr_rxd_buffer + 1; // store number of received bytes
                rxd_buffer_locked = 1; // lock the rxd buffer
            } else { // checksum invalid
                rxd_buffer_locked = 0; // unlock rxd buffer
            }
            ptr_rxd_buffer = 0; // reset rxd buffer pointer
        }
    } else // rxd buffer overrun
    {
        ptr_rxd_buffer = 0; // reset rxd buffer
        rxd_buffer_locked = 0; // unlock rxd buffer
    }
    LED1_OFF
}
 
/**
 * Decode the recevied Buffer
 * portions taken and adapted from
 * http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Ftags%2FV0.72p%2Fuart.c
 */
void Decode64(void) {
    uint8_t a, b, c, d;
    uint8_t x, y, z;
    uint8_t ptrIn = 3;
    uint8_t ptrOut = 3;
    uint8_t len = ReceivedBytes - 6;
 
    while (len) {
        a = rxd_buffer[ptrIn++] - '=';
        b = rxd_buffer[ptrIn++] - '=';
        c = rxd_buffer[ptrIn++] - '=';
        d = rxd_buffer[ptrIn++] - '=';
 
        x = (a << 2) | (b >> 4);
        y = ((b & 0x0f) << 4) | (c >> 2);
        z = ((c & 0x03) << 6) | d;
 
        if (len--) rxd_buffer[ptrOut++] = x;
        else break;
        if (len--) rxd_buffer[ptrOut++] = y;
        else break;
        if (len--) rxd_buffer[ptrOut++] = z;
        else break;
    }
    pRxData = &rxd_buffer[3];
    RxDataLen = ptrOut - 3;
}
 
/**
 * request Data through USART in special MK format by adding checksum and
 * encode data in modified Base64
 * portions taken and adapted from
 * http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Ftags%2FV0.72p%2Fuart.c
 */
void sendMKData(unsigned char cmd, unsigned char addr, unsigned char *snd, unsigned char len) {
    unsigned int pt = 0;
    unsigned char a, b, c;
    unsigned char ptr = 0;
 
    txd_buffer[pt++] = '#'; // Start-Byte
    txd_buffer[pt++] = 'a' + addr; // Adress
    txd_buffer[pt++] = cmd; // Command
    while (len) {
        if (len) {
            a = snd[ptr++];
            len--;
        } else a = 0;
        if (len) {
            b = snd[ptr++];
            len--;
        } else b = 0;
        if (len) {
            c = snd[ptr++];
            len--;
        } else c = 0;
        txd_buffer[pt++] = '=' + (a >> 2);
        txd_buffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
        txd_buffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
        txd_buffer[pt++] = '=' + (c & 0x3f);
    }
 
    // add crc
    unsigned int tmpCRC = 0, i;
    for (i = 0; i < pt; i++) {
        tmpCRC += txd_buffer[i];
    }
    tmpCRC %= 4096;
    txd_buffer[i++] = '=' + tmpCRC / 64;
    txd_buffer[i++] = '=' + tmpCRC % 64;
    txd_buffer[i++] = '\r';
 
    usart1_puts((char*) txd_buffer);
}
 
/**
 * short script to directly send a request thorugh usart including en- and disabling it
 * where <address> is the address of the receipient, <label> is which data set to request
 * and <ms> represents the milliseconds delay between data
 */
void usart1_request_mk_data(uint8_t address, char label, uint8_t ms) {
            // re-enable TXD pin
            usart1_EnableTXD();
 
            unsigned char mstenth = ms/10;
                        sendMKData(label, address, &mstenth, 1);
                        // wait until UDR ready
                        while (!(UCSR1A & (1 << UDRE1)));                                              
            // disable TXD pin again
            usart1_DisableTXD();
}
 
#endif
 

Rev 389	Rev 514
1	/****************************************************************************	1	/****************************************************************************
2	* Copyright (C) 2009 by Claas Anders "CaScAdE" Rathje *	2	* Copyright (C) 2009 by Claas Anders "CaScAdE" Rathje *
3	* admiralcascade@gmail.com *	3	* admiralcascade@gmail.com *
4	* Project-URL: http://www.mylifesucks.de/oss/c-osd/ *	4	* Project-URL: http://www.mylifesucks.de/oss/c-osd/ *
5	* *	5	* *
6	* This program is free software; you can redistribute it and/or modify *	6	* This program is free software; you can redistribute it and/or modify *
7	* it under the terms of the GNU General Public License as published by *	7	* it under the terms of the GNU General Public License as published by *
8	* the Free Software Foundation; either version 2 of the License. *	8	* the Free Software Foundation; either version 2 of the License. *
9	* *	9	* *
10	* This program is distributed in the hope that it will be useful, *	10	* This program is distributed in the hope that it will be useful, *
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of *	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13	* GNU General Public License for more details. *	13	* GNU General Public License for more details. *
14	* *	14	* *
15	* You should have received a copy of the GNU General Public License *	15	* You should have received a copy of the GNU General Public License *
16	* along with this program; if not, write to the *	16	* along with this program; if not, write to the *
17	* Free Software Foundation, Inc., *	17	* Free Software Foundation, Inc., *
18	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *	18	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19	****************************************************************************/	19	****************************************************************************/
20		20
21	#include <avr/io.h>	21	#include <avr/io.h>
22	#include <avr/interrupt.h>	22	#include <avr/interrupt.h>
23	#include <util/delay.h>	23	#include <util/delay.h>
24	#include "main.h"	24	#include "main.h"
25	#include "usart1.h"	25	#include "usart1.h"
-		26
-		27	#if !(ALLCHARSDEBUG\|(WRITECHARS != -1))
26		28
27	volatile uint8_t rxd_buffer_locked = 0;	29	volatile uint8_t rxd_buffer_locked = 0;
28	volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];	30	volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];
29	volatile uint8_t txd_buffer[TXD_BUFFER_LEN];	31	volatile uint8_t txd_buffer[TXD_BUFFER_LEN];
30	volatile uint8_t ReceivedBytes = 0;	32	volatile uint8_t ReceivedBytes = 0;
31	volatile uint8_t *pRxData = 0;	33	volatile uint8_t *pRxData = 0;
32	volatile uint8_t RxDataLen = 0;	34	volatile uint8_t RxDataLen = 0;
33		35
34	/* ##########################################################################	36	/* ##########################################################################
35	* USART stuff	37	* USART stuff
36	* ##########################################################################*/	38	* ##########################################################################*/
37		39
38	/**	40	/**
39	* init usart1	41	* init usart1
40	*/	42	*/
41	void usart1_init() {	43	void usart1_init() {
42	UBRR1H = ((F_CPU / (16UL * baud)) - 1) >> 8;	44	UBRR1H = ((F_CPU / (16UL * baud)) - 1) >> 8;
43	UBRR1L = (F_CPU / (16UL * baud)) - 1;	45	UBRR1L = (F_CPU / (16UL * baud)) - 1;
44		46
45	// Enable receiver and transmitter; enable RX interrupt	47	// Enable receiver and transmitter; enable RX interrupt
46	UCSR1B = (1 << RXEN1) \| (1 << TXEN1) \| (1 << RXCIE1);	48	UCSR1B = (1 << RXEN1) \| (1 << TXEN1) \| (1 << RXCIE1);
47		49
48	//asynchronous 8N1	50	//asynchronous 8N1
49	UCSR1C = (1 << URSEL1) \| (3 << UCSZ10);	51	UCSR1C = (1 << URSEL1) \| (3 << UCSZ10);
50	}	52	}
51		53
52	/**	54	/**
53	* disable the txd pin of usart1	55	* disable the txd pin of usart1
54	*/	56	*/
55	void usart1_DisableTXD(void) {	57	void usart1_DisableTXD(void) {
56	UCSR1B &= ~(1 << TXCIE1); // disable TX-Interrupt	58	UCSR1B &= ~(1 << TXCIE1); // disable TX-Interrupt
57	UCSR1B &= ~(1 << TXEN1); // disable TX in USART	59	UCSR1B &= ~(1 << TXEN1); // disable TX in USART
58	DDRB &= ~(1<<DDB3); // set TXD pin as input	60	DDRB &= ~(1<<DDB3); // set TXD pin as input
59	PORTB &= ~(1 << PORTB3); // disable pullup on TXD pin	61	PORTB &= ~(1 << PORTB3); // disable pullup on TXD pin
60	}	62	}
61		63
62	/**	64	/**
63	* enable the txd pin of usart1	65	* enable the txd pin of usart1
64	*/	66	*/
65	void usart1_EnableTXD(void) {	67	void usart1_EnableTXD(void) {
66	DDRB \|= (1<<DDB3); // set TXD pin as output	68	DDRB \|= (1<<DDB3); // set TXD pin as output
67	PORTB &= ~(1 << PORTB3); // disable pullup on TXD pin	69	PORTB &= ~(1 << PORTB3); // disable pullup on TXD pin
68	UCSR1B \|= (1 << TXEN1); // enable TX in USART	70	UCSR1B \|= (1 << TXEN1); // enable TX in USART
69	UCSR1B \|= (1 << TXCIE1); // enable TX-Interrupt	71	UCSR1B \|= (1 << TXCIE1); // enable TX-Interrupt
70	}	72	}
71		73
72	/**	74	/**
73	* send a single <character> through usart1	75	* send a single <character> through usart1
74	*/	76	*/
75	void usart1_putc(unsigned char character) {	77	void usart1_putc(unsigned char character) {
76	// wait until UDR ready	78	// wait until UDR ready
77	while (!(UCSR1A & (1 << UDRE1)));	79	while (!(UCSR1A & (1 << UDRE1)));
78	UDR1 = character;	80	UDR1 = character;
79	}	81	}
80		82
81	/**	83	/**
82	* send a <string> throught usart1	84	* send a <string> throught usart1
83	*/	85	*/
84	void usart1_puts(char *s) {	86	void usart1_puts(char *s) {
85	while (*s) {	87	while (*s) {
86	usart1_putc(*s);	88	usart1_putc(*s);
87	s++;	89	s++;
88	}	90	}
89	}	91	}
90		92
91	/**	93	/**
92	* transmit interrupt handler	94	* transmit interrupt handler
93	* unused	95	* unused
94	*/	96	*/
95	ISR(SIG_USART1_DATA) {	97	ISR(SIG_USART1_DATA) {
96	}	98	}
97		99
98	/**	100	/**
99	* receive data through usart1	101	* receive data through usart1
100	* portions taken and adapted from	102	* portions taken and adapted from
101	* http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Fbranches%2FV0.72p+Code+Redesign+killagreg%2Fuart0.c	103	* http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Fbranches%2FV0.72p+Code+Redesign+killagreg%2Fuart0.c
102	*/	104	*/
103	ISR(SIG_USART1_RECV) {	105	ISR(SIG_USART1_RECV) {
104	if (rxd_buffer_locked) return; // if rxd buffer is locked immediately return	106	if (rxd_buffer_locked) return; // if rxd buffer is locked immediately return
105	LED1_ON	107	LED1_ON
106	static uint16_t crc;	108	static uint16_t crc;
107	static uint8_t ptr_rxd_buffer = 0;	109	static uint8_t ptr_rxd_buffer = 0;
108	uint8_t crc1, crc2;	110	uint8_t crc1, crc2;
109	uint8_t c;	111	uint8_t c;
110		112
111	c = UDR1; // catch the received byte	113	c = UDR1; // catch the received byte
112		114
113	// the rxd buffer is unlocked	115	// the rxd buffer is unlocked
114	if ((ptr_rxd_buffer == 0) && (c == '#')) // if rxd buffer is empty and syncronisation character is received	116	if ((ptr_rxd_buffer == 0) && (c == '#')) // if rxd buffer is empty and syncronisation character is received
115	{	117	{
116	/*	118	/*
117	// skip other datasets	119	// skip other datasets
118	if (ptr_rxd_buffer == 2 && rxd_buffer[ptr_rxd_buffer] != 'O') {	120	if (ptr_rxd_buffer == 2 && rxd_buffer[ptr_rxd_buffer] != 'O') {
119	ptr_rxd_buffer = 0; // reset rxd buffer	121	ptr_rxd_buffer = 0; // reset rxd buffer
120	rxd_buffer_locked = 0; // unlock rxd buffer	122	rxd_buffer_locked = 0; // unlock rxd buffer
121	}*/	123	}*/
122	rxd_buffer[ptr_rxd_buffer++] = c; // copy 1st byte to buffer	124	rxd_buffer[ptr_rxd_buffer++] = c; // copy 1st byte to buffer
123	crc = c; // init crc	125	crc = c; // init crc
124	} else if (ptr_rxd_buffer < RXD_BUFFER_LEN) // collect incomming bytes	126	} else if (ptr_rxd_buffer < RXD_BUFFER_LEN) // collect incomming bytes
125	{	127	{
126	if (c != '\r') // no termination character	128	if (c != '\r') // no termination character
127	{	129	{
128	rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer	130	rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
129	crc += c; // update crc	131	crc += c; // update crc
130	} else // termination character was received	132	} else // termination character was received
131	{	133	{
132	// the last 2 bytes are no subject for checksum calculation	134	// the last 2 bytes are no subject for checksum calculation
133	// they are the checksum itself	135	// they are the checksum itself
134	crc -= rxd_buffer[ptr_rxd_buffer - 2];	136	crc -= rxd_buffer[ptr_rxd_buffer - 2];
135	crc -= rxd_buffer[ptr_rxd_buffer - 1];	137	crc -= rxd_buffer[ptr_rxd_buffer - 1];
136	// calculate checksum from transmitted data	138	// calculate checksum from transmitted data
137	crc %= 4096;	139	crc %= 4096;
138	crc1 = '=' + crc / 64;	140	crc1 = '=' + crc / 64;
139	crc2 = '=' + crc % 64;	141	crc2 = '=' + crc % 64;
140	// compare checksum to transmitted checksum bytes	142	// compare checksum to transmitted checksum bytes
141	if ((crc1 == rxd_buffer[ptr_rxd_buffer - 2]) && (crc2 == rxd_buffer[ptr_rxd_buffer - 1])) { // checksum valid	143	if ((crc1 == rxd_buffer[ptr_rxd_buffer - 2]) && (crc2 == rxd_buffer[ptr_rxd_buffer - 1])) { // checksum valid
142	rxd_buffer[ptr_rxd_buffer] = '\r'; // set termination character	144	rxd_buffer[ptr_rxd_buffer] = '\r'; // set termination character
143	ReceivedBytes = ptr_rxd_buffer + 1; // store number of received bytes	145	ReceivedBytes = ptr_rxd_buffer + 1; // store number of received bytes
144	rxd_buffer_locked = 1; // lock the rxd buffer	146	rxd_buffer_locked = 1; // lock the rxd buffer
145	} else { // checksum invalid	147	} else { // checksum invalid
146	rxd_buffer_locked = 0; // unlock rxd buffer	148	rxd_buffer_locked = 0; // unlock rxd buffer
147	}	149	}
148	ptr_rxd_buffer = 0; // reset rxd buffer pointer	150	ptr_rxd_buffer = 0; // reset rxd buffer pointer
149	}	151	}
150	} else // rxd buffer overrun	152	} else // rxd buffer overrun
151	{	153	{
152	ptr_rxd_buffer = 0; // reset rxd buffer	154	ptr_rxd_buffer = 0; // reset rxd buffer
153	rxd_buffer_locked = 0; // unlock rxd buffer	155	rxd_buffer_locked = 0; // unlock rxd buffer
154	}	156	}
155	LED1_OFF	157	LED1_OFF
156	}	158	}
157		159
158	/**	160	/**
159	* Decode the recevied Buffer	161	* Decode the recevied Buffer
160	* portions taken and adapted from	162	* portions taken and adapted from
161	* http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Ftags%2FV0.72p%2Fuart.c	163	* http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Ftags%2FV0.72p%2Fuart.c
162	*/	164	*/
163	void Decode64(void) {	165	void Decode64(void) {
164	uint8_t a, b, c, d;	166	uint8_t a, b, c, d;
165	uint8_t x, y, z;	167	uint8_t x, y, z;
166	uint8_t ptrIn = 3;	168	uint8_t ptrIn = 3;
167	uint8_t ptrOut = 3;	169	uint8_t ptrOut = 3;
168	uint8_t len = ReceivedBytes - 6;	170	uint8_t len = ReceivedBytes - 6;
169		171
170	while (len) {	172	while (len) {
171	a = rxd_buffer[ptrIn++] - '=';	173	a = rxd_buffer[ptrIn++] - '=';
172	b = rxd_buffer[ptrIn++] - '=';	174	b = rxd_buffer[ptrIn++] - '=';
173	c = rxd_buffer[ptrIn++] - '=';	175	c = rxd_buffer[ptrIn++] - '=';
174	d = rxd_buffer[ptrIn++] - '=';	176	d = rxd_buffer[ptrIn++] - '=';
175		177
176	x = (a << 2) \| (b >> 4);	178	x = (a << 2) \| (b >> 4);
177	y = ((b & 0x0f) << 4) \| (c >> 2);	179	y = ((b & 0x0f) << 4) \| (c >> 2);
178	z = ((c & 0x03) << 6) \| d;	180	z = ((c & 0x03) << 6) \| d;
179		181
180	if (len--) rxd_buffer[ptrOut++] = x;	182	if (len--) rxd_buffer[ptrOut++] = x;
181	else break;	183	else break;
182	if (len--) rxd_buffer[ptrOut++] = y;	184	if (len--) rxd_buffer[ptrOut++] = y;
183	else break;	185	else break;
184	if (len--) rxd_buffer[ptrOut++] = z;	186	if (len--) rxd_buffer[ptrOut++] = z;
185	else break;	187	else break;
186	}	188	}
187	pRxData = &rxd_buffer[3];	189	pRxData = &rxd_buffer[3];
188	RxDataLen = ptrOut - 3;	190	RxDataLen = ptrOut - 3;
189	}	191	}
190		192
191	/**	193	/**
192	* request Data through USART in special MK format by adding checksum and	194	* request Data through USART in special MK format by adding checksum and
193	* encode data in modified Base64	195	* encode data in modified Base64
194	* portions taken and adapted from	196	* portions taken and adapted from
195	* http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Ftags%2FV0.72p%2Fuart.c	197	* http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Ftags%2FV0.72p%2Fuart.c
196	*/	198	*/
197	void sendMKData(unsigned char cmd, unsigned char addr, unsigned char *snd, unsigned char len) {	199	void sendMKData(unsigned char cmd, unsigned char addr, unsigned char *snd, unsigned char len) {
198	unsigned int pt = 0;	200	unsigned int pt = 0;
199	unsigned char a, b, c;	201	unsigned char a, b, c;
200	unsigned char ptr = 0;	202	unsigned char ptr = 0;
201		203
202	txd_buffer[pt++] = '#'; // Start-Byte	204	txd_buffer[pt++] = '#'; // Start-Byte
203	txd_buffer[pt++] = 'a' + addr; // Adress	205	txd_buffer[pt++] = 'a' + addr; // Adress
204	txd_buffer[pt++] = cmd; // Command	206	txd_buffer[pt++] = cmd; // Command
205	while (len) {	207	while (len) {
206	if (len) {	208	if (len) {
207	a = snd[ptr++];	209	a = snd[ptr++];
208	len--;	210	len--;
209	} else a = 0;	211	} else a = 0;
210	if (len) {	212	if (len) {
211	b = snd[ptr++];	213	b = snd[ptr++];
212	len--;	214	len--;
213	} else b = 0;	215	} else b = 0;
214	if (len) {	216	if (len) {
215	c = snd[ptr++];	217	c = snd[ptr++];
216	len--;	218	len--;
217	} else c = 0;	219	} else c = 0;
218	txd_buffer[pt++] = '=' + (a >> 2);	220	txd_buffer[pt++] = '=' + (a >> 2);
219	txd_buffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));	221	txd_buffer[pt++] = '=' + (((a & 0x03) << 4) \| ((b & 0xf0) >> 4));
220	txd_buffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));	222	txd_buffer[pt++] = '=' + (((b & 0x0f) << 2) \| ((c & 0xc0) >> 6));
221	txd_buffer[pt++] = '=' + (c & 0x3f);	223	txd_buffer[pt++] = '=' + (c & 0x3f);
222	}	224	}
223		225
224	// add crc	226	// add crc
225	unsigned int tmpCRC = 0, i;	227	unsigned int tmpCRC = 0, i;
226	for (i = 0; i < pt; i++) {	228	for (i = 0; i < pt; i++) {
227	tmpCRC += txd_buffer[i];	229	tmpCRC += txd_buffer[i];
228	}	230	}
229	tmpCRC %= 4096;	231	tmpCRC %= 4096;
230	txd_buffer[i++] = '=' + tmpCRC / 64;	232	txd_buffer[i++] = '=' + tmpCRC / 64;
231	txd_buffer[i++] = '=' + tmpCRC % 64;	233	txd_buffer[i++] = '=' + tmpCRC % 64;
232	txd_buffer[i++] = '\r';	234	txd_buffer[i++] = '\r';
233		235
234	usart1_puts((char*) txd_buffer);	236	usart1_puts((char*) txd_buffer);
235	}	237	}
236		238
237	/**	239	/**
238	* short script to directly send a request thorugh usart including en- and disabling it	240	* short script to directly send a request thorugh usart including en- and disabling it
239	* where <address> is the address of the receipient, <label> is which data set to request	241	* where <address> is the address of the receipient, <label> is which data set to request
240	* and <ms> represents the milliseconds delay between data	242	* and <ms> represents the milliseconds delay between data
241	*/	243	*/
242	void usart1_request_mk_data(uint8_t address, char label, uint8_t ms) {	244	void usart1_request_mk_data(uint8_t address, char label, uint8_t ms) {
243	// re-enable TXD pin	245	// re-enable TXD pin
244	usart1_EnableTXD();	246	usart1_EnableTXD();
245		247
246	unsigned char mstenth = ms/10;	248	unsigned char mstenth = ms/10;
247	sendMKData(label, address, &mstenth, 1);	249	sendMKData(label, address, &mstenth, 1);
248	// wait until UDR ready	250	// wait until UDR ready
249	while (!(UCSR1A & (1 << UDRE1)));	251	while (!(UCSR1A & (1 << UDRE1)));
250	// disable TXD pin again	252	// disable TXD pin again
251	usart1_DisableTXD();	253	usart1_DisableTXD();
252	}	254	}
-		255
-		256	#endif
253		257

Subversion Repositories Projects

(root)/C-OSD/trunk/usart1.c - Rev 389 → 514