amu_commands.h

Go to the documentation of this file.

 
 
 
#ifndef __AMU_COMMANDS_H__
#define __AMU_COMMANDS_H__
 
#include "amu_types.h"
#include "amu_config_internal.h"
 
#define CMD_RW_BIT      7
#define CMD_READ        (1<<CMD_RW_BIT)
#define CMD_WRITE       (0<<CMD_RW_BIT)

 
#define CMD_I2C_USB             0x0100      
#define CMD_USB_ONLY            0x0200      
 
#define CMD_SYSTEM_OFFSET                   CMD_I2C_USB + 0x00
#define CMD_SYSTEM_LED_OFFSET               CMD_I2C_USB + 0x10
#define CMD_DUT_OFFSET                      CMD_I2C_USB + 0x20
#define CMD_EXEC_OFFSET                     CMD_I2C_USB + 0x30
#define CMD_SWEEP_OFFSET                    CMD_I2C_USB + 0x40
#define CMD_AUX_OFFSET                      CMD_I2C_USB + 0x50
#define CMD_ADC_CH_OFFSET                   CMD_I2C_USB + 0x60
#define CMD_MEAS_CH_CMD_OFFSET              CMD_I2C_USB + 0x70
 
#define CMD_USB_SYSTEM_OFFSET               CMD_USB_ONLY + 0x00
#define CMD_USB_EEPROM_CMD_OFFSET           CMD_USB_ONLY + 0x10
#define CMD_USB_ADC_VOLTAGE_CMD_OFFSET      CMD_USB_ONLY + 0x20
#define CMD_USB_ADC_CURRENT_CMD_OFFSET      CMD_USB_ONLY + 0x30
#define CMD_USB_SWEEP_OFFSET                CMD_USB_ONLY + 0x40
#define CMD_USB_SYSTEM_CONFIG_OFFSET        CMD_USB_ONLY + 0x50
 
typedef enum {
    CMD_SYSTEM =              CMD_SYSTEM_OFFSET,
    CMD_SYSTEM_LED =          CMD_SYSTEM_LED_OFFSET,
    CMD_DUT =                    CMD_DUT_OFFSET,
    CMD_EXEC =                  CMD_EXEC_OFFSET,
    CMD_SWEEP =                    CMD_SWEEP_OFFSET,
    CMD_AUX =                    CMD_AUX_OFFSET,
    CMD_ADC_CH =              CMD_ADC_CH_OFFSET,
    CMD_MEAS_CH =                CMD_MEAS_CH_CMD_OFFSET,
    
    CMD_USB_SYSTEM =          CMD_USB_SYSTEM_OFFSET,
    CMD_USB_EEPROM =          CMD_USB_EEPROM_CMD_OFFSET,
    CMD_USB_ADC_VOLTAGE =        CMD_USB_ADC_VOLTAGE_CMD_OFFSET,
    CMD_USB_ADC_CURRENT =        CMD_USB_ADC_CURRENT_CMD_OFFSET,
    CMD_USB_SWEEP =                CMD_USB_SWEEP_OFFSET,
    CMD_USB_SYSTEM_CONFIG =        CMD_USB_SYSTEM_CONFIG_OFFSET
} CMD_t;
 
#define AMU_GET_CMD_ROOT(cmd)       (cmd & 0xFF70)      
#define AMU_GET_CMD_BRANCH(cmd)     (cmd & 0x000F)      
// With the READ WRITE BIT, we only have SEVEN available "root" enums of 16 comands each
// 
 

typedef enum {
    CMD_SYSTEM_NO_CMD =                        CMD_SYSTEM_OFFSET + 0x00,
    
    CMD_SYSTEM_RESET =                      CMD_SYSTEM_OFFSET + 0x01,
    
    CMD_SYSTEM_XMEGA_FUSES =              CMD_SYSTEM_OFFSET + 0x02,
    
    CMD_SYSTEM_TWI_ADDRESS =              CMD_SYSTEM_OFFSET + 0x03,
    
    CMD_SYSTEM_TWI_NUM_DEVICES =          CMD_SYSTEM_OFFSET + 0x04,
    
    CMD_SYSTEM_TWI_STATUS =                    CMD_SYSTEM_OFFSET + 0x05,
    
    CMD_SYSTEM_FIRMWARE =                    CMD_SYSTEM_OFFSET + 0x06,
    
    CMD_SYSTEM_SERIAL_NUM =                    CMD_SYSTEM_OFFSET + 0x07,
    
    CMD_SYSTEM_TEMPERATURE =              CMD_SYSTEM_OFFSET + 0x08,
    
    CMD_SYSTEM_TIME =                        CMD_SYSTEM_OFFSET + 0x09,
    
    CMD_SYSTEM_UTC_TIME =                    CMD_SYSTEM_OFFSET + 0x0A,
    
    CMD_SYSTEM_LED_COLOR =                  CMD_SYSTEM_OFFSET + 0x0B,
    
    CMD_SYSTEM_XMEGA_USER_SIGNATURES =      CMD_SYSTEM_OFFSET + 0x0C,
    
    CMD_SYSTEM_SLEEP =                      CMD_SYSTEM_OFFSET + 0x0F,
} CMD_SYSTEM_t;
#undef CMD_SYSTEM_OFFSET

typedef enum {
    CMD_DUT_JUNCTION =                      CMD_DUT_OFFSET + 0x00,
    
    CMD_DUT_COVERGLASS =                  CMD_DUT_OFFSET + 0x01,
    
    CMD_DUT_INTERCONNECT =                  CMD_DUT_OFFSET + 0x02,
    
    CMD_DUT_RESERVED =                      CMD_DUT_OFFSET + 0x03,
    
    CMD_DUT_MANUFACTURER =                  CMD_DUT_OFFSET + 0x04,
    
    CMD_DUT_MODEL =                            CMD_DUT_OFFSET + 0x05,
    
    CMD_DUT_TECHNOLOGY =                  CMD_DUT_OFFSET + 0x06,
    
    CMD_DUT_SERIAL_NUMBER =                    CMD_DUT_OFFSET + 0x07,
    
    CMD_DUT_ENERGY =                      CMD_DUT_OFFSET + 0x08,
    
    CMD_DUT_DOSE =                          CMD_DUT_OFFSET + 0x09,
    
    CMD_DUT_NOTES =                            CMD_DUT_OFFSET + 0x0B,
    
    CMD_DUT_TSENSOR_TYPE =                  CMD_DUT_OFFSET + 0x0D,
    
    CMD_DUT_TSENSOR_NUMBER =              CMD_DUT_OFFSET + 0x0E,
    
    CMD_DUT_TSENSOR_FIT =                    CMD_DUT_OFFSET + 0x0F,
} CMD_DUT_t;
#undef CMD_DUT_OFFSET

typedef enum {
    CMD_EXEC_MEAS_ACTIVE_CHANNELS =            CMD_EXEC_OFFSET + 0x00,
    
    CMD_EXEC_MEAS_CHANNEL =                    CMD_EXEC_OFFSET + 0x01,
    
    CMD_EXEC_MEAS_TSENSORS =              CMD_EXEC_OFFSET + 0x02,
    
    CMD_EXEC_MEAS_INTERNAL_VOLTAGES =        CMD_EXEC_OFFSET + 0x03,
    
    CMD_EXEC_MEAS_SUN_SENSOR =              CMD_EXEC_OFFSET + 0x04,
    
    CMD_EXEC_MEAS_PRESSURE_SENSOR =            CMD_EXEC_OFFSET + 0x05,
    
    CMD_EXEC_ADC_CAL =                      CMD_EXEC_OFFSET + 0x07,
    
    CMD_EXEC_ADC_CAL_ALL_INTERNAL =            CMD_EXEC_OFFSET + 0x08,
    
    CMD_EXEC_ADC_CAL_SAVE_ALL_INTERNAL =  CMD_EXEC_OFFSET + 0x09,
    
    CMD_EXEC_DAC_CAL =                      CMD_EXEC_OFFSET + 0x0A,
    
    CMD_EXEC_DAC_CAL_SAVE =                    CMD_EXEC_OFFSET + 0x0B,
    
    CMD_EXEC_TSENSOR_CAL_25C =              CMD_EXEC_OFFSET + 0x0C,
    
    CMD_EXEC_TSENSOR_COEFF_SAVE =            CMD_EXEC_OFFSET + 0x0D,
    
    CMD_EXEC_SUNSENSOR_COEFF_SAVE =            CMD_EXEC_OFFSET + 0x0E,
    
    CMD_EXEC_HEATER_PID_SAVE  =             CMD_EXEC_OFFSET + 0x0F,
} CMD_EXEC_t;
#undef CMD_EXEC_OFFSET

typedef enum {
    CMD_SWEEP_DISABLE =                        CMD_SWEEP_OFFSET + 0x00,
    
    CMD_SWEEP_ENABLE =                      CMD_SWEEP_OFFSET + 0x01,
    
    CMD_SWEEP_TRIG_SWEEP =                  CMD_SWEEP_OFFSET + 0x02,
    
    CMD_SWEEP_TRIG_ISC =                  CMD_SWEEP_OFFSET + 0x03,
    
    CMD_SWEEP_TRIG_VOC =                  CMD_SWEEP_OFFSET + 0x04,
    
    CMD_SWEEP_CONFIG_SAVE =                    CMD_SWEEP_OFFSET + 0x05,
    
    CMD_SWEEP_IV_SAVE_TO_EEPROM =            CMD_SWEEP_OFFSET + 0x06,
    
    CMD_SWEEP_IV_LOAD_FROM_EEPROM =            CMD_SWEEP_OFFSET + 0x07,
    
    CMD_SWEEP_AES_ENCODE =                  CMD_SWEEP_OFFSET + 0x08,
    
    CMD_SWEEP_AES_DECODE =                  CMD_SWEEP_OFFSET + 0x09,
    
    CMD_SWEEP_DATAPOINT_SAVE =              CMD_SWEEP_OFFSET + 0x0A,
    
    CMD_SWEEP_TRIG_INIT =                    CMD_SWEEP_OFFSET + 0x0B,
    
    CMD_SWEEP_DATAPOINT_LOAD =              CMD_SWEEP_OFFSET + 0x0C,
} CMD_SWEEP_t;
#undef CMD_SWEEP_OFFSET

typedef enum {  
    CMD_AUX_DAC_STATE =                        CMD_AUX_OFFSET + 0x00,
    
    CMD_AUX_DAC_CURRENT =                    CMD_AUX_OFFSET + 0x01,
    
    CMD_AUX_DAC_CURRENT_RAW =                CMD_AUX_OFFSET + 0x02,
    
    CMD_AUX_DAC_VOLTAGE =                    CMD_AUX_OFFSET + 0x03,
    
    CMD_AUX_DAC_VOLTAGE_RAW =                CMD_AUX_OFFSET + 0x04,
    
    CMD_AUX_DAC_OFFSET =                  CMD_AUX_OFFSET + 0x05,
    
    CMD_AUX_DAC_OFFSET_CORRECTION =            CMD_AUX_OFFSET + 0x06,
    
    CMD_AUX_DAC_GAIN_CORRECTION =            CMD_AUX_OFFSET + 0x07,
    
    CMD_AUX_HEATER_STATE =                  CMD_AUX_OFFSET + 0x08,
    
    CMD_AUX_HEATER_SETPOINT =                CMD_AUX_OFFSET + 0x09,
    
    CMD_AUX_HEATER_PID =                  CMD_AUX_OFFSET + 0x0A,
    
    CMD_AUX_SUNSENSOR_FIT_YAW_COEFF =        CMD_AUX_OFFSET + 0x0B,
    
    CMD_AUX_SUNSENSOR_FIT_PITCH_COEFF =        CMD_AUX_OFFSET + 0x0C,
    
    CMD_AUX_SUNSENSOR_HVAL =              CMD_AUX_OFFSET + 0x0D,
    
    CMD_AUX_SUNSENSOR_RVAL =              CMD_AUX_OFFSET + 0x0E,
    
    CMD_AUX_SUNSENSOR_THRESHOLD =            CMD_AUX_OFFSET + 0x0F,    
} CMD_AUX_t;
#undef CMD_AUX_OFFSET

typedef enum {
    CMD_ADC_CH_REG =                      CMD_ADC_CH_OFFSET + 0x00,
    
    CMD_ADC_CH_SETUP =                      CMD_ADC_CH_OFFSET + 0x01,
    
    CMD_ADC_CH_FILTER =                        CMD_ADC_CH_OFFSET + 0x02,
    
    CMD_ADC_CH_RATE =                        CMD_ADC_CH_OFFSET + 0x03,
    
    CMD_ADC_CH_PGA =                      CMD_ADC_CH_OFFSET + 0x04,
    
    CMD_ADC_CH_PGA_MAX =                  CMD_ADC_CH_OFFSET + 0x05,
    
    CMD_ADC_CH_PGA_VMAX =                    CMD_ADC_CH_OFFSET + 0x06,
    
    CMD_ADC_CH_PGA_IMAX =                    CMD_ADC_CH_OFFSET + 0x07,
    
    CMD_ADC_CH_SAVE =                        CMD_ADC_CH_OFFSET + 0x08,
    
    CMD_ADC_CH_OFFSET_COEFF =                CMD_ADC_CH_OFFSET + 0x09,
    
    CMD_ADC_CH_GAIN_COEFF =                    CMD_ADC_CH_OFFSET + 0x0A,
    
    CMD_ADC_CH_CAL_INTERNAL =                CMD_ADC_CH_OFFSET + 0x0B,
    
    CMD_ADC_CH_CAL_ZERO_SCALE =                CMD_ADC_CH_OFFSET + 0x0C,
    
    CMD_ADC_CH_CAL_FULL_SCALE =                CMD_ADC_CH_OFFSET + 0x0D,
    
    CMD_ADC_CH_CAL_RESET =                  CMD_ADC_CH_OFFSET + 0x0E,
    
    CMD_ADC_CH_CAL_SAVE =                    CMD_ADC_CH_OFFSET + 0x0F,
} CMD_ADC_CH_t;
#undef CMD_ADC_CH_OFFSET

typedef enum {
    CMD_MEAS_CH_VOLTAGE =                    CMD_MEAS_CH_CMD_OFFSET + 0x00,
    
    CMD_MEAS_CH_CURRENT =                    CMD_MEAS_CH_CMD_OFFSET + 0x01,
    
    CMD_MEAS_CH_TSENSOR =                    CMD_MEAS_CH_CMD_OFFSET + 0x02,
    
    CMD_MEAS_CH_TSENSOR_0 =                    CMD_MEAS_CH_CMD_OFFSET + 0x02,
    
    CMD_MEAS_CH_TSENSOR_1 =                    CMD_MEAS_CH_CMD_OFFSET + 0x03,
    
    CMD_MEAS_CH_TSENSOR_2 =                    CMD_MEAS_CH_CMD_OFFSET + 0x04,
    
    CMD_MEAS_CH_BIAS =                      CMD_MEAS_CH_CMD_OFFSET + 0x05,
    
    CMD_MEAS_CH_OFFSET =                  CMD_MEAS_CH_CMD_OFFSET + 0x06,
    
    CMD_MEAS_CH_TEMP =                      CMD_MEAS_CH_CMD_OFFSET + 0x07,
    
    CMD_MEAS_CH_AVDD =                      CMD_MEAS_CH_CMD_OFFSET + 0x08,
    
    CMD_MEAS_CH_IOVDD =                        CMD_MEAS_CH_CMD_OFFSET + 0x09,
    
    CMD_MEAS_CH_ALDO =                      CMD_MEAS_CH_CMD_OFFSET + 0x0A,
    
    CMD_MEAS_CH_DLDO =                      CMD_MEAS_CH_CMD_OFFSET + 0x0B,
    
    CMD_MEAS_CH_SS_TL =                        CMD_MEAS_CH_CMD_OFFSET + 0x0C,
    
    CMD_MEAS_CH_SS_BL=                     CMD_MEAS_CH_CMD_OFFSET + 0x0D,
    
    CMD_MEAS_CH_SS_BR =                        CMD_MEAS_CH_CMD_OFFSET + 0x0E,
    
    CMD_MEAS_CH_SS_TR =                        CMD_MEAS_CH_CMD_OFFSET + 0x0F,
} CMD_MEAS_CH_t;
#undef CMD_MEAS_CH_CMD_OFFSET
 

typedef enum {
    CMD_USB_SYSTEM_ENTER_BOOTLOADER =        CMD_USB_SYSTEM_OFFSET + 0x00,
    
    CMD_USB_SYSTEM_LIST_SCPI_COMMANDS =        CMD_USB_SYSTEM_OFFSET + 0x01,
    
    CMD_USB_SYSTEM_TWI_SCAN =                CMD_USB_SYSTEM_OFFSET + 0x02,
    
    CMD_USB_SYSTEM_TWI_MODE =                CMD_USB_SYSTEM_OFFSET + 0x03,
    
    CMD_USB_SYSTEM_DEBUG =                  CMD_USB_SYSTEM_OFFSET + 0x04
} CMD_USB_SYSTEM_t;
#undef CMD_USB_SYSTEM_OFFSET
 

typedef enum {
    CMD_USB_EEPROM_ERASE_ALL =              CMD_USB_EEPROM_CMD_OFFSET + 0x00,
    
    CMD_USB_EEPROM_ERASE_CONFIG =            CMD_USB_EEPROM_CMD_OFFSET + 0x01,
    
    CMD_USB_EEPROM_OFFSET =                    CMD_USB_EEPROM_CMD_OFFSET + 0x02,
    
    CMD_USB_EEPROM_GAIN =                    CMD_USB_EEPROM_CMD_OFFSET + 0x03,
    
    CMD_USB_EEPROM_VOLTAGE_OFFSET =            CMD_USB_EEPROM_CMD_OFFSET + 0x04,
    
    CMD_USB_EEPROM_CURRENT_OFFSET =            CMD_USB_EEPROM_CMD_OFFSET + 0x05,
    
    CMD_USB_EEPROM_VOLTAGE_GAIN =            CMD_USB_EEPROM_CMD_OFFSET + 0x06,
    
    CMD_USB_EEPROM_CURRENT_GAIN =            CMD_USB_EEPROM_CMD_OFFSET + 0x07,
} CMD_USB_EEPROM_t;
#undef CMD_USB_EEPROM_CMD_OFFSET

typedef enum {
    CMD_USB_ADC_VOLTAGE_CAL_ZERO =      CMD_USB_ADC_VOLTAGE_CMD_OFFSET + 0x00,
    
    CMD_USB_ADC_VOLTAGE_CAL_FULL =      CMD_USB_ADC_VOLTAGE_CMD_OFFSET + 0x01,
    
    CMD_USB_ADC_VOLTAGE_CAL_RESET =        CMD_USB_ADC_VOLTAGE_CMD_OFFSET + 0x02,
    
    CMD_USB_ADC_VOLTAGE_CAL_SAVE =      CMD_USB_ADC_VOLTAGE_CMD_OFFSET + 0x03,
    
    CMD_USB_ADC_VOLTAGE_PGA =            CMD_USB_ADC_VOLTAGE_CMD_OFFSET + 0x04,
    
    CMD_USB_ADC_VOLTAGE_MAX =            CMD_USB_ADC_VOLTAGE_CMD_OFFSET + 0x05,
    
    CMD_USB_ADC_VOLTAGE_OFFSET =      CMD_USB_ADC_VOLTAGE_CMD_OFFSET + 0x06,
    
    CMD_USB_ADC_VOLTAGE_GAIN =          CMD_USB_ADC_VOLTAGE_CMD_OFFSET + 0x07,

    CMD_USB_ADC_VOLTAGE_MAX_PGA =        CMD_USB_ADC_VOLTAGE_CMD_OFFSET + 0x08,
} CMD_USB_ADC_VOLTAGE_t;
#undef CMD_USB_ADC_VOLTAGE_CMD_OFFSET
 

typedef enum {
    CMD_USB_ADC_CURRENT_CAL_ZERO =      CMD_USB_ADC_CURRENT_CMD_OFFSET + 0x00,
    
    CMD_USB_ADC_CURRENT_CAL_FULL =      CMD_USB_ADC_CURRENT_CMD_OFFSET + 0x01,
    
    CMD_USB_ADC_CURRENT_CAL_RESET =        CMD_USB_ADC_CURRENT_CMD_OFFSET + 0x02,
    
    CMD_USB_ADC_CURRENT_CAL_SAVE =      CMD_USB_ADC_CURRENT_CMD_OFFSET + 0x03,
    
    CMD_USB_ADC_CURRENT_PGA =            CMD_USB_ADC_CURRENT_CMD_OFFSET + 0x04,
    
    CMD_USB_ADC_CURRENT_MAX =            CMD_USB_ADC_CURRENT_CMD_OFFSET + 0x05,
    
    CMD_USB_ADC_CURRENT_OFFSET =      CMD_USB_ADC_CURRENT_CMD_OFFSET + 0x06,
    
    CMD_USB_ADC_CURRENT_GAIN =          CMD_USB_ADC_CURRENT_CMD_OFFSET + 0x07,

    CMD_USB_ADC_CURRENT_MAX_PGA =        CMD_USB_ADC_CURRENT_CMD_OFFSET + 0x08,
} CMD_USB_ADC_CURRENT_t;
#undef CMD_USB_ADC_CURRENT_CMD_OFFSET

typedef enum {
    CMD_USB_SWEEP_TRIGGER =                    CMD_USB_SWEEP_OFFSET + 0x00,
} CMD_USB_SWEEP_t;
#undef CMD_USB_SWEEP_OFFSET

typedef enum {
    CMD_USB_SYSTEM_CONFIG_CURR_GAIN =        CMD_USB_SYSTEM_CONFIG_OFFSET + 0x00,
    
    CMD_USB_SYSTEM_CONFIG_CURR_RSENSE =        CMD_USB_SYSTEM_CONFIG_OFFSET + 0x01,
    
    CMD_USB_SYSTEM_CONFIG_VOLT_R1 =            CMD_USB_SYSTEM_CONFIG_OFFSET + 0x02,
    
    CMD_USB_SYSTEM_CONFIG_VOLT_R2 =            CMD_USB_SYSTEM_CONFIG_OFFSET + 0x03,
    
    CMD_USB_SYSTEM_CONFIG_SAVE =          CMD_USB_SYSTEM_CONFIG_OFFSET + 0x07,
} CMD_USB_SYSTEM_CONFIG_t;
#undef CMD_USB_SYSTEM_CONFIG_OFFSET
 
 
 
 
#endif /* __AMU_COMMANDS_H__ */