WebSVN - MK3Mag - Diff - Rev 18 and 19 - /branches/MK3Mag V0.14 Code Redesign Killagreg/uart.c

 /*#######################################################################################
 MK3Mag 3D-Magnet sensor
 !!! THIS IS NOT FREE SOFTWARE !!!
 #######################################################################################*/
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Copyright (c) 05.2008 Holger Buss
 // + Thanks to Ilja Fähnrich (P_Latzhalter)
 // + Nur für den privaten Gebrauch
 // + www.MikroKopter.com
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
 // + mit unserer Zustimmung zulässig
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
 // + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
 // + AUSNAHME: Ein bei www.mikrokopter.de erworbener vorbestückter MK3Mag darf als Baugruppe auch in kommerziellen Systemen verbaut werden
 // + Im Zweifelsfall bitte anfragen bei: info@mikrokopter.de
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
 // + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
 // + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
 // + eindeutig als Ursprung verlinkt werden
 // + Benutzung auf eigene Gefahr
 // + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Redistributions of source code (with or without modifications) must retain the above copyright notice,
 // + this list of conditions and the following disclaimer.
 // +   * PORTING this software (or parts of it) to systems (other than hardware from www.mikrokopter.de) is NOT allowed
 // +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
 // +     from this software without specific prior written permission.
 // +   * The use of this project (hardware, software, binary files, sources and documentation) is only permittet
 // +     for non-commercial use (directly or indirectly)
 // +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
 // +     with our written permission
 // +     Exception: A preassembled MK3Mag, purchased from www.mikrokopter.de may be used as a part of commercial systems
 // +     In case of doubt please contact: info@MikroKopter.de
 // +   * If sources or documentations are redistributet on other webpages, our webpage (http://www.MikroKopter.de) must be
 // +     clearly linked as origin
 // +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 // +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 // +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 // +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 // +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 // +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 // +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 // +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 // +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // +  POSSIBILITY OF SUCH DAMAGE.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/wdt.h>
 #include "main.h"
 #include "uart.h"
+#include "timer0.h"
+#include "twislave.h"
+#define FALSE   0
+#define TRUE    1
+#define TXD_BUFFER_LEN  100
+#define RXD_BUFFER_LEN  100
+volatile uint8_t txd_buffer[TXD_BUFFER_LEN];
+volatile uint8_t rxd_buffer_locked = FALSE;
+volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];
-#define MAX_SENDE_BUFF     100
+volatile uint8_t txd_complete = TRUE;
-#define MAX_EMPFANGS_BUFF  100
+volatile uint8_t ReceivedBytes = 0;
-unsigned volatile char SIO_Sollwert = 0;
-unsigned volatile char SioTmp = 0;
-unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];
-unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
-unsigned volatile char NeuerDatensatzEmpfangen = 0;
-unsigned volatile char UebertragungAbgeschlossen = 1;
-unsigned char GetVersionAnforderung = 0,DebugTextAnforderung = 0,DebugGetAnforderung = 0, KompassAntwort = 0;
-unsigned char MeineSlaveAdresse;
-unsigned char MotorTest[4] = {0,0,0,0};
-unsigned volatile char AnzahlEmpfangsBytes = 0;
-unsigned char PcZugriff;
+uint8_t RequestVerInfo                  = FALSE;
-struct str_DebugOut       DebugOut;
+uint8_t RequestDebugData                = FALSE;
-struct str_ExternData     ExternData;
+uint8_t RequestDebugLabel               = FALSE;
+uint8_t RequestCompassHeading   = FALSE;
-struct str_ExternControl  ExternControl;
+uint8_t MySlaveAddr = 0;
+//unsigned char,DebugGetAnforderung = 0,
+DebugOut_t              DebugOut;
-struct str_VersionInfo    VersionInfo;
+ExternData_t    ExternData;
 ExternControl_t ExternControl;
 VersionInfo_t   VersionInfo;
-int Debug_Timer;
+uint16_t  Debug_Timer;
-const unsigned char ANALOG_TEXT[32][16] =
+const uint8_t ANALOG_LABEL[32][16] =
 {
    //1234567890123456
-    "Magnet N        ", //0
+    "Magnet X        ", //0
-    "Magnet R        ",
+    "Magnet Y        ",
     "Magnet Z        ",
-    "Raw    N        ",
+    "Raw X           ",
-    "Raw    R        ",
+    "Raw Y           ",
-    "Raw    Z        ", //5
+    "Raw Z           ", //5
-    "Lage N          ",
+    "Attitude Nick   ",
-    "Lage R          ",
+    "Attitude Roll   ",
-    "Xmin            ",
+    "XOffset         ",
-    "Xmax            ",
+    "XRange          ",
-    "Ymin            ", //10
+    "YOffset         ", //10
-    "Ymax            ",
+    "YRange          ",
-    "Zmin            ",
+    "ZOffset         ",
-    "ZMax            ",
+    "ZRange          ",
     "Calstate        ",
-    "Kompass         ", //15
+    "Heading Request ", //15
     "User0           ",
     "User1           ",
     "Analog18        ",
     "Analog19        ",
     "Analog20        ", //20
     "Analog30        ", //30
     "Analog31        "
 };
+/****************************************************************/
+/*              Initialization of the USART0                    */
+/****************************************************************/
+void USART0_Init (void)
+{
+        uint8_t sreg = SREG;
+        uint16_t ubrr = (uint16_t) ((uint32_t) SYSCLK/(8 * BAUD_RATE) - 1);
+        // disable all interrupts before configuration
+        cli();
+        // disable RX-Interrupt
+        UCSR0B &= ~(1 << RXCIE0);
+        // disable TX-Interrupt
+        UCSR0B &= ~(1 << TXCIE0);
+        // set direction of RXD0 and TXD0 pins
+        // set RXD0 (PD0) as an input pin
+        PORTD |= (1 << PORTD0);
+        DDRD  &= ~(1 << DDD0);
+        // set TXD0 (PD1) as an output pin
+        PORTD |= (1 << PORTD1);
+        DDRD  |= (1 << DDD1);
+        // USART0 Baud Rate Register
+        // set clock divider
+        UBRR0H = (uint8_t)(ubrr >> 8);
+        UBRR0L = (uint8_t)ubrr;
+        // USART0 Control and Status Register A, B, C
+        // enable double speed operation in
+        UCSR0A |= (1 << U2X0);
+        // enable receiver and transmitter in
+        UCSR0B |= (1 << TXEN0) | (1 << RXEN0);
+        // set asynchronous mode
+        UCSR0C &= ~(1 << UMSEL01);
+        UCSR0C &= ~(1 << UMSEL00);
+        // no parity
+        UCSR0C &= ~(1 << UPM01);
+        UCSR0C &= ~(1 << UPM00);
+        // 1 stop bit
+        UCSR0C &= ~(1 << USBS0);
+        // 8-bit
+        UCSR0B &= ~(1 << UCSZ02);
+        UCSR0C |=  (1 << UCSZ01);
+        UCSR0C |=  (1 << UCSZ00);
+        // flush receive buffer
+        while ( UCSR0A & (1<<RXC0) ) UDR0;
+        // enable interrupts at the end
+        // enable RX-Interrupt
+        UCSR0B |= (1 << RXCIE0);
+        // enable TX-Interrupt
+        UCSR0B |= (1 << TXCIE0);
+        rxd_buffer_locked = FALSE;
+        txd_complete = TRUE;
+        Debug_Timer = SetDelay(200);
+        // restore global interrupt flags
+    SREG = sreg;
+        VersionInfo.Major = VERSION_MAJOR;
+        VersionInfo.Minor = VERSION_MINOR;
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//++ Sende-Part der Datenübertragung
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-SIGNAL(INT_VEC_TX)
-{
- static unsigned int ptr = 0;
- unsigned char tmp_tx;
+    VersionInfo.PCCompatible = VERSION_COMPATIBLE;
- if(!UebertragungAbgeschlossen)
-  {
-   ptr++;                    // die [0] wurde schon gesendet
-   tmp_tx = SendeBuffer[ptr];
+    // Version beim Start ausgeben (nicht schön, aber geht... )
-   if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
-    {
-     ptr = 0;
-     UebertragungAbgeschlossen = 1;
-    }
-   UDR = tmp_tx;
+        uart_putchar ('\n');uart_putchar ('C');uart_putchar ('P');uart_putchar (':');
+        uart_putchar ('V');uart_putchar (0x30 + VERSION_MAJOR);uart_putchar ('.');uart_putchar (0x30 + VERSION_MINOR/10); uart_putchar (0x30 + VERSION_MINOR%10);
-  }
+    uart_putchar ('\n');
-  else ptr = 0;
+}
-}
-void SendUart(void)
-{
- static unsigned int ptr = 0;
- unsigned char tmp_tx;
- if(!(USR & 0x40)) return;
- if(!UebertragungAbgeschlossen)
+// ---------------------------------------------------------------------------------
-  {
-   ptr++;                    // die [0] wurde schon gesendet
-   tmp_tx = SendeBuffer[ptr];
-   if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
-    {
-     ptr = 0;
-     UebertragungAbgeschlossen = 1;
-    }
-   USR |= (1<TXC0);
+void USART0_EnableTXD(void)
-   UDR = tmp_tx;
+{
-  }
+        DDRD |= (1<<DDD1);              // set TXD pin as output
-  else ptr = 0;
+        UCSR0B |= (1 << TXEN0);         // enable TX in USART
-}
-// --------------------------------------------------------------------------
-void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max)  // Wohin mit den Daten; Wie lang; Wo im RxdBuffer
-{
- unsigned char a,b,c,d;
- unsigned char ptr = 0;
- unsigned char x,y,z;
- while(len)
-  {
-   a = RxdBuffer[ptrIn++] - '=';
-   b = RxdBuffer[ptrIn++] - '=';
+}
-   c = RxdBuffer[ptrIn++] - '=';
-   d = RxdBuffer[ptrIn++] - '=';
-   if(ptrIn > max - 2) break;     // nicht mehr Daten verarbeiten, als empfangen wurden
-   x = (a << 2) | (b >> 4);
-   y = ((b & 0x0f) << 4) | (c >> 2);
-   z = ((c & 0x03) << 6) | d;
-   if(len--) ptrOut[ptr++] = x; else break;
+// ---------------------------------------------------------------------------------
+void USART0_DisableTXD(void)
+{
+        UCSR0B &= ~(1 << TXEN0);        // disable TXD in USART
+        DDRD &= ~(1<<DDD1);             // set TXD pin as input
+}
+/****************************************************************/
+/*               USART0 transmitter ISR                         */
+/****************************************************************/
+ISR(USART_TX_vect)
+{
+        static uint16_t ptr_txd_buffer = 0;
+        uint8_t tmp_tx;
+        if(!txd_complete) // transmission not completed
+        {
+                ptr_txd_buffer++;                    // die [0] wurde schon gesendet
+                tmp_tx = txd_buffer[ptr_txd_buffer];
+                // if terminating character or end of txd buffer was reached
+                if((tmp_tx == '\r') || (ptr_txd_buffer == TXD_BUFFER_LEN))
+                {
+                        ptr_txd_buffer = 0; // reset txd pointer
+                        txd_complete = 1; // stop transmission
-   if(len--) ptrOut[ptr++] = y; else break;
+                }
-   if(len--) ptrOut[ptr++] = z; else break;
+                UDR0 = tmp_tx; // send current byte will trigger this ISR again
-  }
+        }
+        // transmission completed
-}
+        else ptr_txd_buffer = 0;
+}
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+/****************************************************************/
-//++ Empfangs-Part der Datenübertragung
+/*               USART0 receiver ISR                            */
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+/****************************************************************/
-SIGNAL(INT_VEC_RX)
-{
+ISR(USART_RX_vect)
+{
- static unsigned int crc;
+        static uint16_t crc;
- static unsigned char crc1,crc2,buf_ptr;
+        static uint8_t ptr_rxd_buffer = 0;
- static unsigned char UartState = 0;
- unsigned char CrcOkay = 0;
+        uint8_t crc1, crc2;
+        uint8_t c;
- SioTmp = UDR;
- if(buf_ptr >= MAX_EMPFANGS_BUFF)    UartState = 0;
+        c = UDR0;  // catch the received byte
- if(SioTmp == '\r' && UartState == 2)
+        if(rxd_buffer_locked) return; // if rxd buffer is locked immediately return
-  {
-   UartState = 0;
-   crc -= RxdBuffer[buf_ptr-2];
+        // the rxd buffer is unlocked
-   crc -= RxdBuffer[buf_ptr-1];
+        if((ptr_rxd_buffer == 0) && (c == '#')) // if rxd buffer is empty and syncronisation character is received
-   crc %= 4096;
+        {
-   crc1 = '=' + crc / 64;
+                rxd_buffer[ptr_rxd_buffer++] = c; // copy 1st byte to buffer
+                crc = c; // init crc
-   crc2 = '=' + crc % 64;
+        }
-   CrcOkay = 0;
+        #if 0
-   if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; };
-   if(CrcOkay) // Datensatz schon verarbeitet
+        else if (ptr_rxd_buffer == 1) // handle address
+        {
-    {
+                rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
+                crc += c; // update crc
+        }
-     NeuerDatensatzEmpfangen = 1;
+        #endif
-         AnzahlEmpfangsBytes = buf_ptr;
+        else if (ptr_rxd_buffer < RXD_BUFFER_LEN) // collect incomming bytes
-     RxdBuffer[buf_ptr] = '\r';
+        {
-         if((RxdBuffer[2] == 'R')) wdt_enable(WDTO_250MS); // Reset-Commando
-//     uart_putchar(RxdBuffer[2]);
+                if(c != '\r') // no termination character
+                {
-        }
+                        rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
-  }
+                        crc += c; // update crc
+                }
-  else
+                else // termination character was received
-  switch(UartState)
+                {
-  {
+                        // the last 2 bytes are no subject for checksum calculation
-   case 0:
+                        // they are the checksum itself
-          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
+                        crc -= rxd_buffer[ptr_rxd_buffer-2];
-                  buf_ptr = 0;
+                        crc -= rxd_buffer[ptr_rxd_buffer-1];
-                  RxdBuffer[buf_ptr++] = SioTmp;
-                  crc = SioTmp;
+                        // calculate checksum from transmitted data
-          break;
+                        crc %= 4096;
-   case 1: // Adresse auswerten
+                        crc1 = '=' + crc / 64;
-                  UartState++;
+                        crc2 = '=' + crc % 64;
-                  RxdBuffer[buf_ptr++] = SioTmp;
+                        // compare checksum to transmitted checksum bytes
-                  crc += SioTmp;
+                        if((crc1 == rxd_buffer[ptr_rxd_buffer-2]) && (crc2 == rxd_buffer[ptr_rxd_buffer-1]))
-                  break;
+                        {   // checksum valid
-   case 2: //  Eingangsdaten sammeln
+                                rxd_buffer_locked = TRUE;          // lock the rxd buffer
+                                ReceivedBytes = ptr_rxd_buffer;    // store number of received bytes
+                                rxd_buffer[ptr_rxd_buffer] = '\r'; // set termination character
+                                // if 2nd byte is an 'R' enable watchdog that will result in an reset
+                                if(rxd_buffer[2] == 'R') {wdt_enable(WDTO_250MS);} // Reset-Commando
+                        }
-                  RxdBuffer[buf_ptr] = SioTmp;
+                        else
-                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
+                        {       // checksum invalid
+                                rxd_buffer_locked = FALSE; // unlock rxd buffer
+                        }
-                  else UartState = 0;
+                        ptr_rxd_buffer = 0; // reset rxd buffer pointer
-                  crc += SioTmp;
+                }
                   break;
-   default:
+        else // rxd buffer overrun
           UartState = 0;
-          break;
+                ptr_rxd_buffer = 0; // reset rxd buffer
-  }
+                rxd_buffer_locked = FALSE; // unlock rxd buffer
+        }
-};
+}
 // --------------------------------------------------------------------------
-void AddCRC(unsigned int wieviele)
+void AddCRC(uint16_t datalen)
 {
- unsigned int tmpCRC = 0,i;
+        uint16_t tmpCRC = 0, i;
- for(i = 0; i < wieviele;i++)
+        for(i = 0; i < datalen; i++)
+        {
+                tmpCRC += txd_buffer[i];
    tmpCRC += SendeBuffer[i];
-  }
+        tmpCRC %= 4096;
-   tmpCRC %= 4096;
+        txd_buffer[i++] = '=' + tmpCRC / 64;
-   SendeBuffer[i++] = '=' + tmpCRC / 64;
+        txd_buffer[i++] = '=' + tmpCRC % 64;
-   SendeBuffer[i++] = '=' + tmpCRC % 64;
+        txd_buffer[i++] = '\r';
-   SendeBuffer[i++] = '\r';
+        txd_complete = FALSE;
-  UebertragungAbgeschlossen = 0;
+        UDR0 = txd_buffer[0]; // initiates the transmission (continued in the TXD ISR)
-  UDR = SendeBuffer[0];
+}
-}
 // --------------------------------------------------------------------------
-void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)
+void SendOutData(uint8_t cmd,uint8_t module, uint8_t *snd, uint8_t len)
 {
- unsigned int pt = 0;
+        uint16_t pt = 0;
- unsigned char a,b,c;
+        uint8_t a,b,c;
- unsigned char ptr = 0;
+        uint8_t ptr = 0;
- SendeBuffer[pt++] = '#';               // Startzeichen
+        txd_buffer[pt++] = '#';         // Start character
- SendeBuffer[pt++] = modul;             // Adresse (a=0; b=1,...)
+        txd_buffer[pt++] = module;      // Address (a=0; b=1,...)
- SendeBuffer[pt++] = cmd;                       // Commando
+        txd_buffer[pt++] = cmd;         // Command
- while(len)
+        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;
-   SendeBuffer[pt++] = '=' + (a >> 2);
-   SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
-   SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
-   SendeBuffer[pt++] = '=' + ( c & 0x3f);
-  }
- AddCRC(pt);
-}
-//############################################################################
-//Routine für die Serielle Ausgabe
-int uart_putchar (char c)
 //############################################################################
-{
+                if(len) { a = snd[ptr++]; len--;} else a = 0;
-    if(!(UCR & (1 << TXEN))) return (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);
+        }
+        AddCRC(pt); // add checksum after data block and initates the transmission
+}
+// --------------------------------------------------------------------------
+void Decode64(uint8_t *ptrOut, uint8_t len, uint8_t ptrIn, uint8_t max)
+{
+        uint8_t a,b,c,d;
+        uint8_t ptr = 0;
+        uint8_t x,y,z;
+        while(len)
+        {
+                a = rxd_buffer[ptrIn++] - '=';
-        if (c == '\n')
+                b = rxd_buffer[ptrIn++] - '=';
+                c = rxd_buffer[ptrIn++] - '=';
-                uart_putchar('\r');
+                d = rxd_buffer[ptrIn++] - '=';
-        //Warten solange bis Zeichen gesendet wurde
+                if(ptrIn > max - 2) break;
-        loop_until_bit_is_set(USR, UDRE);
-        //Ausgabe des Zeichens
         UDR = c;
+                x = (a << 2) | (b >> 4);
+                y = ((b & 0x0f) << 4) | (c >> 2);
+                z = ((c & 0x03) << 6) | d;
+                if(len--) ptrOut[ptr++] = x; else break;
+                if(len--) ptrOut[ptr++] = y; else break;
+                if(len--) ptrOut[ptr++] = z; else break;
+        }
+}
-        return (0);
-}
-// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
-void WriteProgramData(unsigned int pos, unsigned char wert)
+int16_t uart_putchar (int8_t c)
+{
-{
+        // if tx is not enabled return immediatly
-}
+        if(!(UCSR0B & (1 << TXEN0))) return (0);
+        if (c == '\n') uart_putchar('\r');
-//############################################################################
+        // wait until previous character was send
-//INstallation der Seriellen Schnittstelle
+        loop_until_bit_is_set(UCSR0A, UDRE0);
-void UART_Init (void)
+        // send character
-//############################################################################
+        UDR0 = c;
-{
-        //Enable TXEN im Register UCR TX-Data Enable & RX Enable
-        UCR=(1 << TXEN) | (1 << RXEN);
+        return (0);
-    // UART Double Speed (U2X)
+}
+// --------------------------------------------------------------------------
+void USART0_ProcessRxData(void)
+{
-        USR   |= (1<<U2X);
-        // RX-Interrupt Freigabe
-        UCSRB |= (1<<RXCIE);    // serieller Empfangsinterrupt
-        // TX-Interrupt Freigabe
-        UCSRB |= (1<<TXCIE);
-        //Teiler wird gesetzt
-        UBRR= (SYSCLK / (BAUD_RATE * 8L) -1 );
-        //öffnet einen Kanal für printf (STDOUT)
-//      fdevopen (uart_putchar, NULL);
-    Debug_Timer = SetDelay(200);
-    // Version beim Start ausgeben (nicht schön, aber geht... )
-        uart_putchar ('\n');uart_putchar ('C');uart_putchar ('P');uart_putchar (':');
-        uart_putchar ('V');uart_putchar (0x30 + VERSION_HAUPTVERSION);uart_putchar ('.');uart_putchar (0x30 + VERSION_NEBENVERSION/10); uart_putchar (0x30 + VERSION_NEBENVERSION%10);
-    uart_putchar ('\n');
-}
-void BearbeiteRxDaten(void)
-{
- if(!NeuerDatensatzEmpfangen) return;
-// unsigned int tmp_int_arr1[1];
-// unsigned int tmp_int_arr2[2];
-// unsigned int tmp_int_arr3[3];
- unsigned char tmp_char_arr2[2];
-// unsigned char tmp_char_arr3[3];
-// unsigned char tmp_char_arr4[4];
- //if(!MotorenEin)
- PcZugriff = 255;
+        // if data in the rxd buffer are not locked immediately return
-  switch(RxdBuffer[2])
-  {
+        if(!rxd_buffer_locked) return;
    case 'w':// Lagewinkel
-            Decode64((unsigned char *) &ExternData,sizeof(ExternData),3,AnzahlEmpfangsBytes);
-            DebugOut.Analog[15]++;
-            KompassAntwort = 1;
-            break;
-   case 'c':
-   case 'b':
-                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
-            ExternData.Winkel[0] = ExternControl.Par1;
-            ExternData.Winkel[1] = ExternControl.Par2;
+        uint8_t tmp_char_arr2[2]; // local char buffer
-            break;
-   case 'v': // Version-Anforderung     und Ausbaustufe
-            GetVersionAnforderung = 1;
-            PC_Connected = 255;
-            break;
-   case 'a':// Texte der Analogwerte
-            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
+        switch(rxd_buffer[2])
-            DebugTextAnforderung = tmp_char_arr2[0];
-            PC_Connected = 255;
-                        break;
-   case 'g':// "Get"-Anforderung für Debug-Daten
-            // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
-            PC_Connected = 255;
-            DebugGetAnforderung = 1;
-            break;
+        {
-   case 'h':// x-1 Displayzeilen
+           case 'w':// Attitude
+                        Decode64((uint8_t *) &ExternData, sizeof(ExternData), 3, ReceivedBytes);
-            PC_Connected = 255;
+                        DebugOut.Analog[15]++;
-            break;
+                        RequestCompassHeading = TRUE;
+                        break;
-/*
+                case 'b': // extern control
+                case 'c': // extern control with debug request
-   case 'b':
+                        Decode64((uint8_t *) &ExternControl,sizeof(ExternControl), 3,ReceivedBytes);
-                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
+                        ExternData.Attitude[0] = ExternControl.Par1;
-                        RemoteTasten |= ExternControl.RemoteTasten;
+            ExternData.Attitude[1] = ExternControl.Par2;
-            ConfirmFrame = ExternControl.Frame;
+                        break;
-            break;
-   case 'c':
-                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
-                        RemoteTasten |= ExternControl.RemoteTasten;
-            ConfirmFrame = ExternControl.Frame;
-            DebugDataAnforderung = 1;
-            break;
-   case 'h':// x-1 Displayzeilen
-            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
-            RemoteTasten |= tmp_char_arr2[0];
-                        if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten
-                        DebugDisplayAnforderung = 1;
-                        break;
-   case 't':// Motortest
-            Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);
-                        break;
-   case 'k':// Keys von DubWise
-            Decode64((unsigned char *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,AnzahlEmpfangsBytes);
-                        ConfirmFrame = DubWiseKeys[3];
-                        break;
-   case 'q':// "Get"-Anforderung für Settings
-            // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
-            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
-            if(tmp_char_arr2[0] != 0xff)
-             {
-                          if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;
-                  ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
-                  SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
-             }
-             else
+                case 'h':// x-1 display columns
-                  SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
+                        PC_Connected = 255;
                         break;
-            break;
+                case 'v': // get version and board release
+                        RequestVerInfo = TRUE;
-   case 'l':
+                        PC_Connected = 255;
-   case 'm':
-   case 'n':
-   case 'o':
+                        break;
-   case 'p': // Parametersatz speichern
-            Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
-                        WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
-            eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1);  // aktiven Datensatz merken
-            Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
-            Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
-            Piep(GetActiveParamSetNumber());
+                case 'a':// Labels of the Analog Debug outputs
-         break;
+                        Decode64((uint8_t *) &tmp_char_arr2[0], sizeof(tmp_char_arr2), 3, ReceivedBytes);
-*/
+                        RequestDebugLabel = tmp_char_arr2[0];
+                        PC_Connected = 255;
-  }
-// DebugOut.AnzahlZyklen =  Debug_Timer_Intervall;
+                        break;
- NeuerDatensatzEmpfangen = 0;
-}
-//---------------------------------------------------------------------------------------------
+                case 'g':// get debug data
-void DatenUebertragung(void)
-{
- if((CheckDelay(Debug_Timer) && UebertragungAbgeschlossen))      // im Singlestep-Betrieb in jedem Schtitt senden
-         {
-         SetDebugValues();
-          SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
+                        RequestDebugData = TRUE;
-          Debug_Timer = SetDelay(250);   // Sendeintervall
+                        PC_Connected = 255;
+                        break;
+        }
+        // unlock the rxd buffer after processing
+        rxd_buffer_locked = FALSE;
+}
+//---------------------------------------------------------------------------------------------
+void USART0_TransmitTxData(void)
+{
+        if(!(UCSR0B & (1 << TXEN0))) return;
+        if(!txd_complete) return;
+    if(CheckDelay(Debug_Timer) && txd_complete)
+    {
+                SetDebugValues();
+                SendOutData('D',MySlaveAddr,(uint8_t *) &DebugOut,sizeof(DebugOut));
+                Debug_Timer = SetDelay(250);
+    }
+    if(RequestDebugLabel != 255)
+    {

Subversion Repositories MK3Mag

(root)/branches/MK3Mag V0.14 Code Redesign Killagreg/uart.c - Rev 18 → 19