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 STATUS 0

#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 0x11100001UL

#define MSG_CAL_GET 0x11100002UL

#define MSG_ABS 0x111000031UL

#define MSG_REL 0x11100004UL

#define MSG_START 0x11100005UL

#define MSG_STOP 0x11100006UL

#define MSG_STATUS 0x11100007UL

#define MSG_CAL_RET 0x111000f2UL

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

// 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 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( uint8_t type );

int main( void )

{

    // Enable interrupts as early as possible

    sei();

    Timer_Init();

    // Set as outputs and stop rotor

    DDRD |= (1 << PD1)|(1 << PD2);

    PORTD &= ~((1 << PD1)|(1 << PD2));

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

    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, 100, TimerTypeFreeRunning, 0);

    Timer_SetTimeout(1, 1000, TimerTypeFreeRunning, 0);

    sendStatus( STATUS );

    while (1) {

        if (Timer_Expired(0)) {

            // Periodicly read antennas position

            readFeedback();

        }

        if (Timer_Expired(1)) {

            sendStatus(STATUS);

        }

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

                        txMsg.Id = MSG_CAL_RET;

                        txMsg.DataLength = 2;

                        txMsg.Data.words[0] = calibration( GET, 0 );

                        BIOS_CanSend(&txMsg);

                    }

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

                    }

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

    }

    // Calculate average

    position = position >> AVERAGE_SIZE_SHIFT;

    // Convert to degrees, gives about 361 degrees

    // start 508, stop 1023 => 516 bits per rotation

    // 516 * 7 / 10 = 361

    // Antennen rör sig inom 180 -> 360 (=0) -> 180

    // Norr = mittläget = 0 / 360 grader = 766 decimalt innan omräkning

    // Söder = ändlägena = 180 grader = 508 och 1023 innan omräkning

    // Make it between 508 and 1023

    if( position < 508 ){

        position = 0;

    }else{

        position -= 508;

    }

//  if( 0x8000&position ){

//      position = -position;

//      position *= 7;

//      position /= 10;

//      //position = -position;

//  }else{

        // Make it between 0 and 360

        position *= 7;

        position /= 10;

//  }

    // Move it to 180 and 540

    position += 180;

    // Calibrate

    position += (int16_t)azimuthCalibration;

    // North is now at 360

    if( position > 360 ){

        // Antenna is between 0 and 180

        position -= 360;

    }

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

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

        PORTD |= (1 << PD2);

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

        PORTD &= ~(1 << PD2);

        PORTD |= (1 << PD1);

    }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; // Store result in ring buffer

    azimuthArrayPosition++;

    if( AVERAGE_SIZE <= azimuthArrayPosition ){

        azimuthArrayPosition = 0;

    }

    // Start next conversion

    ADCSRA |= ( 1 << ADSC );

}

void sendStatus( uint8_t type )

{

    Can_Message_t txMsg;

    //txMsg.Id = 0x1f8f0100UL; //(( 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();

    if(STATUS == type){

        txMsg.Id = 0x1f8f0100UL;

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

        txMsg.DataLength = 2;

    }else{

        txMsg.Id = 0x12020202UL;

        txMsg.Data.bytes[ 0 ] = type;

        txMsg.DataLength = 1;

    }

    // Try to resend up to four times

    for(int i=0; i<3;i++){

        if( CAN_OK == BIOS_CanSend( &txMsg )){

            return;

        }

    }      

}