Subversion Repositories HomeAutomation

/**

 * AntennaControl

 *

 * Build for use at ETA, http://www.eta.chalmers.se/

 * controlling their 2 meter yagi antenna.

 * For the moment only support for azimuth,

 * elevation is yet to be implemented.

 *

 * @date 2007-12-10

 * @author Erik Larsson

 *

 */

/*

 * This version uses a NodeEssential

 * and the pins used are:

 * 0: PD2 azimuth plus

 * 1: PD1 azimuth minus

 * 8: PC4 ADC4 azimuth feedback

 */

/*-----------------------------------------------------------------------------

 * Includes

 *---------------------------------------------------------------------------*/

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

/*-----------------------------------------------------------------------------

 * Defines

 *---------------------------------------------------------------------------*/

#define APP_TYPE    0xf0a0

#define APP_VERSION 0x0002

#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

//FIXME move these message id 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

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

// For calculating average feedback measurement

uint16_t azimuthReadout[ AVERAGE_SIZE ];

uint16_t azimuthCalibration;

/*-----------------------------------------------------------------------------

 * Declarations

 *---------------------------------------------------------------------------*/

/**

 * calibration

 * Sets and gets calibration data from EEPROM

 *

 * @param mode: set /get

 * @param value

 * @return value

 */

int16_t calibration( uint8_t mode, uint16_t value );

// Turn rotor

// position: 0-1024

/**

 * turn

 * Turns rotor to given position

 * FIXME implement this function

 *

 * @param position

 * @return

 */

uint8_t turn( uint16_t position );

/**

 * getPosition

 * Calculates the antenna position

 * Uses a number of the latest adc readings

 * and gets the avarage value

 *

 * @param void

 * @return position

 */

uint16_t getPosition( void );

/**

 * initAdcFeedback

 * Starts the ADC

 *

 * @param void

 * @return void

 */

void initAdcFeedback( void );

/**

 * readFeedback

 * Gets antenna position from ADC and

 * puts in arrary for later calculations

 *

 * @param void

 * @return void

 */

void readFeedback( void );

/**

 * controlRelay

 * Control the relay that turns the rotor

 *

 * @param direction

 * @return void

 */

void controlRelay( uint8_t direction );

/**

 * sendStatus

 * Sends antennas position on CAN bus

 *

 * @param void

 * @return void

 */

void sendStatus( void );

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

    }

}

/*-----------------------------------------------------------------------------

 * Main Program

 *---------------------------------------------------------------------------*/

int main( void )

{

    // Enable interrupts as early as possible

    sei();

    Timer_Init();

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

    Timer_SetTimeout(1, 1000, TimerTypeFreeRunning, 0);

    sendStatus();

    while (1) {

        if (Timer_Expired(0)) {

            // Periodicly read antennas position

            readFeedback();

        }

        if (Timer_Expired(1)) {

            // Send antennas position

            sendStatus();

        }

        /* If any messages is received */

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

                        //FIXME implement this

                    }

                    break;

                case MSG_REL:

                    // Start turning to relative position

                    if( 2 == rxMsg.DataLength ){

                        //FIXME implement this

                    }

                    break;

                case MSG_START:

                    // Start turning rotor

                    if( 1 == rxMsg.DataLength ){

                        // First data byte decides direction

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

                    }

                    break;

                case MSG_STOP:

                    // Stop turning rotor

                    controlRelay( ROTATE_STOP );

                    break;

                case MSG_STATUS:

                    // Get position

                    if( 0 == rxMsg.DataLength ){

                        sendStatus();

                    }

                    break;

                default:

                    break;

            }

            rxMsgFull = 0;

        }

    }

    return 0;

}

/*-----------------------------------------------------------------------------

 * Definitions

 *---------------------------------------------------------------------------*/

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 )

{

    //FIXME implement this

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

    position /= 3;

    // Calibrate

    position += (int16_t)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 );

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

        PORTD &= ~(1 << PD2);

        PORTD |= (1 << PD1);

    }else if ( ROTATE_MINUS == direction ){

        // Turn CCW

        PORTD &= ~(1 << PD1);

        PORTD |= (1 << PD2);

    }else{

        // Stop azimuth rotor

        PORTD |= (1 << PD1);

        PORTD |= (1 << PD2);

    }

}

void readFeedback( void )

{

    static uint8_t azimuthArrayPosition = 0;

    // Wait for ADC conversion to complete

    while( ADCSRA & ( 1 << ADSC )){}

    // Put readout in ringbuffer

    azimuthReadout[ azimuthArrayPosition ] = ADCW;

    azimuthArrayPosition++;

    if( AVERAGE_SIZE <= azimuthArrayPosition ){

        azimuthArrayPosition = 0;

    }

    // Start next conversion

    ADCSRA |= ( 1 << ADSC );

}

void sendStatus( void )

{

    // Gets antennas position and sends on CAN bus

    Can_Message_t txMsg;

    txMsg.Id = 0x1f8f0100UL; //FIXME id should not be defined here

    txMsg.DataLength = 2;

    txMsg.RemoteFlag = 0;

    txMsg.ExtendedFlag = 1;

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

    BIOS_CanSend( &txMsg );

}