Subversion Repositories HomeAutomation

/**

 * AntennaControl

 *

 * Build for use at ETA, http://www.eta.chalmers.se/, controlling their 2 meter yagi antenna.

 *

 * @date 2007-10-28

 * @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/timer/timer.h>

#define APP_TYPE    0xf0a0

#define APP_VERSION 0x0001

#define AZIMUTH 0

#define ROTATE_STOP 0

#define ROTATE_PLUS 1

#define ROTATE_MINUS 2

#define SET 0

#define GET 1

#define CALIBRATE_AZIMUTH 0 // EEPROM adress

// Make sure this is a power of 2

#define AVERAGE_SIZE 16

#define AVERAGE_SIZE_SHIFT 4

// Tillfälliga defines

#define MSG_CAL_SET 0x0100001UL

#define MSG_CAL_GET 0x0100002UL

#define MSG_ABS 0x01000031UL

#define MSG_REL 0x0100004UL

#define MSG_START 0x0100005UL

#define MSG_STOP 0x0100006UL

#define MSG_STATUS 0x0100007UL

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

// Essential pins

// 0: PD2 azimuth plus

// 1: PD1 azimuth minus 

// 8: PC4 ADC4 azimuth 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;

// For calculating average feedback measurement

uint16_t azimuthReadout[ AVERAGE_SIZE ];

//uint16_t elevationReadout[ AVERAGE_SIZE];

uint16_t azimuthCalibration;

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

// mode: set / get

// value:

int16_t calibration( uint8_t mode, uint16_t value );

// Turn rotor

// position: 0-1024

uint8_t turn( uint16_t position );

// Get position

// Gets the average value for compensation of distorsions

uint16_t getPosition( void );

// Initiate ADC

void initAdcFeedback( void );

// Read antenna feedback from ADC

void readFeedback( void );

// Control rotation relays

void controlRelay( uint8_t direction );

// Sends antennas position on CAN

void sendStatus( void );

int main( void )

{

    // Enable interrupts as early as possible

    sei();

    Timer_Init();

    // Setup ADC

    initAdcFeedback();

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

    // Read calibration value from eeprom

    azimuthCalibration = eeprom_read_word( CALIBRATE_AZIMUTH );

    // Timer for reading position feedback

    Timer_SetTimeout(0, 50, TimerTypeFreeRunning, 0);

    while (1) {

        if (Timer_Expired(0)) {

            // Periodicly read antennas position

            readFeedback();

        }

        if (rxMsgFull) {

            switch (rxMsg.Id){

                case MSG_CAL_SET: // Set calibration value

                    if( 2 == rxMsg.DataLength ){

                        calibration( SET, rxMsg.Data.words[0] );

                    }

                    break;

                case MSG_CAL_GET: // Get calibration value

                    if( 0 == rxMsg.DataLength ){

                    }

                    break;

                case MSG_ABS: // Start turning to absolute position

                    if( 2 == rxMsg.DataLength ){

                    }

                    break;

                case MSG_REL: // Start turning to relative position

                    if( 2 == rxMsg.DataLength ){

                    }

                    break;

                case MSG_START: // Start turning

                    if( 1 == rxMsg.DataLength ){

                        // First data byte decides direction

                        controlRelay( rxMsg.Data.bytes[0] );

                    }

                    break;

                case MSG_STOP: // Stop turning

                    if( 1 == rxMsg.DataLength ){

                        controlRelay( ROTATE_STOP );

                    }

                    break;

                case MSG_STATUS: // Get position

                    if( 0 == rxMsg.DataLength ){

                        sendStatus();

                    }

                    break;

                default:

                    break;

            }

            rxMsgFull = 0; //  

        }

    }

    return 0;

}

int16_t calibration( uint8_t mode, uint16_t value )

{

    // set / get calibration value

    if( SET == mode ){

        eeprom_write_word( CALIBRATE_AZIMUTH, value );

        azimuthCalibration = value;

    }else if( GET == mode ){

        return azimuthCalibration;

    }

    return 0;

}

uint8_t turn( uint16_t position )

{

    // start relay

    // read feedback

    // callibrate measurement

    while(0){

    }

    return 0;

}

uint16_t getPosition( void )

{

    uint16_t position = 0;

    // Get average value of position

    for( uint8_t i=0; i < AVERAGE_SIZE; i++ ){

        position += azimuthReadout[i];

    }

    position = position >> AVERAGE_SIZE_SHIFT;

    position += azimuthCalibration;

    return position;

}

void initAdcFeedback( void )

{

    // ADC4: Azimuth 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 up ADC and enable it

    PRR &= ~( 1 << PRADC );

    ADCSRA |= ( 1 << ADEN );

    // Start first conversion

    ADCSRA |= ( 1 << ADSC );

}

void controlRelay( uint8_t direction )

{

    if( ROTATE_PLUS == direction ){ // Turn clockwise

        PORTD &= ~(1 << PD2);

        PORTD |= (1 << PD1);

    }else if ( ROTATE_MINUS == direction ){ // Turn counter clockwise

        PORTD &= ~(1 << PD1);

        PORTD |= (1 << PD2);

    }else{

        // Stop azimuth rotor

        PORTD |= (1 << PD1);

        PORTD |= (1 << PD2);

    }

}

void readFeedback( void )

{

    static uint8_t azimuthArrayPosition = 0;

    while( ADCSRA & ( 1 << ADSC )){} // Wait for conversion to complete

    azimuthReadout[ azimuthArrayPosition ] = ADCW;

    azimuthArrayPosition++;

    if( AVERAGE_SIZE <= azimuthArrayPosition ){

        azimuthArrayPosition = 0;

    }

    // Start next conversion

    ADCSRA |= ( 1 << ADSC );

}

void sendStatus( void )

{

    Can_Message_t txMsg;

    txMsg.Id = 0x01fff00UL; //(( CAN_SNS << CAN_SHIFT_CLASS )|( SNS_TYPE_STATUS << CAN_SHIFT_SNS_TYPE )|( SNS_ID_ANTENNA_STATUS << CAN_SHIFT_SNS_ID )|( NODE_ID << CAN_SHIFT_SNS_SID );

    txMsg.DataLength = 2;

    txMsg.RemoteFlag = 0;

    txMsg.ExtendedFlag = 1;

    txMsg.Data.words[ 0 ] = getPosition();

    BIOS_CanSend( &txMsg );

}