WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/AVR/application/AntennaControl/main.c

  * AntennaControl
+ *
- * Build for use at ETA, http://www.eta.chalmers.se/, controlling their 2 meter yagi antenna.
+ * 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-10-28
+ * @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 0x0001
+#define APP_VERSION 0x0002
 #define AZIMUTH 0
 #define ROTATE_STOP 0
 #define ROTATE_PLUS 1
 #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
+//FIXME move these message id defines
-#define MSG_CAL_SET 0x0100001UL
+#define MSG_CAL_SET 0x11100001UL
-#define MSG_CAL_GET 0x0100002UL
+#define MSG_CAL_GET 0x11100002UL
-#define MSG_ABS 0x01000031UL
+#define MSG_ABS 0x111000031UL
-#define MSG_REL 0x0100004UL
+#define MSG_REL 0x11100004UL
-#define MSG_START 0x0100005UL
+#define MSG_START 0x11100005UL
-#define MSG_STOP 0x0100006UL
+#define MSG_STOP 0x11100006UL
-#define MSG_STATUS 0x0100007UL
+#define MSG_STATUS 0x11100007UL
-// ----------
-// Essential pins
-// 0: PD2 azimuth plus
-// 1: PD1 azimuth minus
-// 8: PC4 ADC4 azimuth feedback
+#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
-//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) {
+ * Declarations
-        memcpy((void*)&rxMsg, msg, sizeof(rxMsg));
+ *---------------------------------------------------------------------------*/
-        rxMsgFull = 1;
-    }
-}
+/**
+ * calibration
+ * Sets and gets calibration data from EEPROM
+ *
-// Calibration function
+ * @param mode: set /get
-// mode: set / get
+ * @param value
-// 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 );
+/**
-// Get position
+ * getPosition
+ * Calculates the antenna position
-// Gets the average value for compensation of distorsions
+ * Uses a number of the latest adc readings
+ * and gets the avarage value
+ *
+ * @param void
+ * @return position
+ */
 uint16_t getPosition( void );
+/**
+ * initAdcFeedback
-// Initiate ADC
+ * Starts the ADC
+ *
+ * @param void
+ * @return void
+ */
 void initAdcFeedback( void );
+/**
+ * readFeedback
-// Read antenna feedback from ADC
+ * Gets antenna position from ADC and
+ * puts in arrary for later calculations
+ *
+ * @param void
+ * @return void
+ */
 void readFeedback( void );
+/**
-// Control rotation relays
+ * controlRelay
+ * Control the relay that turns the rotor
+ *
+ * @param direction
+ * @return void
+ */
 void controlRelay( uint8_t direction );
+/**
+ * sendStatus
-// Sends antennas position on CAN
+ * 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){
+            switch ( rxMsg.Id ){
+                case MSG_CAL_SET:
-                case MSG_CAL_SET: // Set calibration value
+                    // Set calibration value
                     if( 2 == rxMsg.DataLength ){
                         calibration( SET, rxMsg.Data.words[0] );
                     }
                     break;
+                case MSG_CAL_GET:
-                case MSG_CAL_GET: // Get calibration value
+                    // 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:
-                case MSG_ABS: // Start turning to absolute position
+                    // 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_REL: // Start turning to relative position
-                    if( 2 == rxMsg.DataLength ){
-                    }
                     break;
-                case MSG_START: // Start turning
+                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
+                case MSG_STOP:
-                    if( 1 == rxMsg.DataLength ){
+                    // Stop turning rotor
-                        controlRelay( ROTATE_STOP );
+                    controlRelay( ROTATE_STOP );
-                    }
                     break;
-                case MSG_STATUS: // Get position
+                case MSG_STATUS:
+                    // Get position
                     if( 0 == rxMsg.DataLength ){
                         sendStatus();
                     }
                     break;
                 default:
                     break;
+            }
-            rxMsgFull = 0; //
+            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 += azimuthCalibration;
+    position += (int16_t)azimuthCalibration;
     return position;
+}
 void initAdcFeedback( void )
     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
     ADCSRA |= ( 1 << ADSC );
+}
 void controlRelay( uint8_t direction )
+{
-    if( ROTATE_PLUS == direction ){ // Turn clockwise
+    if( ROTATE_PLUS == direction ){
+        // Turn CW
         PORTD &= ~(1 << PD2);
         PORTD |= (1 << PD1);
-    }else if ( ROTATE_MINUS == direction ){ // Turn counter clockwise
+    }else if ( ROTATE_MINUS == direction ){
+        // Turn CCW
         PORTD &= ~(1 << PD1);
         PORTD |= (1 << PD2);
     }else{
         // Stop azimuth rotor
         PORTD |= (1 << PD1);
 void readFeedback( void )
+{
     static uint8_t azimuthArrayPosition = 0;
+    // Wait for ADC conversion to complete
-    while( ADCSRA & ( 1 << ADSC )){} // Wait for 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 = 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.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 );
+}

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/application/AntennaControl/main.c – Rev 682 → 731