/Users/craigcornelius/Projects/SPRING Mac Release 0.2/bird.cpp

Go to the documentation of this file.

// $Id: bird.cpp,v 1.30 2006/05/24 16:52:40 sean Exp $
//
// Upgraded to now also use the new Ascension beta library
//
#define USE_NEW_LIBRARY


#if defined(_WIN32) && defined(USE_NEW_LIBRARY)


// stdafx.h : include file for standard system include files,
//  or project specific include files that are used frequently, but
//      are changed infrequently
//

// #define VC_EXTRALEAN         // Exclude rarely-used stuff from Windows headers

#include <afxwin.h>         // MFC core and standard components
#include <afxext.h>         // MFC extensions
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h>                     // MFC support for Windows 95 Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT


#include "pcBird.h"


// Group ID #
#define GROUP_ID                                0

// ISA connection info
#define ISA_BASE_ADDRESS                0x304

#define DeviceNum  1    // which receiver

#include "bird.h"
const char* Bird::rcsid = "@(#) $Id: bird.cpp,v 1.30 2006/05/24 16:52:40 sean Exp $ $Copyright: (c)2001 National Biocomputation Center, Stanford University $";

int Bird::debug = 0;


Bird::Bird(char* port_name_in, int baud, int num_birds_if_master, 
        return_values_enum return_values_in)
        : Sensor(Sensor::bird_sensor), SerialDevice(port_name_in, baud)
{
        if (debug)
          cerr << "Bird::Bird(\"" << port_name_in << "\", " << baud << ", "
                   << num_birds_if_master << ", " << int(return_values_in) << ")\n";

        // locals
        int m_bStandAlone = 0;
        int m_nNumDevices = 1;
        WORD m_pwAddress[10]; m_pwAddress[1] = ISA_BASE_ADDRESS;
        int m_dwReadTimeout = 1000;
        int m_dwWriteTimeout = 1000;

        // Enable displaying of error dialogs.
        birdDisplayErrorDialogs(TRUE);

        // Wake up the birds in ISA mode.
        if (!birdISAWakeUp(GROUP_ID, FALSE, m_nNumDevices, m_pwAddress,
                m_dwReadTimeout, m_dwWriteTimeout)) {
                cerr << "Bird- can't wakeup\n";
                return;
        }

        // Get the old system configuration.
        BIRDSYSTEMCONFIG syscfg;
        if (!birdGetSystemConfig(GROUP_ID, &syscfg)) {
                cerr << "Bird- can't get system config\n";
                return;
        }

        // Display the old system configuration.
        if (debug) {
        fprintf(stderr,"\n\
SYSTEM CONFIGURATION:\n\
System Status: 0x%02X\n\
Error: %d\n\
# Devices: %d\n\
# Servers: %d\n\
Transmitter #: 0x%02X\n\
Measurement Rate: %f\n\
Chassis #: %d\n\
# Chassis Devices: %d\n\
First Device #: %d\n\
Software Revision: 0x%04X\n",
                        syscfg.bySystemStatus,
                        syscfg.byError,
                        syscfg.byNumDevices,
                        syscfg.byNumServers,
                        syscfg.byXmtrNum,
                        syscfg.dMeasurementRate,
                        syscfg.byChassisNum,
                        syscfg.byNumChassisDevices,
                        syscfg.byFirstDeviceNum,
                        syscfg.wSoftwareRev);
        }


        { // Change the configuration of each device.
                // Get the old device configuration.
                BIRDDEVICECONFIG devcfg;
                if (!birdGetDeviceConfig(GROUP_ID, DeviceNum, &devcfg)) {
                        cerr << "Bird-can't get device config #1\n";
                        return;
                }

                // Change the device configuration so that the data format
                //  is position/quaternion.
                devcfg.byDataFormat = BDF_POSITIONMATRIX;
                devcfg.byHemisphere = BHC_REAR;

#ifdef DO_FILTERING
                // if to setup for filtering
                devcfg.bySetup = BDS_ACWIDENOTCHFILTER | BDS_DCFILTER;
                for (int i = 0; i < 7; i++)
                {
                        devcfg.wAlphaMin[i] = 655;
                        devcfg.wAlphaMax[i] = 983;
                        devcfg.wVM[i] = 32767;
                }
#endif

                if (!birdSetDeviceConfig(GROUP_ID, DeviceNum, &devcfg)) {
                        cerr << "Bird- can't set device config\n";
                        return;
                }

                // Get the new device configuration.
                if (!birdGetDeviceConfig(GROUP_ID, DeviceNum, &devcfg)) {
                        cerr << "Bird-can't get device config #2\n";
                        return;
                }

                // Display the new device configuration.
                if (debug) {
                fprintf(stderr, "\n\
DEVICE %d CONFIGURATION:\n\
Status: 0x%02X\n\
ID: %d\n\
Software Revision: 0x%04X\n\
Error: %d\n\
Setup: 0x%02X\n\
Data Format: %d\n\
Report Rate: %d\n\
Scaling: %d\n\
Hemisphere: %d\n\
Device #: %d\n\
Transmitter Type: 0x%02X\n",
                                DeviceNum,
                                devcfg.byStatus,
                                devcfg.byID,
                                devcfg.wSoftwareRev,
                                devcfg.byError,
                                devcfg.bySetup,
                                devcfg.byDataFormat,
                                devcfg.byReportRate,
                                devcfg.wScaling,
                                devcfg.byHemisphere,
                                devcfg.byDeviceNum,
                                devcfg.byXmtrType);
                }
        }  // end device config set

        { // Get a single test reading from each bird.  NOTE: Do NOT use this command in
          //  TCP/IP mode - there is no way to get single bird readings.
        BIRDREADING reading;
        if (!birdStartReading(GROUP_ID, DeviceNum)) {
                cerr << "Bird- can't start reading\n";
                return;
        }
        if (!birdGetReading(GROUP_ID, DeviceNum, &reading)) {
                cerr << "Bird- can't get reading\n";
                return;
        }
        }

}
        

void Bird::Update()
{
        BIRDREADING reading;
        if (!birdStartReading(GROUP_ID, DeviceNum))
                return;
        
        if (!birdGetReading(GROUP_ID, DeviceNum, &reading)) {
                if (birdGetErrorCode() == BE_PHASEERROR)
                        cerr << "Bird::Update()- Phase Error\n";
                else
                        return;
        }
        
        // map the x,y,z (z up) of the transmitter to x,y,z (z out) of the screen
        // Note: this already gives us the position in mm, so no need to convert
        // Looks like this is wrong: it seems to be in 1/1000 of an inch
    pos.x =  reading.position.nY;
    pos.y =  -reading.position.nZ;
    pos.z =  -reading.position.nX;

        // Convert from 1/1000 of an inch to 1 mm
        pos *= 25.4/1000;

        // center off the initial position
        pos -= init_pos;

        // scale it based on the scale factor
        pos *= scalefactor;

        // convert to standard graphics format and 
        // transpose it to make them rotations relative to object
        m.m[0][0] = reading.matrix.n[1][1];
    m.m[1][0] = -reading.matrix.n[1][2];
    m.m[2][0] = -reading.matrix.n[1][0];
    m.m[0][1] = -reading.matrix.n[2][1];
    m.m[1][1] = reading.matrix.n[2][2];
    m.m[2][1] = reading.matrix.n[2][0];
    m.m[0][2] = -reading.matrix.n[0][1];
    m.m[1][2] = reading.matrix.n[0][2];
    m.m[2][2] = reading.matrix.n[0][0];
        m.m[0][3] = m.m[1][3] = m.m[2][3] = 0;
        m.m[3][0] = m.m[3][1] = m.m[3][2] = 0; 
        m.m[3][3] = 1.0;

        { // decode  matrix values
                for (int i=0;i<3; i++) for (int j=0;j<3; j++)
                        m.m[i][j] /= 32767.0;
        }

}


Bird::~Bird()
{
        // Shut down the birds.
        birdShutDown(GROUP_ID);
}


#else

#include "bird.h"
const char* Bird::rcsid = "@(#) $Id: bird.cpp,v 1.30 2006/05/24 16:52:40 sean Exp $ $Copyright: (c)2001 National Biocomputation Center, Stanford University $";

// Streaming versus Polled
//#define STREAMING

#ifdef _WIN32
#include "pcBird.h"

#else
#include <strings.h>
#include <unistd.h>
#ifndef __APPLE__
#include <termio.h>
#endif // __APPLE__
#include <fcntl.h>
#include <sys/time.h>

#ifdef SGI_4D
#include <sys/types.h>
#include <bstring.h>
#elif defined(SUN4)
#include <string.h>
#endif
#endif

#include <stdio.h>

// Command set for bird 
#define BIRD_EXAMINE_VALUE      0x4F
#define BIRD_CHANGE_VALUE       0x50
#define BIRD_POSITION           0x56
#define BIRD_ANGLES             0x57
#define BIRD_MATRIX             0x58
#define BIRD_POSITION_ANGLES    0x59
#define BIRD_POSITION_MATRIX    0x5A
#define BIRD_POINT              0x42
#define BIRD_STREAM             0x40
#define BIRD_RUN                0x46
#define BIRD_SLEEP              0x47
#define BIRD_SYNC_CMD           0x41
#define BIRD_CRT_SYNC_LOW       0x01
#define BIRD_CRT_SYNC_HIGH      0x02
#define BIRD_HOST_SYNC          0x80
#define BIRD_RATE1              0x51
#define BIRD_RATE2              0x52
#define BIRD_RATE8              0x53
#define BIRD_RATE32             0x54
#define BIRD_BUTTON_ON          0x01
#define BIRD_BUTTON_OFF         0x00
#define BIRD_SET_BUTTON         0x4d
// set hemisphere stuff (0x06,0x01) are left hemisphere params)
#define BIRD_HEMISPHERE         0x4c
#define BIRD_HEMI_AXIS          0x00    // aft
#define BIRD_HEMI_SIGN          0x01    // aft
#define BIRD_ANGLE_ALIGN2       0x71
// examine values parameters
#define BIRD_CRYSTAL_SPEED      0x02

#define POSMAX     (36.0 / 32767.0)          /* Position scalling, in inch */
#define ANGMAX     (180.0 / 32767.0)         /* Max angle value */
#define MATMAX     (1.0 / 32767.0)           /* Max matrix value */

#define BIRD_TIME_OUT 800000                 /* after .8 second we abort */

// handy macros for converting their representation to/from a short
#define DECODE(b,i) ((short)( ( ((b)[i+1] << 7 ) | ((b)[i] & 0x7f) ) << 2 ))
#define ENCODE_LSB(x)   (short(x) & 0x00ff)
#define ENCODE_MSB(x)   ((short(x) & 0xff00) >> 8)

int Bird::debug = 0;

// send bird a request for stream data, initialise bird_buffer, and time outs
void Bird::bird_start_stream()
{
        if (!is_master) return;

        if (debug) cerr << "Bird[" << port_name << "]-starting bird stream ...\n";
        write_bird(BIRD_RUN);
#ifdef STREAMING
    write_bird(BIRD_STREAM);

    /* testing bird connection and phasing bit position */
    while ( GetByte() & 0x80 ) {
            /* we have located the phasing bit */
            break;
        }
#endif

        if (debug) cerr << "bird stream started...\n";
}

void Bird::Sleep()
{
        if (debug) cerr << "Bird[" << port_name << "]::Sleep()\n";
        write_bird(BIRD_SLEEP);
        first_update = 1;       // set flag so we'll restart stream 
}

/* write to bird one byte of command, return the actual number of 
   bytes that have been written */
void Bird::write_bird(unsigned char command)
{
    if (debug)
#ifdef LINUX
       cerr << "Bird[" << port_name << "]-WRITE_BIRD: 0x" << command << endl;
#else
       cerr << "Bird[" << port_name << "]-WRITE_BIRD: 0x" << hex << command
                        << dec << endl;
#endif
    
    SendByte(command);
}

/* Initialize Flock of Birds */
void Bird::initialize_flock(int num_birds_in_flock)
{
    write_bird(BIRD_CHANGE_VALUE);   /* change value */
    write_bird(0x32);           /* autoconfiguration */
    write_bird(num_birds_in_flock);
}


/* Bird():
 *      Initialise bird to these conditions:
 *      1. open a port
 *      2. use left hemisphere
 *      3. combine position/angle/button into one packet of 13 bytes
 *      4. use stream mode
 *      5. use proper bird sync function
 *      6. properly locate the phasing bit
 *      7. set filters.
 * Bird( char *, int );
 */

Bird::Bird(char* port_name_in, int baud, int num_birds_if_master, 
        return_values_enum return_values_in)
        : Sensor(Sensor::bird_sensor), SerialDevice(port_name_in, baud)
{
        if (debug)
          cerr << "Bird::Bird(\"" << port_name_in << "\", " << baud << ", "
                   << num_birds_if_master << ", " << int(return_values_in) << ")\n";

    // initialization of class variables
        is_master = 0;          // assume not
    first_update = 1;   // never been updated before
    return_values = return_values_in;
    for (int i=0; i<3; i++) for (int j=0; j<3; j++) m.m[i][j] = 0.0;
        strncpy(port_name, port_name_in, 80);

    // if it is the master, initialize and tell the number of birds in flock
    if (num_birds_if_master > 0) {
                is_master = 1;  // hey- we are!
        initialize_flock(num_birds_if_master);
        }

    switch (return_values) {
    case POSITION:              write_bird(BIRD_POSITION); break; // position data only
    case ANGLES:                write_bird(BIRD_ANGLES); break; // angles data only
    case MATRIX:                write_bird(BIRD_MATRIX); break; // matrix data only
    case POSITION_ANGLES:       write_bird(BIRD_POSITION_ANGLES); break; // position/angles data 
    case POSITION_MATRIX:       write_bird(BIRD_POSITION_MATRIX); break; // position/matrix data
    }

    // set other params
    write_bird(BIRD_RATE1);               /* using highest report rate */
        write_bird(BIRD_SET_BUTTON);          /* instruct the button...*/
    write_bird(BIRD_BUTTON_OFF);           /* to be off, to save xmit time */

    /* Use choosen hemispere */
    write_bird(BIRD_HEMISPHERE);              
    write_bird(BIRD_HEMI_AXIS);       
    write_bird(BIRD_HEMI_SIGN);   

    /* rotate coord system */
    //angle_align(0.0, 0.0, 0.0);

    // learn some things about the bird
    //write_bird(BIRD_EXAMINE_VALUE);

/*    turn_off_filters(); */
}

Bird::~Bird()
{
          if (debug) cerr << "Bird[" << port_name << "]::~Bird()\n";

          if (is_master)
        Sleep();        // put the bird to bed
}

void Bird::setCRTsync(sync_enum sync_mode)
{
        if (!is_master) return;
        if (debug) 
                cerr << "Bird[" << port_name << "]::setCRTsync(" << int(sync_mode) 
                         << ")\n";

    /* use the proper sync function */
    switch ( sync_mode )
    {
      case NO_SYNC: break;
      case SYNC_CRT_LOW: sync_bird_crt_low(); break;
      case SYNC_HOST: sync_bird_host(); break;
      case SYNC_CRT_HIGH: sync_bird_crt_low(); break;
      default:
        fprintf(stderr, "Unknown bird sync mode\n");
        break;
    }
}

/* read_bird_stream()
 *      Read in bird position/angle/button status, and put in the structure
 *      Return 1 if data is properly read-in, 0 if no useful data present
 */
char* Bird::read_bird_stream ()
{
        if (debug) cerr << "Bird:[" << port_name << "]- read_bird_stream()\n";

#ifndef STREAMING
        write_bird(BIRD_POINT);
#endif

    // determine size of packet
    int packet_length = 6;
    switch (return_values) {
    case POSITION:              packet_length = 6; break;
    case ANGLES:                packet_length = 6; break;
    case MATRIX:                packet_length = 18; break;
    case POSITION_ANGLES:       packet_length = 12; break;
    case POSITION_MATRIX:       packet_length = 24; break;
    }
    //packet_length++;  // for the button value


    // first, flush leftovers so we have the most up-to-date data (no lag)
        // NOTE!!!:  THIS WOULD BE GOOD, EXCEPT IT MEANS THAT WE MUST BE ABLE
        // TO BUFFER THE ENTIRE PACKET IN THE UART, WHICH IS NOT TRUE FOR THE
        // 16550 (16 byte buffer) WHEN READING IN POSITION_MATRIX MODE. SO, WE
        // MOVE THE FLUSH UNTIL AFTER THE READ TO TRY TO KEEP THINGS RELATIVELY
        // UP-TO-DATE, BUT THIS IS A HAIRY SITUATION- WE'RE ALMOST GUARANTEED TO
        // HAVE OLD DATA THE WAY THIS IS SETUP NOW!!!!
        const int uart_buffer_length = 32;  // bytes
        if (packet_length < uart_buffer_length)
      FlushInputQueue();

    { // read characters, building up the bird buffer
      int counter = 0;
      do {
        int c = GetByte();
                if (c == -1) continue;

        // if found phasing bit, restart packet
        if (c & 0x80) counter = 0; 

        // save the char
        bird_buffer[counter] = char(c & 0x7f);

        // increment counter with bounds checking
        if (counter < BIRD_BUF_SIZE) counter++;
      } while (counter < packet_length);
    }

        // flush the rest right here
        if (packet_length >= uart_buffer_length)
          FlushInputQueue();

    // return the buffer
    return bird_buffer;
}

// decode position packet (6 bytes long) into easy-to-use Bird structure
int Bird::decode_position(char* b_b)
{
    // decode the output of the bird unit
    Point3D decoded_pos;
    decoded_pos.x = POSMAX * DECODE(b_b, 0);
    decoded_pos.y = POSMAX * DECODE(b_b, 2);
    decoded_pos.z = POSMAX * DECODE(b_b, 4);
    if (debug)
       cerr << "decode_position::decoded_pos = " << decoded_pos << endl;

    // map the x,y,z (z up) of the transmitter to x,y,z (z out) of the screen
    pos.x =  decoded_pos.y;
    pos.y =  -decoded_pos.z;
    pos.z =  -decoded_pos.x;

        // convert to mm from inches
        pos *= 25.4;

        // make it relative to the user-chosen origin
        pos -= init_pos;

        // scale it based on the scale factor
        pos *= scalefactor;

    // return number of chars eaten
    return(6);
}

// decode angle packet (6 bytes long) into easy-to-use Bird structure
int Bird::decode_angles(char* b_b)
{
    // decode the output of the bird unit
    Point3D decoded_ang;
    decoded_ang.x = ANGMAX * DECODE(b_b, 0);
    decoded_ang.y = ANGMAX * DECODE(b_b, 2);
    decoded_ang.z = ANGMAX * DECODE(b_b, 4);

    // map the x,y,z (z up) of the transmitter to x,y,z (z out) of the screen
    //rot.x =  decoded_ang.y;
    //rot.y =  decoded_ang.x;
    //rot.z =  decoded_ang.z;

    // return number of chars eaten
    return(6);
}

// decode matrix packet (18 bytes long) into easy-to-use Bird structure
int Bird::decode_matrix(char* b_b)
{
    // decode the matrix
        double decoded_m[3][3];
    decoded_m[0][0] = MATMAX * DECODE(b_b, 0);
    decoded_m[0][1] = MATMAX * DECODE(b_b, 2);
    decoded_m[0][2] = MATMAX * DECODE(b_b, 4);
    decoded_m[1][0] = MATMAX * DECODE(b_b, 6);
    decoded_m[1][1] = MATMAX * DECODE(b_b, 8);
    decoded_m[1][2] = MATMAX * DECODE(b_b, 10);
    decoded_m[2][0] = MATMAX * DECODE(b_b, 12);
    decoded_m[2][1] = MATMAX * DECODE(b_b, 14);
    decoded_m[2][2] = MATMAX * DECODE(b_b, 16);

        // convert to standard graphics format and 
        // transpose it to make them rotations relative to object
        m.m[0][0] = decoded_m[1][1];
    m.m[1][0] = -decoded_m[1][2];
    m.m[2][0] = -decoded_m[1][0];
    m.m[0][1] = -decoded_m[2][1];
    m.m[1][1] = decoded_m[2][2];
    m.m[2][1] = decoded_m[2][0];
    m.m[0][2] = -decoded_m[0][1];
    m.m[1][2] = decoded_m[0][2];
    m.m[2][2] = decoded_m[0][0];

    if (debug)
          m.Print();

    // return number of chars eaten
    return(18);
}

// decode button packet (1 byte long) into easy-to-use Bird structure
int Bird::decode_button(char* b_b)
{
    // the button's just the guy at the end of the stream
    active[0] = (b_b[0] & 0x70) ? 1:0;

    // return number of chars eaten
    return(1);
}

// decode position/angle packet (13 bytes long) into easy-to-use Bird structure
int Bird::decode_pos_ang(char* b_b)
{
  int num_used = 0;
  num_used += decode_position(b_b + num_used);
  num_used += decode_angles(b_b + num_used);
  return(num_used);
}

// decode position/angle packet (13 bytes long) into easy-to-use Bird structure
int Bird::decode_pos_mat(char* b_b)
{
  int num_used = 0;
  num_used += decode_position(b_b + num_used);
  num_used += decode_matrix(b_b + num_used); 
  return(num_used);
}

/* bird_button_status():
 *      Return > 0 if the button is down, < 0 if up (not been pressed)
 *      Refer to birdlib.h for exact meaning of these:
 *              BIRD_BUTTON_IS_DOWN 1
 *              BIRD_BUTTON_PRESSED 2
 *              BIRD_BUTTON_IS_UP -1
 *              BIRD_BUTTON_RELEASED -2
 */
Bird::button_enum Bird::bird_button_status()
{
    static Bird::button_enum last_button_status = Bird::UP;
    Bird::button_enum retval = Bird::UP;

    if (active[0])
        retval = Bird::DOWN;
    else
        retval = Bird::UP;

    if ( last_button_status != retval )
    {
        last_button_status = retval;
        //retval += retval;
    }
    return retval;
}

/* some trivial routines */

#ifdef OLD_CODE
/* return current time, in the residule of micro-second */
int Bird::get_mic_time()
{
    gettimeofday( &timeval, &timez);
    return timeval.tv_usec;
}

/* return duration since the give value, in microsecond */
int Bird::get_mic_duration(int last)
// int last;                                 /* micro second */
{
    int duration;
    gettimeofday( &timeval, &timez);
    duration = timeval.tv_usec - last;
    return ( (duration <0 ) ? (duration + 1000000):duration );
}
#endif

/* set the bird to use CRT sync */
void Bird::sync_bird_crt_low()
{
        write_bird(BIRD_SYNC_CMD);
        write_bird(BIRD_CRT_SYNC_LOW);
}

/* set the bird to use CRT sync */
void Bird::sync_bird_crt_high()
{
        write_bird(BIRD_SYNC_CMD);
        write_bird(BIRD_CRT_SYNC_HIGH);
}

/* set the bird to use HOST sync */
void Bird::sync_bird_host()
{
        write_bird(BIRD_SYNC_CMD);
        write_bird(BIRD_HOST_SYNC);
}


void Bird::Update()
{
    if (debug) cerr << "Bird[" << port_name << "]::Update()\n";

    // if it's the first time, go into stream mode
    if (first_update) {
       bird_start_stream();     /* start bird data stream */
       first_update = 0;
    }

    // do the read
    char* packet = read_bird_stream();

    /* decode the packet into usable data structure */
    if (packet != NULL) {
       int num_used = 0;
       switch (return_values) {
       case POSITION: num_used += decode_position(packet); break;
       case ANGLES: num_used += decode_angles(packet); break;
       case MATRIX: num_used += decode_matrix(packet); break;
       case POSITION_ANGLES: num_used += decode_pos_ang(packet); break;
       case POSITION_MATRIX: num_used += decode_pos_mat(packet); break;
       }
       packet += num_used;
       //num_used += decode_button(packet);
    }
}


void Bird::turn_off_filters()
{
    write_bird(BIRD_CHANGE_VALUE);      /* change command, check page 23 of Bird manual*/
    write_bird(0x04);           /* PARAMETERnumber 4, filters, check page24 */     
    write_bird(0x05);           /* PARAMETERdata, check page28, 00000101 to turn AC Wide  filter off*/
}

// allows you to rotate the bird coordinate system
// angles are +-180 degrees
void Bird::angle_align(double x_rot, double y_rot, double z_rot)
{
    double factor = 32767.0/180.0;
    write_bird(BIRD_ANGLE_ALIGN2);      // command
    write_bird(ENCODE_LSB(z_rot * factor));             // Z rotation LSB
    write_bird(ENCODE_MSB(z_rot * factor));             // Z rotation MSB
    write_bird(ENCODE_LSB(y_rot * factor));             // Y rotation LSB
    write_bird(ENCODE_MSB(y_rot * factor));             // Y rotation MSB
    write_bird(ENCODE_LSB(x_rot * factor));             // X rotation LSB
    write_bird(ENCODE_MSB(x_rot * factor));             // X rotation MSB
}

void Bird::CRTVoltageTest(double* voltage_p, double* scanrate_p)
{
    write_bird(BIRD_SYNC_CMD);  // command
    write_bird(255);    // sync pickup command

    // read in the 4-byte voltage/scan_rate values
    //int counter=0;
    const int packet_size = 4;  // bytes
    char local_buffer[80];
    
        GetBuffer(local_buffer, packet_size);

    // debugging
    printf("local buffer = %d %d %d %d\n", local_buffer[0], local_buffer[1],
        local_buffer[2], local_buffer[3]);

    // decode voltage
#define DECODE_UNPHASED(b,i) ((short)( ((b)[i+1] << 8 ) | (b)[i]))
    const double voltage_factor = (5.0/32767.0);
    *voltage_p = (voltage_factor * DECODE_UNPHASED(local_buffer, 0));

    // decode scan rate
    const double scanrate_factor = (500000.0);
    const double clock_rate = 8.0/40.0; // 40 MHz internal flock crystal speed
    unsigned short counts = DECODE_UNPHASED(local_buffer, 2);
    *scanrate_p = scanrate_factor / (clock_rate*counts);
}

#endif

---