Subversion Repositories FlightCtrl

  SPI_SYNC1,

typedef enum {

// data exchange packets to and From NaviCtrl

// data exchange packets to and From NaviCtrl

ToNaviCtrl_t                    toNaviCtrl;

ToNaviCtrl_t toNaviCtrl;

// rx packet buffer

// rx packet buffer

uint8_t SPITransferCompleted, SPI_ChkSum;

uint8_t SPI_CommandSequence[] = { SPI_CMD_USER, SPI_CMD_STICK, SPI_CMD_PARAMETER1, SPI_CMD_STICK, SPI_CMD_MISC, SPI_CMD_VERSION };

                SPI_CMD_PARAMETER1, SPI_CMD_STICK, SPI_CMD_MISC, SPI_CMD_VERSION };

uint8_t SPI_CommandCounter = 0;

uint8_t SPI_CommandCounter = 0;

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

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

/*  Initialize SPI interface to NaviCtrl     */

/*  Initialize SPI interface to NaviCtrl     */

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

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

void SPI_MasterInit(void) {

void SPI_MasterInit(void) {

  DDR_SPI |= (1<<DD_MOSI)|(1<<DD_SCK);    // Set MOSI and SCK output, all others input

        DDR_SPI |= (1 << DD_MOSI) | (1 << DD_SCK); // Set MOSI and SCK output, all others input

  SLAVE_SELECT_DDR_PORT |= (1 << SPI_SLAVE_SELECT); // set Slave select port as output port

        SLAVE_SELECT_DDR_PORT |= (1 << SPI_SLAVE_SELECT); // set Slave select port as output port

  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(0<<SPR0)|(0<<SPIE);   // Enable SPI, Master, set clock rate fck/64

        SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (0 << SPR0) | (0 << SPIE); // Enable SPI, Master, set clock rate fck/64

  SPSR = 0;//(1<<SPI2X);

        SPSR = 0;//(1<<SPI2X);

  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT); // Deselect Slave

        SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // Deselect Slave

  SPI_TxBuffer = (uint8_t *) &toNaviCtrl; // set pointer to tx-buffer

        SPI_TxBuffer = (uint8_t *) &toNaviCtrl; // set pointer to tx-buffer

  SPITransferCompleted = 1;

        SPITransferCompleted = 1;

  // initialize data packet to NaviControl

        // initialize data packet to NaviControl

  toNaviCtrl.Sync1 = SPI_TXSYNCBYTE1;

        toNaviCtrl.Sync1 = SPI_TXSYNCBYTE1;

  toNaviCtrl.Sync2 = SPI_TXSYNCBYTE2;

        toNaviCtrl.Sync2 = SPI_TXSYNCBYTE2;

  toNaviCtrl.Command = SPI_CMD_USER;

        toNaviCtrl.Command = SPI_CMD_USER;

  toNaviCtrl.IntegralPitch = 0;

        toNaviCtrl.IntegralPitch = 0;

  toNaviCtrl.IntegralRoll = 0;

        toNaviCtrl.IntegralRoll = 0;

  NCSerialDataOkay = 0;

        NCSerialDataOkay = 0;

  NCDataOkay = 0;

        NCDataOkay = 0;

      // disable GPS control

                // disable GPS control

      GPSStickPitch = 0;

                GPSStickRoll = 0;

      GPSStickRoll = 0;

        }

    }

}

}

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

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

/*  Start Transmission of packet to NaviCtrl */

/*  Start Transmission of packet to NaviCtrl */

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

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

void SPI_StartTransmitPacket(void) {

void SPI_StartTransmitPacket(void){

                return; // return immediately if transfer is in progress

  if (!SPITransferCompleted) return; // return immediately if transfer is in progress

        else // transmission was completed

  else // transmission was completed

        {

    {

                SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // Select slave

      SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // Select slave

                // cyclic commands

      // cyclic commands

                toNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];

      toNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];

                if (SPI_CommandCounter >= sizeof(SPI_CommandSequence))

      if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;

                        SPI_CommandCounter = 0;

      SPITransferCompleted = 0; // transfer is in progress

                asm volatile ("nop");

      UpdateSPI_Buffer();    // update data in toNaviCtrl

                asm volatile ("nop");

                asm volatile ("nop");

      SPI_TxBufferIndex = 1; //proceed with 2nd byte

                asm volatile ("nop");

      toNaviCtrl.Chksum = toNaviCtrl.Sync1; // init checksum

                toNaviCtrl.Chksum = toNaviCtrl.Sync1; // init checksum

      SPDR = toNaviCtrl.Sync1; // send first byte

                SPDR = toNaviCtrl.Sync1; // send first byte

    }

        }

}

}

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

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

// Every time this routine is called within the mainloop one byte of the packet to

// This is the spi data transfer between FlightCtrl and NaviCtrl

// the NaviCtrl and one byte of the packet from the NaviCtrl is possible transfered

// Every time this routine is called within the mainloop one byte of the packet to

// the NaviCtrl and one byte of the packet from the NaviCtrl is possible transfered

void SPI_TransmitByte(void) {

        static SPI_RXState_t SPI_RXState = SPI_SYNC1;

void SPI_TransmitByte(void) {

        uint8_t rxdata;

  static SPI_RXState_t SPI_RXState = SPI_SYNC1;

        static uint8_t rxchksum;

  uint8_t rxdata;

  static uint8_t rxchksum;

        if (SPITransferCompleted)

                return; // return immediatly if transfer was completed

  if (SPITransferCompleted) return;  // return immediatly if transfer was completed

        if (!(SPSR & (1 << SPIF)))

  if (!(SPSR & (1 << SPIF))) return; // return if no SPI-IRQ pending

                return; // return if no SPI-IRQ pending

        SendSPI = 4; // mait 4 * 0.102 ms for the next call of SPI_TransmitByte() in the main loop

  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave

        SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave

  rxdata = SPDR; // save spi data register

        rxdata = SPDR; // save spi data register

  switch (SPI_RXState) {

    SPI_RxBufferIndex = 0; // set pointer to start of rx buffer

        switch (SPI_RXState) {

    rxchksum = rxdata; // initialize checksum

        case SPI_SYNC1: // first sync byte

      { // 1st Syncbyte found

                SPI_RxBufferIndex = 0; // set pointer to start of rx buffer

        SPI_RXState  = SPI_SYNC2; // trigger to state for second sync byte

                rxchksum = rxdata; // initialize checksum

      }

                if (rxdata == SPI_RXSYNCBYTE1) { // 1st Syncbyte found

    break;

                        SPI_RXState = SPI_SYNC2; // trigger to state for second sync byte

                }

  case SPI_SYNC2: // second sync byte

                break;

    if (rxdata == SPI_RXSYNCBYTE2)

      { // 2nd Syncbyte found

        case SPI_SYNC2: // second sync byte

        rxchksum += rxdata; // update checksum

                if (rxdata == SPI_RXSYNCBYTE2) { // 2nd Syncbyte found

        SPI_RXState  = SPI_DATA;   // trigger to state for second sync byte

                        rxchksum += rxdata; // update checksum

      }

                        SPI_RXState = SPI_DATA; // trigger to state for second sync byte

    else // 2nd Syncbyte not found

                } else // 2nd Syncbyte not found

      {

                {

        SPI_RXState  = SPI_SYNC1; // jump back to 1st sync byte

                        SPI_RXState = SPI_SYNC1; // jump back to 1st sync byte

      }

                }

    break;

                break;

  case SPI_DATA: // data bytes

        case SPI_DATA: // data bytes

    SPI_RxBuffer[SPI_RxBufferIndex++] = rxdata;  // copy data byte to spi buffer

                SPI_RxBuffer[SPI_RxBufferIndex++] = rxdata; // copy data byte to spi buffer

    // if all bytes are received of a packet from the NaviCtrl

                // if all bytes are received of a packet from the NaviCtrl

    if (SPI_RxBufferIndex >= SPI_RXBUFFER_LEN) {   // last byte transfered is the checksum of the packet

                if (SPI_RxBufferIndex >= SPI_RXBUFFER_LEN) { // last byte transfered is the checksum of the packet

        if (rxdata == rxchksum) { // checksum matching?

                        if (rxdata == rxchksum) { // checksum matching?

            // copy SPI_RxBuffer -> FromFlightCtrl

                                // copy SPI_RxBuffer -> FromFlightCtrl

            uint8_t *ptr = (uint8_t *)&fromNaviCtrl;

                                uint8_t *ptr = (uint8_t *) &fromNaviCtrl;

            cli();

                                cli();

            memcpy(ptr, (uint8_t *) SPI_RxBuffer, sizeof(fromNaviCtrl));

                                memcpy(ptr, (uint8_t *) SPI_RxBuffer, sizeof(fromNaviCtrl));

            sei();

                                sei();

            SPI_RxDataValid = 1;

                                SPI_RxDataValid = 1;

          } else {   // checksum does not match

                        } else { // checksum does not match

            SPI_RxDataValid = 0; // reset valid flag

                                SPI_RxDataValid = 0; // reset valid flag

          }

                asm volatile ("nop");

          SPI_RXState  = SPI_SYNC1; // reset state sync

                asm volatile ("nop");

    } else { // not all bytes transfered

                asm volatile ("nop");

          rxchksum += rxdata; // update checksum

                asm volatile ("nop");

    }

                asm volatile ("nop");

    break;

                asm volatile ("nop");

  }// eof switch(SPI_RXState)

                asm volatile ("nop");

                asm volatile ("nop");

  // if still some bytes left for transmission to NaviCtrl

                asm volatile ("nop");

  if (SPI_TxBufferIndex < SPI_TXBUFFER_LEN) {

                asm volatile ("nop");

      SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave

                asm volatile ("nop");