Subversion Repositories FlightCtrl

Compare Revisions

Ignore whitespace Rev 707 → Rev 708

/trunk/spi.c
2,12 → 2,17
#include "main.h"
 
 
struct str_ToNaviCtrl ToNaviCtrl;
struct str_FromNaviCtrl FromNaviCtrl;
struct str_ToNaviCtrl_Version ToNaviCtrl_Version;
struct str_FromNaviCtrl_Version FromNaviCtrl_Version;
struct str_ToNaviCtrl_Value ToNaviCtrl_Value;
struct str_FromNaviCtrl_Value FromNaviCtrl_Value;
 
unsigned char SPI_BufferIndex;
volatile unsigned char SPI_Buffer[sizeof(FromNaviCtrl)];
unsigned char *Ptr_buffer = (unsigned char *) &ToNaviCtrl;
unsigned char SPI_RxBufferIndex;
 
volatile unsigned char SPI_Buffer[sizeof(FromNaviCtrl_Value)];
unsigned char *SPI_TX_Buffer, *ToNaviCtrl_Chksum;
 
unsigned char SPITransferCompleted, SPI_ChkSum;
#ifdef USE_SPI_COMMUNICATION
 
23,37 → 28,54
SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT);
SPITransferCompleted = 1;
ToNaviCtrl.Sync1 = 0x81;
ToNaviCtrl.Sync2 = 0x55;
//SPDR = 0x00; // dummy write
ToNaviCtrl.Comp = 12;
ToNaviCtrl.IntegralNick = 12345;
ToNaviCtrl.IntegralRoll = 56789;
ToNaviCtrl.StickNick = 100;
ToNaviCtrl.StickRoll = 150;//(char) StickRoll;
ToNaviCtrl.StickGier = 200;//(char) StickGier;
ToNaviCtrl_Value.Sync1 = 0x81;
ToNaviCtrl_Value.Sync2 = 0x55;
ToNaviCtrl_Value.Command = SPI_CMD_VALUE;
ToNaviCtrl_Value.IntegralNick = 12345;
ToNaviCtrl_Value.IntegralRoll = 56789;
ToNaviCtrl_Value.StickNick = 100;
ToNaviCtrl_Value.StickRoll = 150;//(char) StickRoll;
ToNaviCtrl_Value.StickGier = 200;//(char) StickGier;
}
 
//------------------------------------------------------
void SPI_StartTransmitPacket(void)
void SPI_StartTransmitPacket(unsigned char command)
{
//if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return; // transfer of prev. packet not completed
if (!SPITransferCompleted) return;
//if (!(SPSR & (1 << SPIF))) return;
_delay_us(30);
SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
switch(command)
{
case SPI_CMD_VERSION: SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl_Version;
ToNaviCtrl_Chksum = (unsigned char *) &ToNaviCtrl_Version.Chksum;
break;
case SPI_CMD_VALUE: SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl_Value;
ToNaviCtrl_Chksum = (unsigned char *) &ToNaviCtrl_Value.Chksum;
break;
 
}
SPITransferCompleted = 0;
UpdateSPI_Buffer(); // update buffer
SPI_BufferIndex = 1;
DebugOut.Analog[16]++;
//ebugOut.Analog[16]++;
// -- Debug-Output ---
//----
asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
SPDR = ToNaviCtrl.Sync1; // Start transmission
ToNaviCtrl.ChkSum = ToNaviCtrl.Sync1;
SPDR = ToNaviCtrl_Value.Sync1; // Start transmission
*ToNaviCtrl_Chksum = ToNaviCtrl_Value.Sync1;
// SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave
 
}
62,22 → 84,59
//SIGNAL(SIG_SPI)
void SPI_TransmitByte(void)
{
static unsigned char SPI_RXState = 0;
unsigned char rxdata;
static unsigned char rxchksum;
if (SPITransferCompleted) return;
if (!(SPSR & (1 << SPIF))) return;
_delay_us(30);
SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave
if (SPI_BufferIndex < sizeof(FromNaviCtrl))
{
SPI_Buffer[SPI_BufferIndex]= SPDR; // get data
// if (SPI_BufferIndex < 32 ) DebugOut.Analog[26+SPI_BufferIndex] = SPI_Buffer[SPI_BufferIndex];
//if(SPDR!= 0x00) DebugOut.Analog[19]++; ;
}
if (SPI_BufferIndex < sizeof(ToNaviCtrl))
rxdata = SPDR;
switch ( SPI_RXState)
{
case 0:
SPI_RxBufferIndex = 0;
//DebugOut.Analog[17]++;
rxchksum = rxdata;
if (rxdata == 0x81 ) { SPI_RXState = 1; } // 1. Syncbyte ok
break;
 
case 1:
if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState = 2; } // 2. Syncbyte ok
else SPI_RXState = 0;
//DebugOut.Analog[18]++;
break;
case 2:
SPI_Buffer[SPI_RxBufferIndex++]= rxdata; // get data
//DebugOut.Analog[19]++;
if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl_Value))
{
if (rxdata == rxchksum)
{
unsigned char *ptr = (unsigned char *)&FromNaviCtrl_Value;
memcpy(ptr, (unsigned char *) SPI_Buffer, sizeof(SPI_Buffer));
DebugOut.Analog[20]++;
}
else DebugOut.Analog[21]++;
SPI_RXState = 0;
}
else rxchksum += rxdata;
break;
}
if (SPI_BufferIndex < sizeof(ToNaviCtrl_Value))
{
SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
84,100 → 143,32
asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
SPDR = Ptr_buffer[SPI_BufferIndex];
ToNaviCtrl.ChkSum += Ptr_buffer[SPI_BufferIndex];
SPDR = SPI_TX_Buffer[SPI_BufferIndex];
*ToNaviCtrl_Chksum += SPI_TX_Buffer[SPI_BufferIndex];
// SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave
 
}
else
{
unsigned char *ptr = (unsigned char *)&FromNaviCtrl;
SPITransferCompleted = 1;
memcpy(ptr, (unsigned char *) SPI_Buffer, sizeof(SPI_Buffer));
}
else SPITransferCompleted = 1;
SPI_BufferIndex++;
}
 
/*
void SPI_MasterInit(void)
{
DDR_SPI |= (1<<DD_MOSI)|(1<<DD_SCK); // Set MOSI and SCK output, all others input
SLAVE_SELECT_DDR_PORT |= (1 << SPI_SLAVE_SELECT);
SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(0<<SPIE); // Enable SPI, Master, set clock rate fck/64
SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT);
SPITransferCompleted = 1;
ToNaviCtrl.Sync1 = 0x81;
ToNaviCtrl.Sync2 = 0x55;
}
 
//------------------------------------------------------
void SPI_StartTransmitPacket(void)
{
//if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return; // transfer of prev. packet not completed
if (!SPITransferCompleted) return;
SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
SPITransferCompleted = 0;
UpdateSPI_Buffer(); // update buffer
SPI_BufferIndex = 1;
DebugOut.Analog[16]++;
// -- Debug-Output ---
//----
SPDR = ToNaviCtrl.Sync1; // Start transmission
}
 
//------------------------------------------------------
//SIGNAL(SIG_SPI)
void SPI_TransmitByte(void)
{
if (!(SPSR & (1 << SPIF))) return;
SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave
if (SPI_BufferIndex < sizeof(FromNaviCtrl))
{
SPI_Buffer[SPI_BufferIndex]= SPDR; // get data
// if (SPI_BufferIndex < 32 ) DebugOut.Analog[26+SPI_BufferIndex] = SPI_Buffer[SPI_BufferIndex];
//if(SPDR!= 0x00) DebugOut.Analog[19]++; ;
}
if (SPI_BufferIndex < sizeof(ToNaviCtrl))
{
asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave
asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
SPDR = Ptr_buffer[SPI_BufferIndex];
}
else
{
unsigned char *ptr = (unsigned char *)&FromNaviCtrl;
SPITransferCompleted = 1;
memcpy(ptr, (unsigned char *) SPI_Buffer, sizeof(SPI_Buffer));
}
SPI_BufferIndex++;
}
*/
//------------------------------------------------------
void UpdateSPI_Buffer(void)
{
static unsigned char i =0;
cli();
ToNaviCtrl.Comp = SPI_PROTOCOL_COMP;
ToNaviCtrl.IntegralNick = (int) (IntegralNick >> 4);
ToNaviCtrl.IntegralRoll = (int) (IntegralRoll >> 4);
ToNaviCtrl.StickNick = 4;
ToNaviCtrl.StickRoll = 5;//(char) StickRoll;
ToNaviCtrl.StickGier = 6;//(char) StickGier;
ToNaviCtrl_Value.Command = SPI_CMD_VALUE;
ToNaviCtrl_Value.IntegralNick = (int) (IntegralNick >> 4);
ToNaviCtrl_Value.IntegralRoll = (int) (IntegralRoll >> 4);
ToNaviCtrl_Value.StickNick = 4;
ToNaviCtrl_Value.StickRoll = 5;//(char) StickRoll;
ToNaviCtrl_Value.StickGier = 6;//(char) StickGier;
sei();
DebugOut.Analog[30] = FromNaviCtrl_Value.GPS_Nick;
DebugOut.Analog[31] = FromNaviCtrl_Value.GPS_Roll;
}
 
#endif
/trunk/spi.h
2,8 → 2,10
#ifndef _SPI_H
#define _SPI_H
 
//#define USE_SPI_COMMUNICATION
#include <util/delay.h>
 
#define USE_SPI_COMMUNICATION
 
#define SPI_PROTOCOL_COMP 1
 
//-----------------------------------------
47,32 → 49,84
#define SLAVE_SELECT_PORT PORTC
#define SPI_SLAVE_SELECT PC5
 
struct str_ToNaviCtrl
struct str_ToNaviCtrl_Value
{
unsigned char Sync1, Sync2;
unsigned char Comp;
int IntegralNick;
int IntegralRoll;
char StickNick,StickRoll,StickGier;
unsigned char ChkSum;
unsigned char Command;
signed int IntegralNick;
signed int IntegralRoll;
char StickNick,StickRoll,
StickGier, StickGas,
Poti1,Poti2,
Poti3,Poti4;
signed int GyroCompass;
signed int d0;
signed int d1;
unsigned char Chksum;
};
 
struct str_FromNaviCtrl
struct str_ToNaviCtrl_Version
{
unsigned char Sync1, Sync2;
unsigned char Command;
unsigned char HVersion;
unsigned char NVersion;
unsigned char Comp;
unsigned char d0;
signed int d1;
signed int d2;
signed int d3;
signed int d4;
signed int d5;
signed int d6;
signed int d7;
unsigned char Chksum;
};
struct str_FromNaviCtrl_Value
{
unsigned int Dummy;
unsigned char Comp;
int GPS_Nick;
int GPS_Roll;
int CompassValue;
unsigned char Command;
signed int GPS_Nick;
signed int GPS_Roll;
signed int GPS_Gier;
signed int GPS_Height;
signed int CompassValue;
signed int Status;
signed int d0;
signed int d1;
signed int d2;
unsigned char Chksum;
};
 
struct str_FromNaviCtrl_Version
{
unsigned char Command;
unsigned char HVersion;
unsigned char NVersion;
unsigned char Comp;
unsigned char d0;
signed int d1;
signed int d2;
signed int d3;
signed int d4;
signed int d5;
signed int d6;
signed int d7;
unsigned char Chksum;
};
 
#ifdef USE_SPI_COMMUNICATION
extern struct str_ToNaviCtrl ToNaviCtrl;
extern struct str_FromNaviCtrl FromNaviCtrl;
extern struct str_ToNaviCtrl_Version ToNaviCtrl_Version;
extern struct str_FromNaviCtrl_Version FromNaviCtrl_Version;
 
extern struct str_ToNaviCtrl_Value ToNaviCtrl_Value;
extern struct str_FromNaviCtrl_Value FromNaviCtrl_Value;
 
#define SPI_CMD_VERSION 0x02
#define SPI_CMD_VALUE 0x03
 
extern void SPI_MasterInit(void);
extern void SPI_StartTransmitPacket(void);
extern void SPI_StartTransmitPacket(unsigned char command);
extern void UpdateSPI_Buffer(void);
extern void SPI_TransmitByte(void);
#else