/*
* AntennaControl
*
* Build for use at ETA, http://www.eta.chalmers.se/, controlling their 2 meter quad antenna.
*
* @date 2007-09-22
* @author Erik Larsson
*
*/
#include <inttypes.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <string.h>
#include <avr/eeprom.h>
#include <config.h> // All configuration parameters
#include <bios.h> // BIOS interface declarations, including CAN structure and ID defines.
//#include <drivers/uart/serial.h>
#include <drivers/timer/timer.h>
#define APP_TYPE 0xf0a0
#define APP_VERSION 0x0001
#define AZIMUTH 0
#define ELEVATION 1
#define ROTATE_STOP 0
#define ROTATE_PLUS 1
#define ROTATE_MINUS 2
#define SET 0
#define GET 1
#define CALIBRATE_ELEVATION 0
#define CALIBRATE_AZIMUTH 2
// Make sure this is a power of 2
#define AVERAGE_SIZE 16
#define AVERAGE_SIZE_SHIFT 4
// Essential pins
// 0: PD2 azimuth plus
// 1: PD1 azimuth minus
// 2: PD0 elevation plus
// 3: PD4 elevation minus
// 8: PC4 ADC4 azimuth feedback
// 9: PC5 ADC5 elevation feedback
// A simple message "queue", with space for one message only.
// These are declared volatile to tell the compiler not to optimize away accesses.
volatile Can_Message_t rxMsg; // Message storage
volatile uint8_t rxMsgFull; // Synchronization flag
//uint16_t actualElevationValue;
//uint16_t desiredElevationValue;
//uint16_t actualAzimuthValue;
//uint16_t desiredAzimuthValue;
uint16_t azimuthReadout[ AVERAGE_SIZE ];
uint16_t elevationReadout[ AVERAGE_SIZE ];
// CAN message reception callback.
// This function runs with interrupts disabled, keep it as short as possible.
void can_receive( Can_Message_t *msg ) {
if (!rxMsgFull) {
memcpy((void*)&rxMsg
, msg
, sizeof(rxMsg
)); rxMsgFull = 1;
}
}
// Calibration function
// axis: Elevation / Azimuth
// mode: set / get
// value:
int16_t calibration( uint8_t axis, uint8_t mode, uint16_t value );
// Turn rotors
// axis: Elevation / Azimuth
// position: 0-1024
uint8_t turn( uint8_t axis, uint16_t position );
// Get position
// axis: Elevation / Azimuth
// Gets the average value for compensation of distorsions
uint16_t getPosition( uint8_t axis );
// Read position
// axis: Elevation / Azimuth
// uses two adc
uint16_t readPosition(uint8_t axis);
void changeFeedbackAxis( uint8_t axis );
// Initiate ADC
void initAdcFeedback( void );
// Store result from ADC
void readAdcFeedback( void );
// Control rotation relays
// axis: Elevation / Azimuth
void controlRelay( uint8_t axis, uint8_t direction );
// Timer callback function used for some timer tests
void timer_callback( uint8_t timer ) {
Can_Message_t msg;
msg.ExtendedFlag = 1;
msg.Id = (CAN_TST << CAN_SHIFT_CLASS) | NODE_ID;
msg.RemoteFlag = 0;
msg.DataLength = 1;
msg.Data.bytes[0] = timer;
BIOS_CanSend(&msg);
}
ISR( ADC_vect ) // ADC Conversion Complete
{
}
int main( void )
{
// Enable interrupts as early as possible
sei();
Timer_Init();
// Serial_Init();
// unsigned long time;
Can_Message_t txMsg;
txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) | (NODE_ID << CAN_SHIFT_NMT_SID);
txMsg.DataLength = 4;
txMsg.RemoteFlag = 0;
txMsg.ExtendedFlag = 1;
txMsg.Data.words[0] = APP_TYPE;
txMsg.Data.words[1] = APP_VERSION;
// Set up callback for CAN reception, this is optional if only sending is required.
BIOS_CanCallback = &can_receive;
// Send CAN_NMT_APP_START
BIOS_CanSend(&txMsg);
printf("AVR Test Application\n");
txMsg.Id = (CAN_TST << CAN_SHIFT_CLASS) | NODE_ID;
// txMsg.Data.dwords[0] = 0x01020304;
// txMsg.DataLength = 8;
// Set up three timers (assume at least three has been defined)
// The timeout is specified in ticks, which is equal to ms if
// the tick frequency is set to 1000.
Timer_SetTimeout(0, 10, TimerTypeFreeRunning, 0);
// Timer_SetTimeout(1, 10768, TimerTypeOneShot, &timer_callback);
// Timer_SetTimeout(2, 3141, TimerTypeFreeRunning, &timer_callback);
while (1) {
if (Timer_Expired(0)) {
// ad-omvandla
}
if (rxMsgFull) {
// // Print the received message
// printf("RX: ID=%08lx, DLC=%u, EXT=%u, RTR=%u, data={ ",
// rxMsg.Id,
// (uint16_t)rxMsg.DataLength,
// (uint16_t)rxMsg.ExtendedFlag,
// (uint16_t)rxMsg.RemoteFlag);
// for (uint8_t i=0; i<rxMsg.DataLength; i++) {
// printf("%02x ", rxMsg.Data.bytes[i]);
// }
// printf("}\n");
rxMsgFull = 0; //
}
}
return 0;
}
int16_t calibration( uint8_t axis, uint8_t mode, uint16_t value )
{
// set / get calibration value
if( SET == mode ){
if( ELEVATION == axis ){
eeprom_write_word( CALIBRATE_ELEVATION, value );
}else if( AZIMUTH == axis ){
eeprom_write_word( CALIBRATE_AZIMUTH, value );
}
}else if( GET == mode ){
if( ELEVATION == axis ){
return eeprom_read_word( CALIBRATE_ELEVATION );
}else if( AZIMUTH == axis ){
return eeprom_read_word( CALIBRATE_AZIMUTH );
}
}
return 0;
}
uint8_t turn( uint8_t axis, uint16_t position )
{
// start relay
// read feedback
// callibrate measurement
while(0){
}
return 0;
}
uint16_t getPosition( uint8_t axis )
{
/* uint16_t position = 0;
// Get average value of position
for( uint8_t i ; i < 4 ; i++ ){
position += readPosition( axis );
}
position = (position >> 2);
return position;
*/
return 0;
}
uint16_t readPosition( uint8_t axis )
{
uint16_t averageValue = 0;
uint16_t *measuredAxis;
if( ELEVATION == axis ){
// Calculate elevation value
measuredAxis = elevationReadout;
}else if( AZIMUTH == axis ){
// Calculate aximuth value
measuredAxis = azimuthReadout;
}else{
return 0;
}
for(uint8_t i = 0 ; i<AVERAGE_SIZE ; i++ ){
// Summarize
averageValue += measuredAxis[i];
}
averageValue = averageValue >> AVERAGE_SIZE_SHIFT;
return averageValue;
}
void changeFeedbackAxis( uint8_t axis )
{
if( AZIMUTH == axis ){
// Enable ADC4
ADMUX |= ( 1 << MUX2 );
ADMUX &= ~(( 1 << MUX0 )|( 1 << MUX1 )|( 1 << MUX3 ));
}else if( ELEVATION == axis ){
// Enable ADC5
ADMUX |= ( 1 << MUX0 )|( 1 << MUX2 );
ADMUX &= ~(( 1 << MUX1 )|( 1 << MUX3 ));
}
}
void initAdcFeedback( void )
{
// ADC4: Azimuth feedback
// ADC5: Elevation feedback
// Enable ADC4
ADMUX |= ( 1 << MUX2 );
ADMUX &= ~(( 1 << MUX0 )|( 1 << MUX1 )|( 1 << MUX3 ));
// Prescaler /128
ADCSRA |= ( 1 << ADPS2)|( 1 << ADPS1)|( 1 << ADPS0);
// Enable AVcc as Voltage Reference
ADMUX |= ( 1 << REFS0 );
ADMUX &= ~( 1 << REFS1 );
// Right adjust the result
ADMUX &= ~( 1 << ADLAR );
// Auto Trigger
// ADCSRA |= ( 1 << ADATE );
// Disable digital input
DIDR0 |= ( 1 << ADC5D )|( 1 << ADC4D );
// Wake uo ADC and enable it
PRR &= ~( 1 << PRADC );
ADCSRA |= ( 1 << ADEN );
}
void controlRelay( uint8_t axis, uint8_t direction )
{
if( AZIMUTH == axis ){
if( ROTATE_PLUS == direction ){
PORTD &= ~(1 << PD2);
PORTD |= (1 << PD1);
}else if ( ROTATE_MINUS == direction ){
PORTD &= ~(1 << PD1);
PORTD |= (1 << PD2);
}else{
// stop azimuth rotor
PORTD |= (1 << PD1);
PORTD |= (1 << PD2);
}
}else if( ELEVATION == axis ){
if( ROTATE_PLUS == direction ){
PORTD &= ~(1 << PD0);
PORTD |= (1 << PD4);
}else if ( ROTATE_MINUS == direction ){
PORTD &= ~(1 << PD4);
PORTD |= (1 << PD0);
}else{
// stop elevation rotor
PORTD |= (1 << PD0);
PORTD |= (1 << PD4);
}
}else{
// stop all rotors
PORTD |= (1 << PD0);
PORTD |= (1 << PD1);
PORTD |= (1 << PD2);
PORTD |= (1 << PD4);
}
}
void readAdcFeedback( void )
{
static uint8_t azimuthArrayPosition = 0;
static uint8_t elevationArrayPosition = 0;
static uint8_t lastAxis = AZIMUTH;
while( ADCSRA & (1 << ADSC) ); // Wait for conversion to be done
// Get measurement
if( AZIMUTH == lastAxis ){
azimuthReadout[ azimuthArrayPosition ] = ADCW;
azimuthArrayPosition++;
if( AVERAGE_SIZE <= azimuthArrayPosition ){
azimuthArrayPosition = 0;
}
lastAxis = ELEVATION;
}else if( ELEVATION == lastAxis ){
elevationReadout[ elevationArrayPosition ] = ADCW;
elevationArrayPosition++;
if( AVERAGE_SIZE <= elevationArrayPosition ){
elevationArrayPosition = 0;
}
lastAxis = AZIMUTH;
}
// Next time read other axis
changeFeedbackAxis( lastAxis );
// Start next measurement
ADCSRA |= (1 << ADSC);
}