WebSVN - MK3Mag - Diff - Rev 17 and 32

 /*#######################################################################################
 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
+// keep buffers as small as possible
+#define TXD_BUFFER_LEN  100
+#define RXD_BUFFER_LEN  30
+volatile uint8_t txd_buffer[TXD_BUFFER_LEN];
+volatile uint8_t rxd_buffer_locked = FALSE;
+volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];
+volatile uint8_t txd_complete = TRUE;
+volatile uint8_t ReceivedBytes = 0;
+#define VERSION_INFO    0x01
+#define DEBUG_DATA              0x02
+#define DEBUG_LABEL             0x04
+#define COMPASS_HEADING 0x08
-#define MAX_SENDE_BUFF     100
+uint8_t RequestFlags = 0x00;
-#define MAX_EMPFANGS_BUFF  100
-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;
+uint8_t RequestDebugLabel = 0;
-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;
-struct str_DebugOut       DebugOut;
-struct str_ExternData     ExternData;
+uint8_t PC_Connected = 0;
-struct str_ExternControl  ExternControl;
+uint8_t FC_Connected = 0;
+uint8_t MySlaveAddr = 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        ",
+    "RawMagnet X     ",
-    "Raw    R        ",
+    "RawMagnet Y     ",
-    "Raw    Z        ", //5
+    "RawMagnet Z     ", //5
-    "Angle N         ",
+    "Attitude Nick   ",
-    "Angle R         ",
+    "Attitude Roll   ",
-    "Xmin            ",
+    "Magnet X Offset ",
-    "Xmax            ",
+    "Magnet X Range  ",
-    "Ymin            ", //10
+    "Magnet Y Offset ", //10
-    "Ymax            ",
+    "Magnet Y Range  ",
-    "Zmin            ",
+    "Magnet Z Offset ",
-    "ZMax            ",
+    "Magnet Z Range  ",
-    "Compass         ",
+    "Calstate        ",
-    "Calstate        ", //15
+    "Heading         ", //15
     "User0           ",
     "User1           ",
-    "AccN            ",
+    "Acc X           ",
-    "AccR            ",
+    "Acc Y           ",
-    "AccZ            ", //20
+    "Acc Z           ", //20
-    "RawAccN         ",
+    "RawAcc X        ",
-    "RawAccR         ",
+    "RawAcc Y        ",
-    "RawAccZ         ",
+    "RawAcc Z        ",
-    "OffsetAccN      ",
+    "Acc X Offset    ",
-    "OffsetAccR      ", //25
+    "Acc Y Offset    ", //25
-    "OffsetAccZ      ",
+    "Acc Z Offset    ",
+    "Analog27        ",
+    "Analog28        ",
+    "Analog29        ",
+    "I2C Error       ", //30
+    "I2C Okay        "
+};
+/****************************************************************/
+/*              Initialization of the USART0                    */
+/****************************************************************/
+void USART0_Init (void)
+{
+        uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(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 tristate
+        DDRD  &= ~(1 << DDD0);
+        PORTD &= ~(1 << PORTD0);
+        // set TXD0 (PD1) as an output pin
+        DDRD  |= (1 << DDD1);
+        PORTD &= ~(1 << PORTD1);
+        // 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
+        UCSR0A |= (1 << U2X0);
+        // 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);
+        // enable receiver and transmitter
+        UCSR0B |= (1 << RXEN0);
+        UCSR0B |= (1 << TXEN0);
+        // flush receive buffer
+        while ( UCSR0A & (1<<RXC0) ) UDR0;
+        // enable RX-Interrupt
+        UCSR0B |= (1 << RXCIE0);
+        // enable TX-Interrupt
+        UCSR0B |= (1 << TXCIE0);
+        rxd_buffer_locked = FALSE;
+        txd_complete = TRUE;
+        VersionInfo.Major = VERSION_MAJOR;
+        VersionInfo.Minor = VERSION_MINOR;
+    VersionInfo.PCCompatible = VERSION_COMPATIBLE;
+    // Version beim Start ausgeben (nicht schön, aber geht... )
+        USART0_putchar ('\n');
+        USART0_putchar ('C');
+        USART0_putchar ('P');
-    "Analog27        ",
+        USART0_putchar (':');
-    "Analog28        ",
+        USART0_putchar ('V');
+        USART0_putchar (0x30 + VERSION_MAJOR);
+        USART0_putchar ('.');
-    "Analog29        ",
+        USART0_putchar (0x30 + VERSION_MINOR/10);
+        USART0_putchar (0x30 + VERSION_MINOR%10);
+    USART0_putchar ('\n');
+}
+// ---------------------------------------------------------------------------------
-    "Analog30        ", //30
+void USART0_EnableTXD(void)
+{
+        DDRD |= (1<<DDD1);                      // set TXD pin as output
+        PORTD &= ~(1 << PORTD1);
+        UCSR0B |= (1 << TXEN0);         // enable TX in USART
+        UCSR0B |= (1 << TXCIE0);        // disable TX-Interrupt
+}
+// ---------------------------------------------------------------------------------
+void USART0_DisableTXD(void)
+{
+        while(!txd_complete){ };
+        UCSR0B &= ~(1 << TXCIE0);   // disable TX-Interrupt
-    "Analog31        "
+        UCSR0B &= ~(1 << TXEN0);        // disable TXD in USART
-};
+        DDRD &= ~(1<<DDD1);             // set TXD pin as input
+        PORTD &= ~(1 << PORTD1);
+}
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+/****************************************************************/
-//++ Sende-Part der Datenübertragung
+/*               USART0 transmitter ISR                         */
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+/****************************************************************/
+ISR(USART_TX_vect)
-SIGNAL(INT_VEC_TX)
+{
-{
+        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 = TRUE; // stop transmission
+                }
+                UDR0 = tmp_tx; // send current byte will trigger this ISR again
+        }
+        // transmission completed
+        else ptr_txd_buffer = 0;
+}
- static unsigned int ptr = 0;
- unsigned char tmp_tx;
+/****************************************************************/
+/*               USART0 receiver ISR                            */
+/****************************************************************/
+ISR(USART_RX_vect)
+{
+        static uint16_t crc;
+        uint8_t crc1, crc2;
+        uint8_t c;
+        static uint8_t ptr_rxd_buffer = 0;
+        c = UDR0;  // catch the received byte
+        if(rxd_buffer_locked) return; // if rxd buffer is locked immediately return
+        // the rxd buffer is unlocked
+        if((ptr_rxd_buffer == 0) && (c == '#')) // if rxd buffer is empty and syncronisation character is received
+        {
+                rxd_buffer[ptr_rxd_buffer++] = c; // copy 1st byte to buffer
+                crc = c; // init crc
+        }
+        #if 0
+        else if (ptr_rxd_buffer == 1) // handle address
+        {
+                rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
+                crc += c; // update crc
- if(!UebertragungAbgeschlossen)
+        }
+        #endif
+        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_locked = TRUE;          // lock the rxd buffer
+                                ReceivedBytes = ptr_rxd_buffer;    // store number of received bytes
+                                rxd_buffer[ptr_rxd_buffer] = '\r'; // set termination character
-   ptr++;                    // die [0] wurde schon gesendet
+                                // 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
-   tmp_tx = SendeBuffer[ptr];
+                        }
+                        else
+                        {       // checksum invalid
+                                rxd_buffer_locked = FALSE; // unlock rxd buffer
+                        }
-   if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
+                        ptr_rxd_buffer = 0; // reset rxd buffer pointer
-    {
-     ptr = 0;
-     UebertragungAbgeschlossen = 1;
-    }
-   UDR = tmp_tx;
-  }
-  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;
+        else // rxd buffer overrun
-    }
-   USR |= (1<TXC0);
+        {
-   UDR = tmp_tx;
+                ptr_rxd_buffer = 0; // reset rxd buffer
-  }
-  else ptr = 0;
+                rxd_buffer_locked = FALSE; // unlock rxd buffer
-}
-// --------------------------------------------------------------------------
-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++] - '=';
+void AddCRC(uint16_t datalen)
-   b = RxdBuffer[ptrIn++] - '=';
+{
-   c = RxdBuffer[ptrIn++] - '=';
+        uint16_t tmpCRC = 0, i;
-   d = RxdBuffer[ptrIn++] - '=';
-   if(ptrIn > max - 2) break;     // nicht mehr Daten verarbeiten, als empfangen wurden
         for(i = 0; i < datalen; i++)
-   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;
-  }
-}
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//++ Empfangs-Part der Datenübertragung
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-SIGNAL(INT_VEC_RX)
-{
- static unsigned int crc;
- static unsigned char crc1,crc2,buf_ptr;
- static unsigned char UartState = 0;
- unsigned char CrcOkay = 0;
- SioTmp = UDR;
- if(buf_ptr >= MAX_EMPFANGS_BUFF)    UartState = 0;
- if(SioTmp == '\r' && UartState == 2)
-  {
-   UartState = 0;
-   crc -= RxdBuffer[buf_ptr-2];
-   crc -= RxdBuffer[buf_ptr-1];
-   crc %= 4096;
-   crc1 = '=' + crc / 64;
-   crc2 = '=' + crc % 64;
-   CrcOkay = 0;
-   if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; };
-   if(CrcOkay) // Datensatz schon verarbeitet
-    {
-     NeuerDatensatzEmpfangen = 1;
-         AnzahlEmpfangsBytes = buf_ptr;
-     RxdBuffer[buf_ptr] = '\r';
-         if((RxdBuffer[2] == 'R')) wdt_enable(WDTO_250MS); // Reset-Commando
-//     uart_putchar(RxdBuffer[2]);
-        }
-  }
-  else
-  switch(UartState)
-  {
-   case 0:
-          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet
-                  buf_ptr = 0;
-                  RxdBuffer[buf_ptr++] = SioTmp;
-                  crc = SioTmp;
-          break;
-   case 1: // Adresse auswerten
-                  UartState++;
-                  RxdBuffer[buf_ptr++] = SioTmp;
-                  crc += SioTmp;
-                  break;
-   case 2: //  Eingangsdaten sammeln
                   RxdBuffer[buf_ptr] = SioTmp;
-                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
+                tmpCRC += txd_buffer[i];
                   else UartState = 0;
-                  crc += SioTmp;
+        tmpCRC %= 4096;
+        txd_buffer[i++] = '=' + tmpCRC / 64;
-                  break;
+        txd_buffer[i++] = '=' + tmpCRC % 64;
-   default:
+        txd_buffer[i++] = '\r';
+        txd_complete = FALSE;
+        UDR0 = txd_buffer[0]; // initiates the transmission (continued in the TXD ISR)
-          UartState = 0;
+}
-          break;
-  }
+// --------------------------------------------------------------------------
+void SendOutData(uint8_t cmd,uint8_t module, uint8_t *snd, uint8_t len)
-};
+{
+        uint16_t pt = 0;
+        uint8_t a,b,c;
+        uint8_t ptr = 0;
+        txd_buffer[pt++] = '#';         // Start character
-// --------------------------------------------------------------------------
+        txd_buffer[pt++] = module;      // Address (a=0; b=1,...)
-void AddCRC(unsigned int wieviele)
+        txd_buffer[pt++] = cmd;         // Command
- unsigned int tmpCRC = 0,i;
+        while(len)
  for(i = 0; i < wieviele;i++)
+                if(len) { a = snd[ptr++]; len--;} else a = 0;
-  {
+                if(len) { b = snd[ptr++]; len--;} else b = 0;
-   tmpCRC += SendeBuffer[i];
+                if(len) { c = snd[ptr++]; len--;} else c = 0;
-  }
+                txd_buffer[pt++] = '=' + (a >> 2);
-   tmpCRC %= 4096;
+                txd_buffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
+                txd_buffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
-   SendeBuffer[i++] = '=' + tmpCRC / 64;
+                txd_buffer[pt++] = '=' + ( c & 0x3f);
-   SendeBuffer[i++] = '=' + tmpCRC % 64;
+        }
-   SendeBuffer[i++] = '\r';
+        AddCRC(pt); // add checksum after data block and initates the transmission
+}
-  UebertragungAbgeschlossen = 0;
-  UDR = SendeBuffer[0];
-}
+// --------------------------------------------------------------------------
+void Decode64(uint8_t *ptrOut, uint8_t len, uint8_t ptrIn, uint8_t max)
+{
-// --------------------------------------------------------------------------
+        uint8_t a,b,c,d;
-void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)
+        uint8_t ptr = 0;
-{
- unsigned int pt = 0;
- unsigned char a,b,c;
+        uint8_t x,y,z;
- unsigned char ptr = 0;
+        while(len)
  SendeBuffer[pt++] = '#';               // Startzeichen
- SendeBuffer[pt++] = modul;             // Adresse (a=0; b=1,...)
- SendeBuffer[pt++] = cmd;                       // Commando
+                a = rxd_buffer[ptrIn++] - '=';
- while(len)
+                b = rxd_buffer[ptrIn++] - '=';
-  {
-   if(len) { a = snd[ptr++]; len--;} else a = 0;
+                c = rxd_buffer[ptrIn++] - '=';
+                d = rxd_buffer[ptrIn++] - '=';
-   if(len) { b = snd[ptr++]; len--;} else b = 0;
+                if(ptrIn > max - 2) break;
-   if(len) { c = snd[ptr++]; len--;} else c = 0;
-   SendeBuffer[pt++] = '=' + (a >> 2);
-   SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
+                x = (a << 2) | (b >> 4);
-   SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
+                y = ((b & 0x0f) << 4) | (c >> 2);
-   SendeBuffer[pt++] = '=' + ( c & 0x3f);
+                z = ((c & 0x03) << 6) | d;
-  }
- AddCRC(pt);
                 if(len--) ptrOut[ptr++] = x; else break;
                 if(len--) ptrOut[ptr++] = y; else break;
+                if(len--) ptrOut[ptr++] = z; else break;
+        }
+}
 //############################################################################
-//Routine für die Serielle Ausgabe
+// --------------------------------------------------------------------------
-int uart_putchar (char c)
-//############################################################################
-{
+int16_t USART0_putchar (int8_t c)
-    if(!(UCR & (1 << TXEN))) return (0);
-        if (c == '\n')
-                uart_putchar('\r');
-        //Warten solange bis Zeichen gesendet wurde
-        loop_until_bit_is_set(USR, UDRE);
-        //Ausgabe des Zeichens
-        UDR = c;
-        return (0);
-}
-// --------------------------------------------------------------------------
-void WriteProgramData(unsigned int pos, unsigned char wert)
-{
-}
-void UART_InterruptEnable(void)
-{
-        UCSRB |= (1<<RXCIE);    // serieller Empfangsinterrupt
-        // TX-Interrupt Freigabe
-        UCSRB |= (1<<TXCIE);
-}
-//############################################################################
-//INstallation der Seriellen Schnittstelle
+{
+        // if tx is not enabled return immediatly
+        if(!(UCSR0B & (1 << TXEN0))) return (0);
+        if (c == '\n') USART0_putchar('\r');
+        // wait until previous character was send
+        loop_until_bit_is_set(UCSR0A, UDRE0);
+        // send character
+        UDR0 = c;
+        return (0);
-void UART_Init (void)
+}
-//############################################################################
-{
-        //Enable TXEN im Register UCR TX-Data Enable & RX Enable
+// --------------------------------------------------------------------------
+void USART0_ProcessRxData(void)
-        UCR=(1 << TXEN) | (1 << RXEN);
+{
-    // UART Double Speed (U2X)
+        // if data in the rxd buffer are not locked immediately return
-        USR   |= (1<<U2X);
+        if(!rxd_buffer_locked) return;
-        //Teiler wird gesetzt
+        uint8_t tmp_char_arr2[2]; // local char buffer
-        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... )
+        switch(rxd_buffer[2])
-        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)
+           case 'w':// Attitude
-{
- if(!NeuerDatensatzEmpfangen) return;
+                        Decode64((uint8_t *) &ExternData, sizeof(ExternData), 3, ReceivedBytes);
-// unsigned int tmp_int_arr1[1];
+                        RequestFlags |= COMPASS_HEADING;
-// unsigned int tmp_int_arr2[2];
-// unsigned int tmp_int_arr3[3];
- unsigned char tmp_char_arr2[2];
-// unsigned char tmp_char_arr3[3];
+                        AttitudeSource = ATTITUDE_SOURCE_UART;
-// unsigned char tmp_char_arr4[4];
+                        Orientation = ExternData.Orientation;
- //if(!MotorenEin)
+                        FC_Connected = 255;
- PcZugriff = 255;
-  switch(RxdBuffer[2])
+                        break;
-   case 'w':// Lagewinkel
-            Decode64((unsigned char *) &ExternData,sizeof(ExternData),3,AnzahlEmpfangsBytes);
-            DebugOut.Analog[15]++;
-            KompassAntwort = 1;
-            AngleSource = 2;
-            break;
-   case 'c':
-   case 'b':
-                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
+                case 'b': // extern control
-//            ExternData.Winkel[0] = ExternControl.Par1;
-//            ExternData.Winkel[1] = ExternControl.Par2;
-            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);
-            DebugTextAnforderung = tmp_char_arr2[0];
-            PC_Connected = 255;
+                case 'c': // extern control with debug request
-                        break;
-   case 'g':// "Get"-Anforderung für Debug-Daten
+                        Decode64((uint8_t *) &ExternControl,sizeof(ExternControl), 3,ReceivedBytes);
-            // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
-            PC_Connected = 255;
+                        #define KEY1    0x01
-            DebugGetAnforderung = 1;
+                        #define KEY2    0x02
+                        #define KEY3    0x04
-            break;
+                        #define KEY4    0x08
-   case 'h':// x-1 Displayzeilen
+                        #define KEY5    0x10
+                        // use right arrow at display for switching the calstate
+                        if(ExternControl.RemoteButtons & KEY2)
+                        {
-            PC_Connected = 255;
+                                ExternData.CalState++;
+                                if(ExternData.CalState == 6) ExternData.CalState = 0;
-            break;
+                        }
-/*
+                        //ExternData.Attitude[0] = ExternControl.Par1;
-   case 'b':
+            //ExternData.Attitude[1] = ExternControl.Par2;
-                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
+            PC_Connected = 255;
-                        RemoteTasten |= ExternControl.RemoteTasten;
-            ConfirmFrame = ExternControl.Frame;
-            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);
+                        break;
-                  SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
-             }
+                case 'h':// x-1 display columns
-             else
+                        PC_Connected = 255;
+                        break;
                   SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
+                case 'v': // get version and board release
-            break;
+                        RequestFlags |= VERSION_INFO;
+                        PC_Connected = 255;
-   case 'l':
+                        break;
-   case 'm':
-   case 'n':
-   case 'o':
-   case 'p': // Parametersatz speichern
+                case 'a':// Labels of the Analog Debug outputs
-            Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
+                        Decode64((uint8_t *) &tmp_char_arr2[0], sizeof(tmp_char_arr2), 3, ReceivedBytes);
-                        WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
+                        RequestDebugLabel = tmp_char_arr2[0];
+                        RequestFlags |= DEBUG_LABEL;
-            eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1);  // aktiven Datensatz merken
+                        PC_Connected = 255;
-            Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
+                        break;
-            Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
+                case 'g':// get debug data
-            Piep(GetActiveParamSetNumber());
+                        RequestFlags |= DEBUG_DATA;
-         break;
+                        PC_Connected = 255;
-*/
+                        break;
+        }
+        // unlock the rxd buffer after processing
-  }
+        rxd_buffer_locked = FALSE;
+}
-// DebugOut.AnzahlZyklen =  Debug_Timer_Intervall;
- NeuerDatensatzEmpfangen = 0;
-}
+//---------------------------------------------------------------------------------------------
+void USART0_TransmitTxData(void)
+{
-//---------------------------------------------------------------------------------------------
+        if(!(UCSR0B & (1 << TXEN0))) return;
-void DatenUebertragung(void)
+        if(!txd_complete) return;
-{
- if((CheckDelay(Debug_Timer) && UebertragungAbgeschlossen))      // im Singlestep-Betrieb in jedem Schtitt senden
+    if(CheckDelay(Debug_Timer))
-         {
-          SetDebugValues();
+    {
-          SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
+                SetDebugValues();
-          Debug_Timer = SetDelay(250);   // Sendeintervall
+                SendOutData('D',MySlaveAddr,(uint8_t *) &DebugOut,sizeof(DebugOut));
-         }
+                Debug_Timer = SetDelay(250);
-    if(GetVersionAnforderung && UebertragungAbgeschlossen)
-     {
+    }
-      SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
-          GetVersionAnforderung = 0;
-     }
+    if(RequestFlags & DEBUG_LABEL)
     if(DebugTextAnforderung != 255) // Texte für die Analogdaten
+                SendOutData('A',RequestDebugLabel + '0',(uint8_t *) ANALOG_LABEL[RequestDebugLabel],16);
+                RequestDebugLabel = 255;
+                RequestFlags &= ~DEBUG_LABEL;
+        }
+        if(RequestFlags & VERSION_INFO)
+    {
+                SendOutData('V',MySlaveAddr,(uint8_t *) &VersionInfo, sizeof(VersionInfo));
+                RequestFlags &= ~VERSION_INFO;

Subversion Repositories MK3Mag

(root)/tags/V0.21b/uart.c @ 62 - Rev 17 → 32