Subversion Repositories FlightCtrl

 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Copyright (c) 04.2007 Holger Buss

// + only for non-profit use

// + www.MikroKopter.com

// + see the File "License.txt" for further Informations

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/wdt.h>

#include "eeprom.h"

#include "main.h"

#include "menu.h"

#include "timer0.h"

#include "uart.h"

#include "fc.h"

#include "_Settings.h"

#include "rc.h"

#if defined (__AVR_ATmega644__)

#include "ubx.h"

#endif

#define FALSE   0

#define TRUE    1

//int8_t test __attribute__ ((section (".noinit")));

uint8_t DebugGetRequest = 0, DebugDisplayRequest = 0, DebugDataRequest = 0, GetVersionRequest = 0;

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;

uint8_t RemotePollDisplayLine = 0;

uint8_t NurKanalAnforderung = 0;

uint8_t DebugTextAnforderung = 255;

uint8_t PcAccess = 100;

uint8_t MotorTest[4] = {0,0,0,0};

uint8_t DubWiseKeys[4] = {0,0,0,0};

uint8_t MySlaveAddr = 0;

uint8_t ConfirmFrame;

DebugOut_t              DebugOut;

ExternControl_t ExternControl;

VersionInfo_t   VersionInfo;

const uint8_t ANALOG_TEXT[32][16] =

{

   //1234567890123456

    "IntegralPitch   ", //0

    "IntegralRoll    ",

    "AccPitch        ",

    "AccRoll         ",

    "GyroYaw         ",

    "ReadingHight    ", //5

    "AccZ            ",

    "Thrust          ",

    "CompassHeading  ",

    "Voltage         ",

    "Receiver Level  ", //10

    "Analog11        ",

    "GPSDevNorth     ",

    "GPSDevEast      ",

    "GPS_Pitch       ",

    "GPS_Roll        ", //15

    "Acc_Z           ",

    "MeanAccPitch    ",

    "MeanAccRoll     ",

    "IntegralErrPitch",

    "IntegralErrRoll ", //20

    "MeanIntPitch    ",

    "MeanIntRoll         ",

    "NeutralPitch    ",

    "RollOffset      ",

    "IntRoll*Factor  ", //25

    "ReadingGyroPitch",

    "DirectCorrRoll  ",

    "ReadingGyroRoll ",

    "CorrectionRoll  ",

    "I-AttRoll       ", //30

    "StickRoll       "

};

/****************************************************************/

/*              Initialization of the USART0                    */

/****************************************************************/

void USART0_Init (void)

{

        uint8_t sreg = SREG;

        uint16_t ubrr = (uint16_t) ((uint32_t) SYSCLK/(8 * USART0_BAUD) - 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;

        // restore global interrupt flags

    SREG = sreg;

}

/****************************************************************/

/*               USART0 transmitter ISR                         */

/****************************************************************/

ISR(USART0_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

                }

                UDR0 = tmp_tx; // send current byte will trigger this ISR again

        }

        // transmission completed

        else ptr_txd_buffer = 0;

}

/****************************************************************/

/*               USART0 receiver ISR                            */

/****************************************************************/

ISR(USART0_RX_vect)

{

        static uint16_t crc;

        static uint8_t ptr_rxd_buffer = 0;

        uint8_t crc1, crc2;

        uint8_t c;

        c = UDR0;  // catch the received byte

        // If the ATMEGA644 cpu is used the ublox module should be conneced to rxd of the 1st uart.

        // The ATMEGA644p cpu has a 2nd uart to which the ublox is connected.

        #if defined (__AVR_ATmega644__)

        ubx_parser(c);

        #endif

        if(rxd_buffer_locked) return; // if txd 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

        }

        #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

                                // 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

                        }

                        else

                        {       // checksum invalid

                                rxd_buffer_locked = FALSE; // unlock rxd buffer

                        }

                        ptr_rxd_buffer = 0; // reset txd buffer

                }

        } // buffer overrun

        else

        {

                ptr_rxd_buffer = 0; // reset rxd buffer

                rxd_buffer_locked = FALSE; // unlock rxd buffer

        }

}

// --------------------------------------------------------------------------

void AddCRC(uint16_t datalen)

{

 uint16_t tmpCRC = 0,i;

 for(i = 0; i < datalen;i++)

  {

   tmpCRC += txd_buffer[i];

  }

   tmpCRC %= 4096;

   txd_buffer[i++] = '=' + tmpCRC / 64;

   txd_buffer[i++] = '=' + tmpCRC % 64;

   txd_buffer[i++] = '\r';

  txd_complete = 0;

  UDR0 = txd_buffer[0]; // initiates the transmittion

}

// --------------------------------------------------------------------------

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,...)

        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);

        }

        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++] - '=';

                b = rxd_buffer[ptrIn++] - '=';

                c = rxd_buffer[ptrIn++] - '=';

                d = rxd_buffer[ptrIn++] - '=';

                if(ptrIn > max - 2) break;

                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;

        }

}

// --------------------------------------------------------------------------

void ProcessRxData(void)

{

        // if data in the rxd buffer are not locked immediately return

        if(!rxd_buffer_locked) return;

        uint8_t tmp_char_arr2[2]; // local buffer

        PcAccess = 255;

        switch(rxd_buffer[2])

        {

                case 'a':// Labels of the Analog Deboug outputs

                        Decode64((uint8_t *) &tmp_char_arr2[0], sizeof(tmp_char_arr2), 3, ReceivedBytes);

                        DebugTextAnforderung = tmp_char_arr2[0];

                        break;

                case 'b': // extern control

                        Decode64((uint8_t *) &ExternControl,sizeof(ExternControl), 3, ReceivedBytes);

                        RemoteButtons |= ExternControl.RemoteButtons;

                        ConfirmFrame = ExternControl.Frame;

                        break;

                case 'c': // extern control with debug request

                        Decode64((uint8_t *) &ExternControl,sizeof(ExternControl),3,ReceivedBytes);

                        RemoteButtons |= ExternControl.RemoteButtons;

                        ConfirmFrame = ExternControl.Frame;

                        DebugDataRequest = 1;

                        break;

                case 'h':// x-1 display columns

                        Decode64((uint8_t *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,ReceivedBytes);

                        RemoteButtons |= tmp_char_arr2[0];

                        if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1;

                        else NurKanalAnforderung = 0; // keine Displaydaten

                        DebugDisplayRequest = 1;

                        break;

                case 't':// motor test

                        Decode64((uint8_t *) &MotorTest[0],sizeof(MotorTest),3,ReceivedBytes);

                        break;

                case 'k':// keys from DubWise

                        Decode64((uint8_t *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,ReceivedBytes);

                        ConfirmFrame = DubWiseKeys[3];

                        break;

                case 'v': // get version and board release

                        GetVersionRequest = 1;

                        break;

                case 'g':// get debug data

                        DebugGetRequest = 1;

                        break;

                case 'q':// get settings

                        Decode64((uint8_t *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,ReceivedBytes);

                        if(tmp_char_arr2[0] != 0xff)

                        {

                                if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5; // limit to 5

                                // load requested parameter set

                                ParamSet_ReadFromEEProm(tmp_char_arr2[0]);

                                SendOutData('L' + tmp_char_arr2[0] -1,MySlaveAddr,(uint8_t *) &ParamSet.ChannelAssignment[0],PARAMSET_STRUCT_LEN);

                        }

                        else // send active parameter set

                        SendOutData('L' + GetParamByte(PID_ACTIVE_SET)-1,MySlaveAddr,(uint8_t *) &ParamSet.ChannelAssignment[0],PARAMSET_STRUCT_LEN);

                        break;

                case 'l':

                case 'm':

                case 'n':

                case 'o':

                case 'p': // save parameterset

                        Decode64((uint8_t *) &ParamSet.ChannelAssignment[0],PARAMSET_STRUCT_LEN,3,ReceivedBytes);

                        ParamSet_WriteToEEProm(rxd_buffer[2] - 'l' + 1);

                        TurnOver180Pitch = (int32_t) ParamSet.AngleTurnOverPitch * 2500L;

                        TurnOver180Roll = (int32_t) ParamSet.AngleTurnOverRoll * 2500L;

                        Beep(GetActiveParamSet());

                        break;

        }

        // unlock the rxd buffer after processing

        rxd_buffer_locked = FALSE;

}

//############################################################################

//Routine für die Serielle Ausgabe

int16_t uart_putchar (int8_t c)

//############################################################################

{

        if (c == '\n')

                uart_putchar('\r');

        // wait until previous character was send

        loop_until_bit_is_set(UCSR0A, UDRE0);

        //Ausgabe des Zeichens

        UDR0 = c;

        return (0);

}

//---------------------------------------------------------------------------------------------

void TransmitTxData(void)

{

 static int16_t Debug_Timer = 0;

 if(!txd_complete) return;

   if(DebugGetRequest && txd_complete)        // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen

   {

      SendOutData('G',MySlaveAddr,(uint8_t *) &ExternControl,sizeof(ExternControl));

          DebugGetRequest = 0;

   }

    if((CheckDelay(Debug_Timer) || DebugDataRequest) && txd_complete)

         {

          SendOutData('D',MySlaveAddr,(uint8_t *) &DebugOut,sizeof(DebugOut));

          DebugDataRequest = 0;

          Debug_Timer = SetDelay(MIN_DEBUG_INTERVALL);

         }

    if(DebugTextAnforderung != 255) // Texte für die Analogdaten

     {

      SendOutData('A',DebugTextAnforderung + '0',(uint8_t *) ANALOG_TEXT[DebugTextAnforderung],16);

      DebugTextAnforderung = 255;

         }

     if(ConfirmFrame && txd_complete)   // Datensatz ohne CRC bestätigen

         {

      txd_buffer[0] = '#';

      txd_buffer[1] = ConfirmFrame;

      txd_buffer[2] = '\r';

      txd_complete = 0;

      ConfirmFrame = 0;

      UDR0 = txd_buffer[0];

     }

     if(DebugDisplayRequest && txd_complete)

         {

      LCD_PrintMenu();

          DebugDisplayRequest = 0;

      if(++RemotePollDisplayLine == 4 || NurKanalAnforderung)

      {

       SendOutData('4',0,(uint8_t *)&PPM_in,sizeof(PPM_in));   // DisplayZeile übertragen

       RemotePollDisplayLine = -1;

      }

      else  SendOutData('0' + RemotePollDisplayLine,0,(uint8_t *)&DisplayBuff[20 * RemotePollDisplayLine],20);   // DisplayZeile übertragen

         }

    if(GetVersionRequest && txd_complete)

     {

      SendOutData('V',MySlaveAddr,(uint8_t *) &VersionInfo,sizeof(VersionInfo));

          GetVersionRequest = 0;

     }

}