Subversion Repositories NaviCtrl

Rev

Rev 23 | Blame | Compare with Previous | Last modification | View Log | RSS feed

/*#######################################################################################*/
/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */
/*#######################################################################################*/
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 2008 Ingo Busker, Holger Buss
// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
// + FOR NON COMMERCIAL USE ONLY
// + www.MikroKopter.com
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + 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.
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
// + bzgl. der Nutzungsbedingungen aufzunehmen.
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
// + Verkauf von Luftbildaufnahmen, usw.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + 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
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
// + Benutzung auf eigene Gefahr
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
// + mit unserer Zustimmung zulässig
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + 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.
// +   * 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 permitted
// +     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
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
// +     clearly linked as origin
// +   * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
//
// +  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 "main.h"

struct str_FromFlightCtrl   FromFlightCtrl;
struct str_ToFlightCtrl     ToFlightCtrl;

struct str_ToFlightCtrl     SPI_TxBuffer;

volatile unsigned char      SPI_Buffer[sizeof(FromFlightCtrl)];
volatile unsigned char      SPI_BufferIndex = 0;
volatile unsigned char      SPI_TXBufferIndex = 0;

s16 CompassValue;

volatile struct str_MicroMag  MicroMag;

#define SPI_COMMAND_INDEX 0
unsigned char *Ptr_buffer_Tx = (unsigned char *) &SPI_TxBuffer;
//unsigned char *Ptr_buffer_Tx = (unsigned char *) &ToFlightCtrl;
unsigned char *Ptr_buffer_Rx = (unsigned char *) &FromFlightCtrl;
volatile unsigned char SPI_state = 0, SPI_TXUpdatebufferRequest = 0, SPI_RXUpdatebufferRequest = 0;

unsigned char SPI_CommandSequence[] = { SPI_CMD_OSD_DATA, SPI_CMD_GPS_POS, SPI_CMD_GPS_TARGET};
unsigned char SPI_CommandCounter = 0;


//--------------------------------------------------------------
void SSP0_IRQHandler(void)
{
 static u8 chksum = 0;
 u8 data;
 
 GPIO_ToggleBit(GPIO5, GPIO_Pin_7);
 SSP_ClearITPendingBit(SSP0, SSP_IT_RxTimeOut);
 
 while (SSP_GetFlagStatus(SSP0, SSP_FLAG_TxFifoNotFull) == SET)
 {
    if (SPI_TXBufferIndex  < sizeof(ToFlightCtrl))   // still data to send ?  
    { SSP0->DR = Ptr_buffer_Tx[SPI_TXBufferIndex];
      SPI_TxBuffer.Chksum += Ptr_buffer_Tx[SPI_TXBufferIndex];    
          SPI_TXBufferIndex++;  
    }
    else    
    {
      SPI_TXBufferIndex = 0;
          SPI_TXUpdatebufferRequest = 1;
          ToFlightCtrl.Chksum = 0;  
      ToFlightCtrl.BeepTime = BeepTime;
          BeepTime = 0;
          memcpy((unsigned char *) &SPI_TxBuffer, (unsigned char *)     &ToFlightCtrl, sizeof(ToFlightCtrl));
   }
 }
 
 while (SSP_GetFlagStatus(SSP0, SSP_FLAG_RxFifoNotEmpty)==SET)
 {

  data =  SSP0->DR;

   while (SSP_GetFlagStatus(SSP0, SSP_FLAG_TxFifoNotFull) == SET)
 {
     if (SPI_TXBufferIndex  < sizeof(ToFlightCtrl))   // still data to send ?  
     { SSP0->DR = Ptr_buffer_Tx[SPI_TXBufferIndex];
       SPI_TxBuffer.Chksum += Ptr_buffer_Tx[SPI_TXBufferIndex];    
           SPI_TXBufferIndex++;  
     }
     else
     {
       SPI_TXBufferIndex = 0;
           ToFlightCtrl.Chksum = 0;  
           SPI_TXUpdatebufferRequest = 1;
       ToFlightCtrl.BeepTime = BeepTime;
           BeepTime = 0;
           memcpy((unsigned char *) &SPI_TxBuffer, (unsigned char *)    &ToFlightCtrl, sizeof(ToFlightCtrl));
         }

 }  
  switch (SPI_state )
  {
   case 0:
                        SPI_BufferIndex = 0;
                       
                        chksum = data;  
                        if (data == 0xAA && !SPI_RXUpdatebufferRequest)  { SPI_state  = 1;  }   // 1. Syncbyte ok
                       
           break;

   case 1:
                    if (data == 0x83) { chksum += data; SPI_state  = 2;  }   // 2. Syncbyte ok
                 else SPI_state  = 0;      
                       
           break;
   
   case 2:
                   SPI_Buffer[SPI_BufferIndex++]= data;             // get data
 
                   if (SPI_BufferIndex >= sizeof(SPI_Buffer))           // end of packet
                   {  
                if (data == chksum)
                        {
                          u8 i;
              SPI_RXUpdatebufferRequest = 1;
                  for (i=0;i<sizeof(SPI_Buffer);i++) { Ptr_buffer_Rx[i] = SPI_Buffer[i]; }

                          DebugOut.Analog[13]++;
                        }
                         else { DebugOut.Analog[12]++; }
                       
                        SPI_state  = 0;  
                   }
                 else chksum += data;
    break;

        default: SPI_state  = 0;  break;
  }
 }
 
 
 
}

//--------------------------------------------------------------
void SPI0_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  SSP_InitTypeDef   SSP_InitStructure;

  SerialPutString("SPI init...");
 
  SCU_APBPeriphClockConfig(__GPIO2 ,ENABLE);
  SCU_APBPeriphClockConfig(__SSP0 ,ENABLE);
   
  GPIO_DeInit(GPIO2);
  //SSP0_CLK, SSP0_MOSI, SSP0_SS pins
  GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
  GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable;
  GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1  ;
  GPIO_Init (GPIO2, &GPIO_InitStructure);

  // SSP0_MISO pin GPIO2.6
  GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
  GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable;
  GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2  ;
  GPIO_Init (GPIO2, &GPIO_InitStructure);
 
  SSP_DeInit(SSP0);
  SSP_StructInit(&SSP_InitStructure);
  SSP_InitStructure.SSP_FrameFormat = SSP_FrameFormat_Motorola;
  SSP_InitStructure.SSP_Mode = SSP_Mode_Slave;
  SSP_InitStructure.SSP_SlaveOutput = SSP_SlaveOutput_Enable;
  SSP_InitStructure.SSP_CPHA = SSP_CPHA_1Edge;
  SSP_InitStructure.SSP_CPOL = SSP_CPOL_Low;
  SSP_InitStructure.SSP_ClockRate = 0;
 
  SSP_Init(SSP0, &SSP_InitStructure);
 
  SSP_ITConfig(SSP0, SSP_IT_RxFifo | SSP_IT_TxFifo | SSP_IT_RxTimeOut, ENABLE);
 
  SSP_Cmd(SSP0, ENABLE);

  ToFlightCtrl.Sync1 = 0x81;
  ToFlightCtrl.Sync2 = 0x55;
   
  VIC_Config(SSP0_ITLine, VIC_IRQ, 1);
  VIC_ITCmd(SSP0_ITLine, ENABLE);  

  SerialPutString("ok\n\r");
 
 
}

//------------------------------------------------------
void SPI_CheckSlaveSelect(void)
{

 //if (SS_PIN)  { SPI_BufferIndex = 0;  }
 
   DebugOut.Analog[0] = FromFlightCtrl.IntegralNick;
   DebugOut.Analog[1] = FromFlightCtrl.IntegralRoll;
   DebugOut.Analog[2] = (30*FromFlightCtrl.AccNick)/108;
   DebugOut.Analog[3] = (30*FromFlightCtrl.AccRoll)/108;

/* DebugOut.Analog[2] = FromFlightCtrl.StickNick;
 DebugOut.Analog[3] = FromFlightCtrl.Command;
 DebugOut.Analog[4] = FromFlightCtrl.StickRoll;
 DebugOut.Analog[5] = FromFlightCtrl.StickGier;
 */

 DebugOut.Analog[25] = FromFlightCtrl.GyroCompass;

}
//------------------------------------------------------
void UpdateSPI_Buffer(void)
{
   if (SPI_RXUpdatebufferRequest)
   {
     if (CompassUpdateActiv) return;  // testweise deaktiviert

          VIC_ITCmd(SSP0_ITLine, DISABLE);  

          ToFlightCtrl.CompassValue = I2C_Heading.Heading;
          ToFlightCtrl.GPS_Nick = GPS_Nick;
          ToFlightCtrl.GPS_Roll = GPS_Roll;
      DebugOut.Analog[26] = I2C_Heading.Heading;

      ToFlightCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];
      if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;
 
          switch (ToFlightCtrl.Command)
          {
            case  SPI_CMD_OSD_DATA:
                                  ToFlightCtrl.Param.Byte[0] = OsdBar;
                                  ToFlightCtrl.Param.Int[1]  = OsdDistance;
                  break;

            case  SPI_CMD_GPS_POS:
                                  ToFlightCtrl.Param.Long[0]  = GPS_Data.Longitude;
                                  ToFlightCtrl.Param.Long[1]  = GPS_Data.Latitude;
                  break;

            case  SPI_CMD_GPS_TARGET:
                                  ToFlightCtrl.Param.Long[0]  = GPS_Data.TargetLongitude;
                                  ToFlightCtrl.Param.Long[1]  = GPS_Data.TargetLatitude;
                  break;

                default:
                  break;
          }
          VIC_ITCmd(SSP0_ITLine, ENABLE);  

         if (I2C_Heading.Heading <= 359)
         {
         }    
         else
         {
           if (I2C_Version.Hauptversion != 0xff) TimerCompassUpdate = SetDelay(1);
           return;
         }

         SPI_TXUpdatebufferRequest = 0;

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

//      DebugOut.Analog[11] = FromFlightCtrl.Command;
         switch(FromFlightCtrl.Command)
         {
           case SPI_CMD_USER:
           DebugOut.Analog[7]++;
                                    Parameter_UserParam1 = FromFlightCtrl.Param.Byte[0];
                                    Parameter_UserParam2 = FromFlightCtrl.Param.Byte[1];
                                    Parameter_UserParam3 = FromFlightCtrl.Param.Byte[2];
                                    Parameter_UserParam4 = FromFlightCtrl.Param.Byte[3];
                                    Parameter_UserParam5 = FromFlightCtrl.Param.Byte[4];
                                    Parameter_UserParam6 = FromFlightCtrl.Param.Byte[5];
                                    Parameter_UserParam7 = FromFlightCtrl.Param.Byte[6];
             break;
       case SPI_CMD_STICK:
           DebugOut.Analog[8]++;
                                    FC_StickGas  = (s32) FromFlightCtrl.Param.sByte[0];
                                    FC_StickGier = (s32) FromFlightCtrl.Param.sByte[1];
                                        FC_StickNick = (s32) FromFlightCtrl.Param.sByte[2];
                                    FC_StickRoll = (s32) FromFlightCtrl.Param.sByte[3];
                                    FC_Poti1     = (s32) FromFlightCtrl.Param.Byte[4];
                                    FC_Poti2     = (s32) FromFlightCtrl.Param.Byte[5];
                                        FC_Poti3         = (s32) FromFlightCtrl.Param.Byte[6];
                                    FC_Poti4     = (s32) FromFlightCtrl.Param.Byte[7];
                                        SenderOkay       = (s32) FromFlightCtrl.Param.Byte[8];
             break;

                case SPI_CMD_CAL_COMPASS:
                DebugOut.Analog[9]++;
                                        CompassCalState =  FromFlightCtrl.Param.Byte[0];
                 break;

       default:
             break;
         }


   //------------
    I2C_WriteNickRoll.Roll = FromFlightCtrl.IntegralRoll;
    I2C_WriteNickRoll.Nick = FromFlightCtrl.IntegralNick;

        Navigation();

    SPI_RXUpdatebufferRequest = 0;
  }  
}