Skip to content
Snippets Groups Projects
Commit ef5d3b97 authored by Marco Filho's avatar Marco Filho
Browse files

Remove all files that should be on API

parent d1df55d9
No related branches found
No related tags found
2 merge requests!7Major refactor,!6Take API out of EPICS module
Hide whitespace changes
Inline Side-by-side
Showing
with 0 additions and 1609 deletions
vmmTbl.Makefile
+ 0
− 4
View file @ ef5d3b97
...@@ -11,11 +11,7 @@ TMPS += $(APPDB)/hybrid.template ...@@ -11,11 +11,7 @@ TMPS += $(APPDB)/hybrid.template
TMPS += $(APPDB)/vmm_tbl.template TMPS += $(APPDB)/vmm_tbl.template
SUBS = $(APPDB)/channels.sub SUBS = $(APPDB)/channels.sub
SOURCES += $(APPSRC)/hybrid.cpp
SOURCES += $(APPSRC)/vmm3a.cpp
SOURCES += $(APPSRC)/VmmTblAPI.cpp
SOURCES += $(APPSRC)/vmm_tbl.cpp SOURCES += $(APPSRC)/vmm_tbl.cpp
SOURCES += $(APPSRC)/VmmTblRegsMap.cpp
DBDS += $(APPSRC)/vmm_tbl.dbd DBDS += $(APPSRC)/vmm_tbl.dbd
......
vmmTblApp/src/VmmTblAPI.cpp deleted 100644 → 0
+ 0
− 446
View file @ d1df55d9
#include "VmmTblAPI.h"
#include <sstream>
#include <bitset>
#include <algorithm>
#include <chrono>
#include <thread>
#include <array>
#include "FrontEndBase.h"
void delayMilliseconds(int milliseconds) {
std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
}
VmmTblAPI::VmmTblAPI(RMMAPI* rmmApi, int ring, int node, std::string name)
: FrontEndBase(rmmApi, ring, node, name)
{
}
VmmTblAPI::~VmmTblAPI() {
}
void VmmTblAPI::acquire(bool acquire) {
if (acquire) {
enableAcquisition(false);
sendAll(true);
enableAcquisition(true);
} else {
enableAcquisition(false);
}
}
void VmmTblAPI::sendAll(bool useConfigCheck) {
configFE();
for(int hybrid = 0; hybrid <= HYBRIDS_PER_FEN; hybrid++) {
if (isHybridEnabled(hybrid)) {
configHybrid(hybrid);
for(int vmm = 0; vmm < VMMS_PER_HYBRID; vmm++) {
configVMM(hybrid, vmm, useConfigCheck);
}
}
}
}
void VmmTblAPI::enableAcquisition(bool enabled) {
userRegWrite("app_acq_enable", enabled);
userRegWrite("sc_acq_on_off", 0x00000000);
userRegWrite("sc_acq_on_off", 0x00000001);
userRegWrite("sc_acq_on_off", 0x00000000);
}
std::string VmmTblAPI::checkLinkStatus(int hyb) {
uint32_t result = readWriteRegs("sc_app_link_status", 0, "app_link_status");
int pos = 7 - hyb;
return intToHexString(result).substr(pos, 1);
}
void VmmTblAPI::configFE() {
userRegWrite("app_debug_data_format", 0);
userRegWrite("app_latency_reset", 27);
userRegWrite("app_latency_data_max", 1024);
userRegWrite("app_latency_data_jitter", 0);
userRegWrite("app_tp_offset_first", 100);
userRegWrite("app_tp_offset", 1000);
userRegWrite("app_tp_latency", 46);
userRegWrite("app_tp_number", 1);
userRegWrite("app_chmask", getChMap());
userRegWrite("sc_cfg_app", 0x00000000);
userRegWrite("sc_cfg_app", 0x00000001);
userRegWrite("sc_cfg_app", 0x00000000);
}
uint16_t VmmTblAPI::getChMap() {
std::string chMapString = "0000000000000000";
for (int hybrid = 0; hybrid < HYBRIDS_PER_FEN; hybrid++) {
if (isHybridEnabled(hybrid)) {
for (int vmm = 0; vmm < VMMS_PER_HYBRID; vmm++) {
chMapString.replace(15 - (hybrid * 2 + vmm), 1, "1");
}
}
}
uint16_t chMap = std::stoi(chMapString, nullptr, 2);
return chMap;
}
bool VmmTblAPI::enableHybrid(int hybrid, bool onOff) {
if(hybrid < HYBRIDS_PER_FEN) {
enabled_hybrids[hybrid] = onOff;
return true;
} else return false;
}
bool VmmTblAPI::isHybridEnabled(int hybrid) {
if(hybrid < HYBRIDS_PER_FEN) return enabled_hybrids[hybrid];
else return false;
}
Hybrid& VmmTblAPI::getHybrid(int index) {
if (index < 0 || index >= HYBRIDS_PER_FEN)
throw std::out_of_range("Invalid hybrid index");
return hybrids[index];
}
void VmmTblAPI::configHybrid(int hybrid_index) {
std::array<std::string, 3> registers = {"hyb_tp_skew0", "hyb_tp_width0", "hyb_tp_polarity0"};
for (const auto& reg : registers) {
unsigned short result = 0;
hybrids[hybrid_index].getRegister(reg, result);
userRegWrite(reg + std::to_string(hybrid_index), result);
}
uint32_t value = (1 << hybrid_index);
userRegWrite("sc_cfg_hyb", 0x0);
userRegWrite("sc_cfg_hyb", value);
userRegWrite("sc_cfg_hyb", 0x0);
}
std::string VmmTblAPI::readFwVersion(int hyb) {
uint32_t result = readWriteRegs("sc_i2c_firmware_version",
hyb,
"hyb_i2c_firmware_version0" + std::to_string(hyb));
return intToHexString(result);
}
std::string VmmTblAPI::readGeoPos(int hyb) {
uint32_t result = readWriteRegs("sc_i2c_geo_id", hyb, "hyb_i2c_geoid0" + std::to_string(hyb));
return intToHexString(result).substr(6);
}
std::string VmmTblAPI::readIDChip(int hyb) {
std::string full_string;
uint32_t result = 0;
result = readWriteRegs("sc_i2c_hybrid_id", hyb, "hyb_i2c_hybrid_id00" + std::to_string(hyb));
full_string += intToHexString(result);
result = readWriteRegs("sc_i2c_hybrid_id", hyb, "hyb_i2c_hybrid_id10" + std::to_string(hyb));
full_string += intToHexString(result);
result = readWriteRegs("sc_i2c_hybrid_id", hyb, "hyb_i2c_hybrid_id20" + std::to_string(hyb));
full_string += intToHexString(result);
result = readWriteRegs("sc_i2c_hybrid_id", hyb, "hyb_i2c_hybrid_id30" + std::to_string(hyb));
full_string += intToHexString(result);
return full_string;
}
bool VmmTblAPI::configVMM(int hybrid_index, int vmm_index, bool enableConfigCheck)
{
bool result = true;
bool ok;
std::vector<std::string> globalRegisters;
globalRegisters.clear();
fillGlobalRegisters(globalRegisters, hybrid_index, vmm_index);
std::cout << "Global Registers:" << std::endl;
for (const auto& reg : globalRegisters) {
std::cout << reg << std::endl;
}
if(globalRegisters.size()!=3){
std::cout << "ERROR Global SPI does not have 3 words" << std::endl;
return -1;
}
std::vector<std::string> channelRegisters;
channelRegisters.clear();
fillChRegisters(channelRegisters, hybrid_index, vmm_index);
if(channelRegisters.size() != 64){
std::cout << "ERROR Channel registers do not have 64 values" << std::endl;
return -1;
}
std::vector<std::string> globalRegisters2;
globalRegisters2.clear();
fillGlobalRegisters2(globalRegisters2, hybrid_index, vmm_index);
if(globalRegisters2.size()!=3){
std::cout << "ERROR Global SPI does not have 3 words" << std::endl;
return -1;
}
int idx = hybrid_index * 2 + vmm_index;
std::string sVmmIndex = "99";
if(idx < 10) sVmmIndex = "0" + std::to_string(idx);
else if(idx < 16) sVmmIndex = std::to_string(idx);
bool g_use_config_check = true;
if(g_use_config_check) {
//reset I2C address 65 register 0
if(enableConfigCheck) {
// TODO: Check with we need that (the enableConfigCheck is always false in the VMM code)
//uint32_t value = (1 << hybrid_index);
//ESS_WriteSc("sc_i2c_reset_config_check", 0x00000000, ok);
//ESS_WriteSc("sc_i2c_reset_config_check", value, ok);
//ESS_WriteSc("sc_i2c_reset_config_check", 0x00000000, ok);
}
}
unsigned int firstGlobalRegSPI_2 = 0;
unsigned int lastGlobalRegSPI_2 = 2;
unsigned int firstGlobalRegSPI_1 = 67;
unsigned int lastGlobalRegSPI_1 = 69;
// global SPI / VMM3: global bank 0
for(unsigned int i = firstGlobalRegSPI_2; i <= lastGlobalRegSPI_2; i++) {
std::string param = "vmm_global_bank2_sp" + std::to_string(i - firstGlobalRegSPI_2) + sVmmIndex;
uint32_t value = std::stoul(globalRegisters2[i - firstGlobalRegSPI_2], nullptr, 2);
userRegWrite(param, value);
}
//channel SPI
for(unsigned int i = 0; i < CHANNELS_PER_VMM; i++) {
std::string position_str = std::to_string(i);
if (position_str.size() == 1) position_str = "0" + position_str;
std::string param = "vmm_ch" + position_str + sVmmIndex;
uint32_t value = std::stoul(channelRegisters[i], nullptr, 2);
std::cout << "param: " << param << std::endl;
userRegWrite(param, value);
}
// global SPI / VMM3: global bank 1
for(unsigned int i = firstGlobalRegSPI_1; i <= lastGlobalRegSPI_1; i++) {
std::string param = "vmm_global_bank1_sp" + std::to_string(i - firstGlobalRegSPI_1) + sVmmIndex;
uint32_t value = std::stoul(globalRegisters[i - firstGlobalRegSPI_1], nullptr, 2);
userRegWrite(param, value);
}
uint32_t value = (1 << idx);
userRegWrite("sc_cfg_vmm", 0x00000000);
userRegWrite("sc_cfg_vmm", value);
userRegWrite("sc_cfg_vmm", 0x00000000);
return result;
}
void VmmTblAPI::fillGlobalRegisters(std::vector<std::string>& global, int hybrid_index, int vmm_index)
{
unsigned short result;
global.clear();
int sequence = 0;
// GLOBAL SPI 0
std::string spi0 = "00000000000000000000000000000000";
//[0,3] reserved
sequence += 4;
// Function to replace a bit in the spi0 string with a value from VMM settings
auto replaceVMMBit = [&](int index, const std::string& settingName) {
// Convert value to '1' if it's not zero, otherwise '0'
hybrids[hybrid_index].getVMM(vmm_index).getRegister(settingName, result);
spi0[index] = '0' + (result != 0);
};
const std::vector<std::string> settings = {"slvs", "s32", "stcr", "ssart", "srec", "stlc", "sbip", "srat", "sfrst",
"slvsbc", "slvstp", "slvstk", "slvsdt", "slvsart", "slvstki", "slvsena",
"slvs6b", "slh", "slxh", "stgc", "reset1", "reset2"};
for (const auto& setting : settings) {
if (setting == "reset1") sequence += 5; //[25,29] not used
replaceVMMBit(sequence, setting);
sequence++;
}
global.push_back(spi0);
// GLOBAL SPI 1
// Define a function to populate spi string based on VMM settings
auto populateSPI1 = [&](const std::vector<std::pair<std::string, int>>& settings) {
std::string spi;
int sequence = 0;
for (const auto& setting : settings) {
hybrids[hybrid_index].getVMM(vmm_index).getRegister(setting.first, result);
std::string binary_string = std::bitset<16>(result).to_string().substr(16 - setting.second);
if (setting.first == "sdt") {
// Populate threshold DAC lowest 6 bits
for (int i = 4; i < 10; ++i) spi += binary_string[i];
} else spi += binary_string;
sequence += setting.second;
}
// Append '0' to the end of spi to reserve the last bit: [31] reserved
spi += '0';
// Push back the populated spi string to the global vector
global.push_back(spi);
};
// Populate SPI 1 settings
populateSPI1({{"sdt", 10},{"sdp10", 10}, {"sc10b", 2}, {"sc8b", 2},
{"sc6b", 3}, {"s8b", 1}, {"s6b", 1}, {"s10b", 1},
{"sdcks", 1}, {"sdcka", 1}, {"sdck6b", 1}, {"sdrv", 1},
{"stpp", 1}});
// GLOBAL SPI 2
// Define a function to populate spi string based on VMM settings
auto populateSPI2 = [&](const std::vector<std::pair<std::string, int>>& settings) {
std::string spi;
int sequence = 0;
for (const auto& setting : settings) {
hybrids[hybrid_index].getVMM(vmm_index).getRegister(setting.first, result);
std::string binary_string = std::bitset<16>(result).to_string().substr(16 - setting.second);
if (setting.first == "sdt") {
// Populate threshold DAC highest 4 bits
for (int i = 0; i < 4; ++i) {
spi += binary_string[i];
sequence++;
}
} else {
spi += binary_string;
sequence += setting.second;
}
}
// Push back the populated spi string to the global vector
global.push_back(spi);
};
// Populate SPI 2 settings
populateSPI2({{"sp", 1}, {"sdp", 1}, {"sbmx", 1}, {"sbft", 1}, {"sbfp", 1},
{"sbfm", 1}, {"slg", 1}, {"sm5_sm0", 6}, {"scmx", 1}, {"sfa", 1},
{"sfam", 1}, {"st", 2}, {"sfm", 1}, {"sg", 3}, {"sng", 1}, {"stot", 1},
{"sttt", 1}, {"ssh", 1}, {"stc", 2}, {"sdt", 10}});
}
void VmmTblAPI::fillChRegisters(std::vector<std::string>& registers, int hybrid_index, int vmm_index)
{
registers.clear();
unsigned short result;
auto populateRegisters = [&](const std::vector<std::pair<std::string, int>>& regs, int channel) {
std::string _reg = "00000000";
int sequence = 8;
for (const auto& reg : regs) {
hybrids[hybrid_index].getVMM(vmm_index).getRegister(reg.first, channel, result);
std::string binary_string = std::bitset<16>(result).to_string().substr(16 - reg.second);
if (reg.first == "sd" || reg.first == "sz10b" ||
reg.first == "sz08b" || reg.first == "sz06b") {
//According to ATLAS software, has to be reversed
std::reverse(binary_string.begin(), binary_string.end());
}
_reg += binary_string;
sequence += reg.second;
}
// Append '0' to the end of spi to reserve the last bit: [31] reserved
_reg += "0";
// Push back the populated _reg string to the registers vector
registers.push_back(_reg);
};
std::vector<std::pair<std::string, int>> registers_map = {{"sc", 1}, {"sl", 1}, {"st", 1},
{"sth", 1}, {"sm", 1}, {"smx", 1},
{"sd", 5}, {"sz10b", 5}, {"sz08b", 4},
{"sz06b", 3}};
for(int ch = 0; ch < CHANNELS_PER_VMM; ch++) {
populateRegisters(registers_map, ch);
}
}
void VmmTblAPI::fillGlobalRegisters2(std::vector<std::string>& global, int hybrid_index, int vmm_index)
{
unsigned short result;
int sequence = 0;
// GLOBAL SPI 0
std::string spi0 = "00000000000000000000000000000000";
//[0,30] not used
sequence+=31;
// magic number on BCID [31]
hybrids[hybrid_index].getVMM(vmm_index).getRegister("nskipm_i", result);
spi0.replace(sequence, 1, std::to_string(result));
global.push_back(spi0);
// GLOBAL SPI 1
std::string spi1 = "00000000000000000000000000000000";
hybrids[hybrid_index].getVMM(vmm_index).getRegister("sL0cktest", result);
// clocks when L0 core disabled [0]
spi1.replace(sequence, 1, std::to_string(result));
sequence++;
//invert DCK [1]
hybrids[hybrid_index].getVMM(vmm_index).getRegister("sL0dckinv", result);
spi1.replace(sequence, 1, std::to_string(result));
sequence++;
//invert BCCLK [2]
hybrids[hybrid_index].getVMM(vmm_index).getRegister("sL0ckinv", result);
spi1.replace(sequence, 1, std::to_string(result));
sequence++;
//L0 core
hybrids[hybrid_index].getVMM(vmm_index).getRegister("sL0ena", result);
spi1.replace(sequence, 1, std::to_string(result));
sequence++;
global.push_back(spi1);
// GLOBAL SPI 2
std::string spi2 = "00000000000000000000000000000000";
global.push_back(spi2);
}
int VmmTblAPI::readADC(int hybrid_index, int vmm_index) {
int adc_result = 0;
int vmm = hybrid_index * 2 + vmm_index;
std::string sVmmIndex = "99";
if(vmm < 10) sVmmIndex = "0" + std::to_string(vmm);
else if(vmm < 16) sVmmIndex = std::to_string(vmm);
uint32_t result = readWriteRegs("sc_i2c_vmm_adc", vmm, "vmm_i2c_adc" + sVmmIndex);
adc_result = (result & 0xFFFF) >> 4; // bit shift
unsigned short sp_value = 0;
hybrids[hybrid_index].getVMM(vmm_index).getRegister("sp", sp_value);
unsigned sm5_sm0_value = 0;
hybrids[hybrid_index].getVMM(vmm_index).getRegister("sm5_sm0", sp_value);
if((sp_value != 0) && (sm5_sm0_value == 1)) adc_result = 1200 - adc_result;
return adc_result;
}
uint32_t VmmTblAPI::readWriteRegs(std::string command_reg, int index, std::string read_reg) {
unsigned int data = 0x00000000;
userRegWrite(command_reg, data);
data = (1 << index);
userRegWrite(command_reg, data);
//Do not read registers back too soon, otherwise old ADC value is read
delayMilliseconds(7);
uint32_t value = userRegRead(read_reg);
userRegWrite(command_reg, 0x0);
return value;
}
vmmTblApp/src/VmmTblAPI.h deleted 100644 → 0
+ 0
− 44
View file @ d1df55d9
#pragma once
#include <vector>
#include <string>
#include <map>
#include <vector>
#include <memory>
#include <iostream>
#include "FrontEndBase.h"
#include "FrontEndFactory.h"
#include "VmmTblRegsMap.h"
#include "hybrid.h"
class VmmTblAPI : public FrontEndBase {
public:
VmmTblAPI(RMMAPI* rmmApi, int ring, int node, std::string name);
~VmmTblAPI();
void configHybrid(int hybrid_index);
bool configVMM(int hybrid_index, int vmm_index, bool enableConfigCheck=false);
void fillGlobalRegisters(std::vector<std::string>& global, int hybrid_index, int vmm_index);
void fillGlobalRegisters2(std::vector<std::string>& global, int hybrid_index, int vmm_index);
void fillChRegisters(std::vector<std::string>& registers, int hybrid_index, int vmm_index);
int readADC(int hybrid_index, int vmm_index);
Hybrid& getHybrid(int index);
bool enableHybrid(int hybrid, bool onOff);
bool isHybridEnabled(int hybrid);
void acquire(bool acquire);
std::string readFwVersion(int hyb);
std::string readIDChip(int hyb);
std::string readGeoPos(int hyb);
std::string checkLinkStatus(int hyb);
void configFE();
private:
Hybrid hybrids[HYBRIDS_PER_FEN];
bool enabled_hybrids[HYBRIDS_PER_FEN] = {};
uint32_t readWriteRegs(std::string command_reg, int index, std::string read_reg);
uint16_t getChMap();
void sendAll(bool useConfigCheck);
void enableAcquisition(bool enabled);
uint8_t linkStatus[HYBRIDS_PER_FEN];
};
vmmTblApp/src/VmmTblRegsMap.cpp deleted 100644 → 0
+ 0
− 807
View file @ d1df55d9
#include "VmmTblRegsMap.h"
extern const std::unordered_map<std::string, uint32_t> vmm_tbl_register_map = {
{ "REGBANK_VERSION", 0x00000000 },
{ "PHASH", 0x00000004 },
{ "ro_test", 0x00000008 },
{ "rw_test", 0x0000000c },
{ "GIT_HASH2", 0x00000010 },
{ "GIT_HASH1", 0x00000014 },
{ "GIT_HASH0", 0x00000018 },
{ "led_ctl", 0x0000001c },
{ "vmm_clk_freq", 0x00000020 },
{ "test_data_en", 0x00000024 },
{ "test_data_rate", 0x00000028 },
{ "hit_cnt_rst", 0x0000002c },
{ "hit_cnt_hv00", 0x00000030 },
{ "hit_cnt_hv01", 0x00000034 },
{ "hit_cnt_hv02", 0x00000038 },
{ "hit_cnt_hv03", 0x0000003c },
{ "sc_acq_on_off", 0x00000040 },
{ "sc_cfg_app", 0x00000044 },
{ "sc_cfg_hyb", 0x00000048 },
{ "sc_cfg_vmm", 0x0000004c },
{ "sc_eeprom_board_id", 0x00000050 },
{ "sc_app_link_status", 0x00000054 },
{ "sc_app_reset_assister", 0x00000058 },
{ "sc_app_board_id", 0x0000005c },
{ "sc_i2c_geo_id", 0x00000060 },
{ "sc_i2c_firmware_version", 0x00000064 },
{ "sc_i2c_hybrid_id", 0x00000068 },
{ "sc_i2c_config_check", 0x0000006c },
{ "sc_i2c_reset_config_check", 0x00000070 },
{ "sc_i2c_vmm_adc", 0x00000074 },
{ "eeprom_board_id", 0x00000078 },
{ "app_board_id", 0x0000007c },
{ "app_debug_data_format", 0x00000080 },
{ "app_latency_reset", 0x00000084 },
{ "app_latency_data_max", 0x00000088 },
{ "app_latency_data_jitter", 0x0000008c },
{ "app_chmask", 0x00000090 },
{ "app_tp_offset_first", 0x00000094 },
{ "app_tp_offset", 0x00000098 },
{ "app_tp_latency", 0x0000009c },
{ "app_tp_number", 0x000000a0 },
{ "app_acq_enable", 0x000000a4 },
{ "app_link_status", 0x000000a8 },
{ "hyb_tp_skew00", 0x000000ac },
{ "hyb_tp_skew01", 0x000000b0 },
{ "hyb_tp_skew02", 0x000000b4 },
{ "hyb_tp_skew03", 0x000000b8 },
{ "hyb_tp_skew04", 0x000000bc },
{ "hyb_tp_width00", 0x000000c0 },
{ "hyb_tp_width01", 0x000000c4 },
{ "hyb_tp_width02", 0x000000c8 },
{ "hyb_tp_width03", 0x000000cc },
{ "hyb_tp_width04", 0x000000d0 },
{ "hyb_tp_polarity00", 0x000000d4 },
{ "hyb_tp_polarity01", 0x000000d8 },
{ "hyb_tp_polarity02", 0x000000dc },
{ "hyb_tp_polarity03", 0x000000e0 },
{ "hyb_tp_polarity04", 0x000000e4 },
{ "hyb_i2c_geoid00", 0x000000e8 },
{ "hyb_i2c_geoid01", 0x000000ec },
{ "hyb_i2c_geoid02", 0x000000f0 },
{ "hyb_i2c_geoid03", 0x000000f4 },
{ "hyb_i2c_geoid04", 0x000000f8 },
{ "hyb_i2c_firmware_version00", 0x000000fc },
{ "hyb_i2c_firmware_version01", 0x00000100 },
{ "hyb_i2c_firmware_version02", 0x00000104 },
{ "hyb_i2c_firmware_version03", 0x00000108 },
{ "hyb_i2c_firmware_version04", 0x0000010c },
{ "hyb_i2c_hybrid_id000", 0x00000110 },
{ "hyb_i2c_hybrid_id001", 0x00000114 },
{ "hyb_i2c_hybrid_id002", 0x00000118 },
{ "hyb_i2c_hybrid_id003", 0x0000011c },
{ "hyb_i2c_hybrid_id004", 0x00000120 },
{ "hyb_i2c_hybrid_id100", 0x00000124 },
{ "hyb_i2c_hybrid_id101", 0x00000128 },
{ "hyb_i2c_hybrid_id102", 0x0000012c },
{ "hyb_i2c_hybrid_id103", 0x00000130 },
{ "hyb_i2c_hybrid_id104", 0x00000134 },
{ "hyb_i2c_hybrid_id200", 0x00000138 },
{ "hyb_i2c_hybrid_id201", 0x0000013c },
{ "hyb_i2c_hybrid_id202", 0x00000140 },
{ "hyb_i2c_hybrid_id203", 0x00000144 },
{ "hyb_i2c_hybrid_id204", 0x00000148 },
{ "hyb_i2c_hybrid_id300", 0x0000014c },
{ "hyb_i2c_hybrid_id301", 0x00000150 },
{ "hyb_i2c_hybrid_id302", 0x00000154 },
{ "hyb_i2c_hybrid_id303", 0x00000158 },
{ "hyb_i2c_hybrid_id304", 0x0000015c },
{ "hyb_i2c_config_check00", 0x00000160 },
{ "hyb_i2c_config_check01", 0x00000164 },
{ "hyb_i2c_config_check02", 0x00000168 },
{ "hyb_i2c_config_check03", 0x0000016c },
{ "hyb_i2c_config_check04", 0x00000170 },
{ "vmm_i2c_adc00", 0x00000174 },
{ "vmm_i2c_adc01", 0x00000178 },
{ "vmm_i2c_adc02", 0x0000017c },
{ "vmm_i2c_adc03", 0x00000180 },
{ "vmm_i2c_adc04", 0x00000184 },
{ "vmm_i2c_adc05", 0x00000188 },
{ "vmm_i2c_adc06", 0x0000018c },
{ "vmm_i2c_adc07", 0x00000190 },
{ "vmm_i2c_adc08", 0x00000194 },
{ "vmm_i2c_adc09", 0x00000198 },
{ "vmm_global_bank2_sp000", 0x0000019c },
{ "vmm_global_bank2_sp001", 0x000001a0 },
{ "vmm_global_bank2_sp002", 0x000001a4 },
{ "vmm_global_bank2_sp003", 0x000001a8 },
{ "vmm_global_bank2_sp004", 0x000001ac },
{ "vmm_global_bank2_sp005", 0x000001b0 },
{ "vmm_global_bank2_sp006", 0x000001b4 },
{ "vmm_global_bank2_sp007", 0x000001b8 },
{ "vmm_global_bank2_sp008", 0x000001bc },
{ "vmm_global_bank2_sp009", 0x000001c0 },
{ "vmm_global_bank2_sp100", 0x000001c4 },
{ "vmm_global_bank2_sp101", 0x000001c8 },
{ "vmm_global_bank2_sp102", 0x000001cc },
{ "vmm_global_bank2_sp103", 0x000001d0 },
{ "vmm_global_bank2_sp104", 0x000001d4 },
{ "vmm_global_bank2_sp105", 0x000001d8 },
{ "vmm_global_bank2_sp106", 0x000001dc },
{ "vmm_global_bank2_sp107", 0x000001e0 },
{ "vmm_global_bank2_sp108", 0x000001e4 },
{ "vmm_global_bank2_sp109", 0x000001e8 },
{ "vmm_global_bank2_sp200", 0x000001ec },
{ "vmm_global_bank2_sp201", 0x000001f0 },
{ "vmm_global_bank2_sp202", 0x000001f4 },
{ "vmm_global_bank2_sp203", 0x000001f8 },
{ "vmm_global_bank2_sp204", 0x000001fc },
{ "vmm_global_bank2_sp205", 0x00000200 },
{ "vmm_global_bank2_sp206", 0x00000204 },
{ "vmm_global_bank2_sp207", 0x00000208 },
{ "vmm_global_bank2_sp208", 0x0000020c },
{ "vmm_global_bank2_sp209", 0x00000210 },
{ "vmm_ch0000", 0x00000214 },
{ "vmm_ch0001", 0x00000218 },
{ "vmm_ch0002", 0x0000021c },
{ "vmm_ch0003", 0x00000220 },
{ "vmm_ch0004", 0x00000224 },
{ "vmm_ch0005", 0x00000228 },
{ "vmm_ch0006", 0x0000022c },
{ "vmm_ch0007", 0x00000230 },
{ "vmm_ch0008", 0x00000234 },
{ "vmm_ch0009", 0x00000238 },
{ "vmm_ch0100", 0x0000023c },
{ "vmm_ch0101", 0x00000240 },
{ "vmm_ch0102", 0x00000244 },
{ "vmm_ch0103", 0x00000248 },
{ "vmm_ch0104", 0x0000024c },
{ "vmm_ch0105", 0x00000250 },
{ "vmm_ch0106", 0x00000254 },
{ "vmm_ch0107", 0x00000258 },
{ "vmm_ch0108", 0x0000025c },
{ "vmm_ch0109", 0x00000260 },
{ "vmm_ch0200", 0x00000264 },
{ "vmm_ch0201", 0x00000268 },
{ "vmm_ch0202", 0x0000026c },
{ "vmm_ch0203", 0x00000270 },
{ "vmm_ch0204", 0x00000274 },
{ "vmm_ch0205", 0x00000278 },
{ "vmm_ch0206", 0x0000027c },
{ "vmm_ch0207", 0x00000280 },
{ "vmm_ch0208", 0x00000284 },
{ "vmm_ch0209", 0x00000288 },
{ "vmm_ch0300", 0x0000028c },
{ "vmm_ch0301", 0x00000290 },
{ "vmm_ch0302", 0x00000294 },
{ "vmm_ch0303", 0x00000298 },
{ "vmm_ch0304", 0x0000029c },
{ "vmm_ch0305", 0x000002a0 },
{ "vmm_ch0306", 0x000002a4 },
{ "vmm_ch0307", 0x000002a8 },
{ "vmm_ch0308", 0x000002ac },
{ "vmm_ch0309", 0x000002b0 },
{ "vmm_ch0400", 0x000002b4 },
{ "vmm_ch0401", 0x000002b8 },
{ "vmm_ch0402", 0x000002bc },
{ "vmm_ch0403", 0x000002c0 },
{ "vmm_ch0404", 0x000002c4 },
{ "vmm_ch0405", 0x000002c8 },
{ "vmm_ch0406", 0x000002cc },
{ "vmm_ch0407", 0x000002d0 },
{ "vmm_ch0408", 0x000002d4 },
{ "vmm_ch0409", 0x000002d8 },
{ "vmm_ch0500", 0x000002dc },
{ "vmm_ch0501", 0x000002e0 },
{ "vmm_ch0502", 0x000002e4 },
{ "vmm_ch0503", 0x000002e8 },
{ "vmm_ch0504", 0x000002ec },
{ "vmm_ch0505", 0x000002f0 },
{ "vmm_ch0506", 0x000002f4 },
{ "vmm_ch0507", 0x000002f8 },
{ "vmm_ch0508", 0x000002fc },
{ "vmm_ch0509", 0x00000300 },
{ "vmm_ch0600", 0x00000304 },
{ "vmm_ch0601", 0x00000308 },
{ "vmm_ch0602", 0x0000030c },
{ "vmm_ch0603", 0x00000310 },
{ "vmm_ch0604", 0x00000314 },
{ "vmm_ch0605", 0x00000318 },
{ "vmm_ch0606", 0x0000031c },
{ "vmm_ch0607", 0x00000320 },
{ "vmm_ch0608", 0x00000324 },
{ "vmm_ch0609", 0x00000328 },
{ "vmm_ch0700", 0x0000032c },
{ "vmm_ch0701", 0x00000330 },
{ "vmm_ch0702", 0x00000334 },
{ "vmm_ch0703", 0x00000338 },
{ "vmm_ch0704", 0x0000033c },
{ "vmm_ch0705", 0x00000340 },
{ "vmm_ch0706", 0x00000344 },
{ "vmm_ch0707", 0x00000348 },
{ "vmm_ch0708", 0x0000034c },
{ "vmm_ch0709", 0x00000350 },
{ "vmm_ch0800", 0x00000354 },
{ "vmm_ch0801", 0x00000358 },
{ "vmm_ch0802", 0x0000035c },
{ "vmm_ch0803", 0x00000360 },
{ "vmm_ch0804", 0x00000364 },
{ "vmm_ch0805", 0x00000368 },
{ "vmm_ch0806", 0x0000036c },
{ "vmm_ch0807", 0x00000370 },
{ "vmm_ch0808", 0x00000374 },
{ "vmm_ch0809", 0x00000378 },
{ "vmm_ch0900", 0x0000037c },
{ "vmm_ch0901", 0x00000380 },
{ "vmm_ch0902", 0x00000384 },
{ "vmm_ch0903", 0x00000388 },
{ "vmm_ch0904", 0x0000038c },
{ "vmm_ch0905", 0x00000390 },
{ "vmm_ch0906", 0x00000394 },
{ "vmm_ch0907", 0x00000398 },
{ "vmm_ch0908", 0x0000039c },
{ "vmm_ch0909", 0x000003a0 },
{ "vmm_ch1000", 0x000003a4 },
{ "vmm_ch1001", 0x000003a8 },
{ "vmm_ch1002", 0x000003ac },
{ "vmm_ch1003", 0x000003b0 },
{ "vmm_ch1004", 0x000003b4 },
{ "vmm_ch1005", 0x000003b8 },
{ "vmm_ch1006", 0x000003bc },
{ "vmm_ch1007", 0x000003c0 },
{ "vmm_ch1008", 0x000003c4 },
{ "vmm_ch1009", 0x000003c8 },
{ "vmm_ch1100", 0x000003cc },
{ "vmm_ch1101", 0x000003d0 },
{ "vmm_ch1102", 0x000003d4 },
{ "vmm_ch1103", 0x000003d8 },
{ "vmm_ch1104", 0x000003dc },
{ "vmm_ch1105", 0x000003e0 },
{ "vmm_ch1106", 0x000003e4 },
{ "vmm_ch1107", 0x000003e8 },
{ "vmm_ch1108", 0x000003ec },
{ "vmm_ch1109", 0x000003f0 },
{ "vmm_ch1200", 0x000003f4 },
{ "vmm_ch1201", 0x000003f8 },
{ "vmm_ch1202", 0x000003fc },
{ "vmm_ch1203", 0x00000400 },
{ "vmm_ch1204", 0x00000404 },
{ "vmm_ch1205", 0x00000408 },
{ "vmm_ch1206", 0x0000040c },
{ "vmm_ch1207", 0x00000410 },
{ "vmm_ch1208", 0x00000414 },
{ "vmm_ch1209", 0x00000418 },
{ "vmm_ch1300", 0x0000041c },
{ "vmm_ch1301", 0x00000420 },
{ "vmm_ch1302", 0x00000424 },
{ "vmm_ch1303", 0x00000428 },
{ "vmm_ch1304", 0x0000042c },
{ "vmm_ch1305", 0x00000430 },
{ "vmm_ch1306", 0x00000434 },
{ "vmm_ch1307", 0x00000438 },
{ "vmm_ch1308", 0x0000043c },
{ "vmm_ch1309", 0x00000440 },
{ "vmm_ch1400", 0x00000444 },
{ "vmm_ch1401", 0x00000448 },
{ "vmm_ch1402", 0x0000044c },
{ "vmm_ch1403", 0x00000450 },
{ "vmm_ch1404", 0x00000454 },
{ "vmm_ch1405", 0x00000458 },
{ "vmm_ch1406", 0x0000045c },
{ "vmm_ch1407", 0x00000460 },
{ "vmm_ch1408", 0x00000464 },
{ "vmm_ch1409", 0x00000468 },
{ "vmm_ch1500", 0x0000046c },
{ "vmm_ch1501", 0x00000470 },
{ "vmm_ch1502", 0x00000474 },
{ "vmm_ch1503", 0x00000478 },
{ "vmm_ch1504", 0x0000047c },
{ "vmm_ch1505", 0x00000480 },
{ "vmm_ch1506", 0x00000484 },
{ "vmm_ch1507", 0x00000488 },
{ "vmm_ch1508", 0x0000048c },
{ "vmm_ch1509", 0x00000490 },
{ "vmm_ch1600", 0x00000494 },
{ "vmm_ch1601", 0x00000498 },
{ "vmm_ch1602", 0x0000049c },
{ "vmm_ch1603", 0x000004a0 },
{ "vmm_ch1604", 0x000004a4 },
{ "vmm_ch1605", 0x000004a8 },
{ "vmm_ch1606", 0x000004ac },
{ "vmm_ch1607", 0x000004b0 },
{ "vmm_ch1608", 0x000004b4 },
{ "vmm_ch1609", 0x000004b8 },
{ "vmm_ch1700", 0x000004bc },
{ "vmm_ch1701", 0x000004c0 },
{ "vmm_ch1702", 0x000004c4 },
{ "vmm_ch1703", 0x000004c8 },
{ "vmm_ch1704", 0x000004cc },
{ "vmm_ch1705", 0x000004d0 },
{ "vmm_ch1706", 0x000004d4 },
{ "vmm_ch1707", 0x000004d8 },
{ "vmm_ch1708", 0x000004dc },
{ "vmm_ch1709", 0x000004e0 },
{ "vmm_ch1800", 0x000004e4 },
{ "vmm_ch1801", 0x000004e8 },
{ "vmm_ch1802", 0x000004ec },
{ "vmm_ch1803", 0x000004f0 },
{ "vmm_ch1804", 0x000004f4 },
{ "vmm_ch1805", 0x000004f8 },
{ "vmm_ch1806", 0x000004fc },
{ "vmm_ch1807", 0x00000500 },
{ "vmm_ch1808", 0x00000504 },
{ "vmm_ch1809", 0x00000508 },
{ "vmm_ch1900", 0x0000050c },
{ "vmm_ch1901", 0x00000510 },
{ "vmm_ch1902", 0x00000514 },
{ "vmm_ch1903", 0x00000518 },
{ "vmm_ch1904", 0x0000051c },
{ "vmm_ch1905", 0x00000520 },
{ "vmm_ch1906", 0x00000524 },
{ "vmm_ch1907", 0x00000528 },
{ "vmm_ch1908", 0x0000052c },
{ "vmm_ch1909", 0x00000530 },
{ "vmm_ch2000", 0x00000534 },
{ "vmm_ch2001", 0x00000538 },
{ "vmm_ch2002", 0x0000053c },
{ "vmm_ch2003", 0x00000540 },
{ "vmm_ch2004", 0x00000544 },
{ "vmm_ch2005", 0x00000548 },
{ "vmm_ch2006", 0x0000054c },
{ "vmm_ch2007", 0x00000550 },
{ "vmm_ch2008", 0x00000554 },
{ "vmm_ch2009", 0x00000558 },
{ "vmm_ch2100", 0x0000055c },
{ "vmm_ch2101", 0x00000560 },
{ "vmm_ch2102", 0x00000564 },
{ "vmm_ch2103", 0x00000568 },
{ "vmm_ch2104", 0x0000056c },
{ "vmm_ch2105", 0x00000570 },
{ "vmm_ch2106", 0x00000574 },
{ "vmm_ch2107", 0x00000578 },
{ "vmm_ch2108", 0x0000057c },
{ "vmm_ch2109", 0x00000580 },
{ "vmm_ch2200", 0x00000584 },
{ "vmm_ch2201", 0x00000588 },
{ "vmm_ch2202", 0x0000058c },
{ "vmm_ch2203", 0x00000590 },
{ "vmm_ch2204", 0x00000594 },
{ "vmm_ch2205", 0x00000598 },
{ "vmm_ch2206", 0x0000059c },
{ "vmm_ch2207", 0x000005a0 },
{ "vmm_ch2208", 0x000005a4 },
{ "vmm_ch2209", 0x000005a8 },
{ "vmm_ch2300", 0x000005ac },
{ "vmm_ch2301", 0x000005b0 },
{ "vmm_ch2302", 0x000005b4 },
{ "vmm_ch2303", 0x000005b8 },
{ "vmm_ch2304", 0x000005bc },
{ "vmm_ch2305", 0x000005c0 },
{ "vmm_ch2306", 0x000005c4 },
{ "vmm_ch2307", 0x000005c8 },
{ "vmm_ch2308", 0x000005cc },
{ "vmm_ch2309", 0x000005d0 },
{ "vmm_ch2400", 0x000005d4 },
{ "vmm_ch2401", 0x000005d8 },
{ "vmm_ch2402", 0x000005dc },
{ "vmm_ch2403", 0x000005e0 },
{ "vmm_ch2404", 0x000005e4 },
{ "vmm_ch2405", 0x000005e8 },
{ "vmm_ch2406", 0x000005ec },
{ "vmm_ch2407", 0x000005f0 },
{ "vmm_ch2408", 0x000005f4 },
{ "vmm_ch2409", 0x000005f8 },
{ "vmm_ch2500", 0x000005fc },
{ "vmm_ch2501", 0x00000600 },
{ "vmm_ch2502", 0x00000604 },
{ "vmm_ch2503", 0x00000608 },
{ "vmm_ch2504", 0x0000060c },
{ "vmm_ch2505", 0x00000610 },
{ "vmm_ch2506", 0x00000614 },
{ "vmm_ch2507", 0x00000618 },
{ "vmm_ch2508", 0x0000061c },
{ "vmm_ch2509", 0x00000620 },
{ "vmm_ch2600", 0x00000624 },
{ "vmm_ch2601", 0x00000628 },
{ "vmm_ch2602", 0x0000062c },
{ "vmm_ch2603", 0x00000630 },
{ "vmm_ch2604", 0x00000634 },
{ "vmm_ch2605", 0x00000638 },
{ "vmm_ch2606", 0x0000063c },
{ "vmm_ch2607", 0x00000640 },
{ "vmm_ch2608", 0x00000644 },
{ "vmm_ch2609", 0x00000648 },
{ "vmm_ch2700", 0x0000064c },
{ "vmm_ch2701", 0x00000650 },
{ "vmm_ch2702", 0x00000654 },
{ "vmm_ch2703", 0x00000658 },
{ "vmm_ch2704", 0x0000065c },
{ "vmm_ch2705", 0x00000660 },
{ "vmm_ch2706", 0x00000664 },
{ "vmm_ch2707", 0x00000668 },
{ "vmm_ch2708", 0x0000066c },
{ "vmm_ch2709", 0x00000670 },
{ "vmm_ch2800", 0x00000674 },
{ "vmm_ch2801", 0x00000678 },
{ "vmm_ch2802", 0x0000067c },
{ "vmm_ch2803", 0x00000680 },
{ "vmm_ch2804", 0x00000684 },
{ "vmm_ch2805", 0x00000688 },
{ "vmm_ch2806", 0x0000068c },
{ "vmm_ch2807", 0x00000690 },
{ "vmm_ch2808", 0x00000694 },
{ "vmm_ch2809", 0x00000698 },
{ "vmm_ch2900", 0x0000069c },
{ "vmm_ch2901", 0x000006a0 },
{ "vmm_ch2902", 0x000006a4 },
{ "vmm_ch2903", 0x000006a8 },
{ "vmm_ch2904", 0x000006ac },
{ "vmm_ch2905", 0x000006b0 },
{ "vmm_ch2906", 0x000006b4 },
{ "vmm_ch2907", 0x000006b8 },
{ "vmm_ch2908", 0x000006bc },
{ "vmm_ch2909", 0x000006c0 },
{ "vmm_ch3000", 0x000006c4 },
{ "vmm_ch3001", 0x000006c8 },
{ "vmm_ch3002", 0x000006cc },
{ "vmm_ch3003", 0x000006d0 },
{ "vmm_ch3004", 0x000006d4 },
{ "vmm_ch3005", 0x000006d8 },
{ "vmm_ch3006", 0x000006dc },
{ "vmm_ch3007", 0x000006e0 },
{ "vmm_ch3008", 0x000006e4 },
{ "vmm_ch3009", 0x000006e8 },
{ "vmm_ch3100", 0x000006ec },
{ "vmm_ch3101", 0x000006f0 },
{ "vmm_ch3102", 0x000006f4 },
{ "vmm_ch3103", 0x000006f8 },
{ "vmm_ch3104", 0x000006fc },
{ "vmm_ch3105", 0x00000700 },
{ "vmm_ch3106", 0x00000704 },
{ "vmm_ch3107", 0x00000708 },
{ "vmm_ch3108", 0x0000070c },
{ "vmm_ch3109", 0x00000710 },
{ "vmm_ch3200", 0x00000714 },
{ "vmm_ch3201", 0x00000718 },
{ "vmm_ch3202", 0x0000071c },
{ "vmm_ch3203", 0x00000720 },
{ "vmm_ch3204", 0x00000724 },
{ "vmm_ch3205", 0x00000728 },
{ "vmm_ch3206", 0x0000072c },
{ "vmm_ch3207", 0x00000730 },
{ "vmm_ch3208", 0x00000734 },
{ "vmm_ch3209", 0x00000738 },
{ "vmm_ch3300", 0x0000073c },
{ "vmm_ch3301", 0x00000740 },
{ "vmm_ch3302", 0x00000744 },
{ "vmm_ch3303", 0x00000748 },
{ "vmm_ch3304", 0x0000074c },
{ "vmm_ch3305", 0x00000750 },
{ "vmm_ch3306", 0x00000754 },
{ "vmm_ch3307", 0x00000758 },
{ "vmm_ch3308", 0x0000075c },
{ "vmm_ch3309", 0x00000760 },
{ "vmm_ch3400", 0x00000764 },
{ "vmm_ch3401", 0x00000768 },
{ "vmm_ch3402", 0x0000076c },
{ "vmm_ch3403", 0x00000770 },
{ "vmm_ch3404", 0x00000774 },
{ "vmm_ch3405", 0x00000778 },
{ "vmm_ch3406", 0x0000077c },
{ "vmm_ch3407", 0x00000780 },
{ "vmm_ch3408", 0x00000784 },
{ "vmm_ch3409", 0x00000788 },
{ "vmm_ch3500", 0x0000078c },
{ "vmm_ch3501", 0x00000790 },
{ "vmm_ch3502", 0x00000794 },
{ "vmm_ch3503", 0x00000798 },
{ "vmm_ch3504", 0x0000079c },
{ "vmm_ch3505", 0x000007a0 },
{ "vmm_ch3506", 0x000007a4 },
{ "vmm_ch3507", 0x000007a8 },
{ "vmm_ch3508", 0x000007ac },
{ "vmm_ch3509", 0x000007b0 },
{ "vmm_ch3600", 0x000007b4 },
{ "vmm_ch3601", 0x000007b8 },
{ "vmm_ch3602", 0x000007bc },
{ "vmm_ch3603", 0x000007c0 },
{ "vmm_ch3604", 0x000007c4 },
{ "vmm_ch3605", 0x000007c8 },
{ "vmm_ch3606", 0x000007cc },
{ "vmm_ch3607", 0x000007d0 },
{ "vmm_ch3608", 0x000007d4 },
{ "vmm_ch3609", 0x000007d8 },
{ "vmm_ch3700", 0x000007dc },
{ "vmm_ch3701", 0x000007e0 },
{ "vmm_ch3702", 0x000007e4 },
{ "vmm_ch3703", 0x000007e8 },
{ "vmm_ch3704", 0x000007ec },
{ "vmm_ch3705", 0x000007f0 },
{ "vmm_ch3706", 0x000007f4 },
{ "vmm_ch3707", 0x000007f8 },
{ "vmm_ch3708", 0x000007fc },
{ "vmm_ch3709", 0x00000800 },
{ "vmm_ch3800", 0x00000804 },
{ "vmm_ch3801", 0x00000808 },
{ "vmm_ch3802", 0x0000080c },
{ "vmm_ch3803", 0x00000810 },
{ "vmm_ch3804", 0x00000814 },
{ "vmm_ch3805", 0x00000818 },
{ "vmm_ch3806", 0x0000081c },
{ "vmm_ch3807", 0x00000820 },
{ "vmm_ch3808", 0x00000824 },
{ "vmm_ch3809", 0x00000828 },
{ "vmm_ch3900", 0x0000082c },
{ "vmm_ch3901", 0x00000830 },
{ "vmm_ch3902", 0x00000834 },
{ "vmm_ch3903", 0x00000838 },
{ "vmm_ch3904", 0x0000083c },
{ "vmm_ch3905", 0x00000840 },
{ "vmm_ch3906", 0x00000844 },
{ "vmm_ch3907", 0x00000848 },
{ "vmm_ch3908", 0x0000084c },
{ "vmm_ch3909", 0x00000850 },
{ "vmm_ch4000", 0x00000854 },
{ "vmm_ch4001", 0x00000858 },
{ "vmm_ch4002", 0x0000085c },
{ "vmm_ch4003", 0x00000860 },
{ "vmm_ch4004", 0x00000864 },
{ "vmm_ch4005", 0x00000868 },
{ "vmm_ch4006", 0x0000086c },
{ "vmm_ch4007", 0x00000870 },
{ "vmm_ch4008", 0x00000874 },
{ "vmm_ch4009", 0x00000878 },
{ "vmm_ch4100", 0x0000087c },
{ "vmm_ch4101", 0x00000880 },
{ "vmm_ch4102", 0x00000884 },
{ "vmm_ch4103", 0x00000888 },
{ "vmm_ch4104", 0x0000088c },
{ "vmm_ch4105", 0x00000890 },
{ "vmm_ch4106", 0x00000894 },
{ "vmm_ch4107", 0x00000898 },
{ "vmm_ch4108", 0x0000089c },
{ "vmm_ch4109", 0x000008a0 },
{ "vmm_ch4200", 0x000008a4 },
{ "vmm_ch4201", 0x000008a8 },
{ "vmm_ch4202", 0x000008ac },
{ "vmm_ch4203", 0x000008b0 },
{ "vmm_ch4204", 0x000008b4 },
{ "vmm_ch4205", 0x000008b8 },
{ "vmm_ch4206", 0x000008bc },
{ "vmm_ch4207", 0x000008c0 },
{ "vmm_ch4208", 0x000008c4 },
{ "vmm_ch4209", 0x000008c8 },
{ "vmm_ch4300", 0x000008cc },
{ "vmm_ch4301", 0x000008d0 },
{ "vmm_ch4302", 0x000008d4 },
{ "vmm_ch4303", 0x000008d8 },
{ "vmm_ch4304", 0x000008dc },
{ "vmm_ch4305", 0x000008e0 },
{ "vmm_ch4306", 0x000008e4 },
{ "vmm_ch4307", 0x000008e8 },
{ "vmm_ch4308", 0x000008ec },
{ "vmm_ch4309", 0x000008f0 },
{ "vmm_ch4400", 0x000008f4 },
{ "vmm_ch4401", 0x000008f8 },
{ "vmm_ch4402", 0x000008fc },
{ "vmm_ch4403", 0x00000900 },
{ "vmm_ch4404", 0x00000904 },
{ "vmm_ch4405", 0x00000908 },
{ "vmm_ch4406", 0x0000090c },
{ "vmm_ch4407", 0x00000910 },
{ "vmm_ch4408", 0x00000914 },
{ "vmm_ch4409", 0x00000918 },
{ "vmm_ch4500", 0x0000091c },
{ "vmm_ch4501", 0x00000920 },
{ "vmm_ch4502", 0x00000924 },
{ "vmm_ch4503", 0x00000928 },
{ "vmm_ch4504", 0x0000092c },
{ "vmm_ch4505", 0x00000930 },
{ "vmm_ch4506", 0x00000934 },
{ "vmm_ch4507", 0x00000938 },
{ "vmm_ch4508", 0x0000093c },
{ "vmm_ch4509", 0x00000940 },
{ "vmm_ch4600", 0x00000944 },
{ "vmm_ch4601", 0x00000948 },
{ "vmm_ch4602", 0x0000094c },
{ "vmm_ch4603", 0x00000950 },
{ "vmm_ch4604", 0x00000954 },
{ "vmm_ch4605", 0x00000958 },
{ "vmm_ch4606", 0x0000095c },
{ "vmm_ch4607", 0x00000960 },
{ "vmm_ch4608", 0x00000964 },
{ "vmm_ch4609", 0x00000968 },
{ "vmm_ch4700", 0x0000096c },
{ "vmm_ch4701", 0x00000970 },
{ "vmm_ch4702", 0x00000974 },
{ "vmm_ch4703", 0x00000978 },
{ "vmm_ch4704", 0x0000097c },
{ "vmm_ch4705", 0x00000980 },
{ "vmm_ch4706", 0x00000984 },
{ "vmm_ch4707", 0x00000988 },
{ "vmm_ch4708", 0x0000098c },
{ "vmm_ch4709", 0x00000990 },
{ "vmm_ch4800", 0x00000994 },
{ "vmm_ch4801", 0x00000998 },
{ "vmm_ch4802", 0x0000099c },
{ "vmm_ch4803", 0x000009a0 },
{ "vmm_ch4804", 0x000009a4 },
{ "vmm_ch4805", 0x000009a8 },
{ "vmm_ch4806", 0x000009ac },
{ "vmm_ch4807", 0x000009b0 },
{ "vmm_ch4808", 0x000009b4 },
{ "vmm_ch4809", 0x000009b8 },
{ "vmm_ch4900", 0x000009bc },
{ "vmm_ch4901", 0x000009c0 },
{ "vmm_ch4902", 0x000009c4 },
{ "vmm_ch4903", 0x000009c8 },
{ "vmm_ch4904", 0x000009cc },
{ "vmm_ch4905", 0x000009d0 },
{ "vmm_ch4906", 0x000009d4 },
{ "vmm_ch4907", 0x000009d8 },
{ "vmm_ch4908", 0x000009dc },
{ "vmm_ch4909", 0x000009e0 },
{ "vmm_ch5000", 0x000009e4 },
{ "vmm_ch5001", 0x000009e8 },
{ "vmm_ch5002", 0x000009ec },
{ "vmm_ch5003", 0x000009f0 },
{ "vmm_ch5004", 0x000009f4 },
{ "vmm_ch5005", 0x000009f8 },
{ "vmm_ch5006", 0x000009fc },
{ "vmm_ch5007", 0x00000a00 },
{ "vmm_ch5008", 0x00000a04 },
{ "vmm_ch5009", 0x00000a08 },
{ "vmm_ch5100", 0x00000a0c },
{ "vmm_ch5101", 0x00000a10 },
{ "vmm_ch5102", 0x00000a14 },
{ "vmm_ch5103", 0x00000a18 },
{ "vmm_ch5104", 0x00000a1c },
{ "vmm_ch5105", 0x00000a20 },
{ "vmm_ch5106", 0x00000a24 },
{ "vmm_ch5107", 0x00000a28 },
{ "vmm_ch5108", 0x00000a2c },
{ "vmm_ch5109", 0x00000a30 },
{ "vmm_ch5200", 0x00000a34 },
{ "vmm_ch5201", 0x00000a38 },
{ "vmm_ch5202", 0x00000a3c },
{ "vmm_ch5203", 0x00000a40 },
{ "vmm_ch5204", 0x00000a44 },
{ "vmm_ch5205", 0x00000a48 },
{ "vmm_ch5206", 0x00000a4c },
{ "vmm_ch5207", 0x00000a50 },
{ "vmm_ch5208", 0x00000a54 },
{ "vmm_ch5209", 0x00000a58 },
{ "vmm_ch5300", 0x00000a5c },
{ "vmm_ch5301", 0x00000a60 },
{ "vmm_ch5302", 0x00000a64 },
{ "vmm_ch5303", 0x00000a68 },
{ "vmm_ch5304", 0x00000a6c },
{ "vmm_ch5305", 0x00000a70 },
{ "vmm_ch5306", 0x00000a74 },
{ "vmm_ch5307", 0x00000a78 },
{ "vmm_ch5308", 0x00000a7c },
{ "vmm_ch5309", 0x00000a80 },
{ "vmm_ch5400", 0x00000a84 },
{ "vmm_ch5401", 0x00000a88 },
{ "vmm_ch5402", 0x00000a8c },
{ "vmm_ch5403", 0x00000a90 },
{ "vmm_ch5404", 0x00000a94 },
{ "vmm_ch5405", 0x00000a98 },
{ "vmm_ch5406", 0x00000a9c },
{ "vmm_ch5407", 0x00000aa0 },
{ "vmm_ch5408", 0x00000aa4 },
{ "vmm_ch5409", 0x00000aa8 },
{ "vmm_ch5500", 0x00000aac },
{ "vmm_ch5501", 0x00000ab0 },
{ "vmm_ch5502", 0x00000ab4 },
{ "vmm_ch5503", 0x00000ab8 },
{ "vmm_ch5504", 0x00000abc },
{ "vmm_ch5505", 0x00000ac0 },
{ "vmm_ch5506", 0x00000ac4 },
{ "vmm_ch5507", 0x00000ac8 },
{ "vmm_ch5508", 0x00000acc },
{ "vmm_ch5509", 0x00000ad0 },
{ "vmm_ch5600", 0x00000ad4 },
{ "vmm_ch5601", 0x00000ad8 },
{ "vmm_ch5602", 0x00000adc },
{ "vmm_ch5603", 0x00000ae0 },
{ "vmm_ch5604", 0x00000ae4 },
{ "vmm_ch5605", 0x00000ae8 },
{ "vmm_ch5606", 0x00000aec },
{ "vmm_ch5607", 0x00000af0 },
{ "vmm_ch5608", 0x00000af4 },
{ "vmm_ch5609", 0x00000af8 },
{ "vmm_ch5700", 0x00000afc },
{ "vmm_ch5701", 0x00000b00 },
{ "vmm_ch5702", 0x00000b04 },
{ "vmm_ch5703", 0x00000b08 },
{ "vmm_ch5704", 0x00000b0c },
{ "vmm_ch5705", 0x00000b10 },
{ "vmm_ch5706", 0x00000b14 },
{ "vmm_ch5707", 0x00000b18 },
{ "vmm_ch5708", 0x00000b1c },
{ "vmm_ch5709", 0x00000b20 },
{ "vmm_ch5800", 0x00000b24 },
{ "vmm_ch5801", 0x00000b28 },
{ "vmm_ch5802", 0x00000b2c },
{ "vmm_ch5803", 0x00000b30 },
{ "vmm_ch5804", 0x00000b34 },
{ "vmm_ch5805", 0x00000b38 },
{ "vmm_ch5806", 0x00000b3c },
{ "vmm_ch5807", 0x00000b40 },
{ "vmm_ch5808", 0x00000b44 },
{ "vmm_ch5809", 0x00000b48 },
{ "vmm_ch5900", 0x00000b4c },
{ "vmm_ch5901", 0x00000b50 },
{ "vmm_ch5902", 0x00000b54 },
{ "vmm_ch5903", 0x00000b58 },
{ "vmm_ch5904", 0x00000b5c },
{ "vmm_ch5905", 0x00000b60 },
{ "vmm_ch5906", 0x00000b64 },
{ "vmm_ch5907", 0x00000b68 },
{ "vmm_ch5908", 0x00000b6c },
{ "vmm_ch5909", 0x00000b70 },
{ "vmm_ch6000", 0x00000b74 },
{ "vmm_ch6001", 0x00000b78 },
{ "vmm_ch6002", 0x00000b7c },
{ "vmm_ch6003", 0x00000b80 },
{ "vmm_ch6004", 0x00000b84 },
{ "vmm_ch6005", 0x00000b88 },
{ "vmm_ch6006", 0x00000b8c },
{ "vmm_ch6007", 0x00000b90 },
{ "vmm_ch6008", 0x00000b94 },
{ "vmm_ch6009", 0x00000b98 },
{ "vmm_ch6100", 0x00000b9c },
{ "vmm_ch6101", 0x00000ba0 },
{ "vmm_ch6102", 0x00000ba4 },
{ "vmm_ch6103", 0x00000ba8 },
{ "vmm_ch6104", 0x00000bac },
{ "vmm_ch6105", 0x00000bb0 },
{ "vmm_ch6106", 0x00000bb4 },
{ "vmm_ch6107", 0x00000bb8 },
{ "vmm_ch6108", 0x00000bbc },
{ "vmm_ch6109", 0x00000bc0 },
{ "vmm_ch6200", 0x00000bc4 },
{ "vmm_ch6201", 0x00000bc8 },
{ "vmm_ch6202", 0x00000bcc },
{ "vmm_ch6203", 0x00000bd0 },
{ "vmm_ch6204", 0x00000bd4 },
{ "vmm_ch6205", 0x00000bd8 },
{ "vmm_ch6206", 0x00000bdc },
{ "vmm_ch6207", 0x00000be0 },
{ "vmm_ch6208", 0x00000be4 },
{ "vmm_ch6209", 0x00000be8 },
{ "vmm_ch6300", 0x00000bec },
{ "vmm_ch6301", 0x00000bf0 },
{ "vmm_ch6302", 0x00000bf4 },
{ "vmm_ch6303", 0x00000bf8 },
{ "vmm_ch6304", 0x00000bfc },
{ "vmm_ch6305", 0x00000c00 },
{ "vmm_ch6306", 0x00000c04 },
{ "vmm_ch6307", 0x00000c08 },
{ "vmm_ch6308", 0x00000c0c },
{ "vmm_ch6309", 0x00000c10 },
{ "vmm_global_bank1_sp000", 0x00000c14 },
{ "vmm_global_bank1_sp001", 0x00000c18 },
{ "vmm_global_bank1_sp002", 0x00000c1c },
{ "vmm_global_bank1_sp003", 0x00000c20 },
{ "vmm_global_bank1_sp004", 0x00000c24 },
{ "vmm_global_bank1_sp005", 0x00000c28 },
{ "vmm_global_bank1_sp006", 0x00000c2c },
{ "vmm_global_bank1_sp007", 0x00000c30 },
{ "vmm_global_bank1_sp008", 0x00000c34 },
{ "vmm_global_bank1_sp009", 0x00000c38 },
{ "vmm_global_bank1_sp100", 0x00000c3c },
{ "vmm_global_bank1_sp101", 0x00000c40 },
{ "vmm_global_bank1_sp102", 0x00000c44 },
{ "vmm_global_bank1_sp103", 0x00000c48 },
{ "vmm_global_bank1_sp104", 0x00000c4c },
{ "vmm_global_bank1_sp105", 0x00000c50 },
{ "vmm_global_bank1_sp106", 0x00000c54 },
{ "vmm_global_bank1_sp107", 0x00000c58 },
{ "vmm_global_bank1_sp108", 0x00000c5c },
{ "vmm_global_bank1_sp109", 0x00000c60 },
{ "vmm_global_bank1_sp200", 0x00000c64 },
{ "vmm_global_bank1_sp201", 0x00000c68 },
{ "vmm_global_bank1_sp202", 0x00000c6c },
{ "vmm_global_bank1_sp203", 0x00000c70 },
{ "vmm_global_bank1_sp204", 0x00000c74 },
{ "vmm_global_bank1_sp205", 0x00000c78 },
{ "vmm_global_bank1_sp206", 0x00000c7c },
{ "vmm_global_bank1_sp207", 0x00000c80 },
{ "vmm_global_bank1_sp208", 0x00000c84 },
{ "vmm_global_bank1_sp209", 0x00000c88 }
};
vmmTblApp/src/VmmTblRegsMap.h deleted 100644 → 0
+ 0
− 6
View file @ d1df55d9
#pragma once
#include <unordered_map>
#include <string>
extern const std::unordered_map<std::string, uint32_t> vmm_tbl_register_map;
\ No newline at end of file
vmmTblApp/src/hybrid.cpp deleted 100644 → 0
+ 0
− 27
View file @ d1df55d9
#include "hybrid.h"
Hybrid::Hybrid() {
loadDefault();
}
Hybrid::~Hybrid() {}
void Hybrid::loadDefault(){
hybrid_registers = {{"TP_skew", 0}, {"TP_width", 0}, {"TP_pol", 0}};
hybrid_info = {{"firmware_version", ""}, {"geo_id", ""}, {"hybrid_id", ""},{"link_status", "0"}, {"description", ""}};
}
VMM3a& Hybrid::getVMM(int index) {
if (index < 0 || index >= VMMS_PER_HYBRID)
throw std::out_of_range("Invalid VMM index");
return vmms[index];
}
vmmStatus Hybrid::getRegister(std::string feature, unsigned short& result) {
vmmStatus status = vmmSuccess;
if(hybrid_registers.find(feature) != hybrid_registers.end())
result = hybrid_registers[feature];
else
status = vmmParamNotFound;
return status;
}
vmmTblApp/src/hybrid.h deleted 100644 → 0
+ 0
− 23
View file @ d1df55d9
#pragma once
#include <string>
#include <map>
#include <iostream>
#include "vmm_params.h"
#include "vmm3a.h"
class Hybrid {
public:
Hybrid();
~Hybrid();
void loadDefault();
VMM3a& getVMM(int index);
vmmStatus getRegister(std::string feature, unsigned short& result);
private:
VMM3a vmms[VMMS_PER_HYBRID];
std::map<std::string, unsigned short> hybrid_registers;
std::map<std::string, std::string> hybrid_info;
};
vmmTblApp/src/vmm3a.cpp deleted 100644 → 0
+ 0
− 206
View file @ d1df55d9
#include "vmm3a.h"
// Define a map to store the valid range for each feature
std::map<std::string, std::pair<int, int>> featureRanges = {
{"sm5_sm0", {0, 67}},
{"sfam", {0, 1}},
{"st", {0, 3}},
{"sg", {0, 7}},
{"stc", {0, 3}},
{"sdt", {0, 1023}},
{"sdp10", {0, 1023}},
{"sc10b", {0, 3}},
{"sc8b", {0, 3}},
{"truncate_i", {0, 63}},
{"nskip_i", {0, 127}},
{"window_i", {0, 7}},
{"rollover_i", {0, 4095}},
{"L0offset_i", {0, 4095}},
{"offset_i", {0, 4095}}
};
std::map<std::string, std::pair<int, int>> featureChannelRanges = {
{"sd", {0, 31}},
{"sz10b", {0, 31}},
{"sz08b", {0, 15}},
{"sz06b", {0, 7}},
{"sc", {0, 1}},
{"sl", {0, 1}},
{"st", {0, 1}},
{"sth", {0, 1}},
{"sc8b", {0, 3}},
{"sm", {0, 1}},
{"smx", {0, 1}}
};
VMM3a::VMM3a(): vmm3aSettings(std::make_unique<VMM3aSettings>()) {
LoadDefault();
}
void VMM3a::LoadDefault() {
//VMM3a channel registers
for(int ch=0; ch<CHANNELS_PER_VMM; ch++){
vmm3aSettings->channels[ch] = {{"sc", 0}, {"sl", 0}, {"st", 0}, {"sth", 0}, {"sm", 0}, {"sd", 0}, {"smx", 0}, {"sz10b", 0}, {"sz08b", 0}, {"sz06b", 0} };
}
//Fill default values to map for Global Register
std::vector<std::string> reg_names = {
"sp", "sdp", "sbmx", "sbft", "sbfp",
"sbfm", "slg", "sm5_sm0", "scmx", "sfa",
"sfam", "st", "sfm", "sg", "sng",
"stot", "sttt", "ssh", "stc",
"sdt", "sdp10", "sc10b", "sc8b", "sc6b",
"s8b", "s6b", "s10b", "sdcks", "sdcka",
"sdck6b", "sdrv", "stpp",
"slvs", "s32", "stcr", "ssart", "srec",
"stlc", "sbip", "srat", "sfrst", "slvsbc",
"slvstp", "slvstk", "slvsdt", "slvsart", "slvstki",
"slvsena", "slvs6b", "sL0enaV", "slh", "slxh",
"stgc", "reset1", "reset2", "nskipm_i", "sL0cktest",
"sL0dckinv", "sL0ckinv", "sL0ena", "truncate_i",
"nskip_i", "window_i", "rollover_i", "L0offset_i", "offset_i"
};
for(const std::string& reg: reg_names) {
vmm3aSettings->globalRegisters.insert(std::pair<std::string, unsigned short>(reg, 0));
}
setRegister("sg", 2);//corrsponds to 3 mV/fC
setRegister("sm5_sm0", 67); //Temperature_sensor
setRegister("sdp10", 300);
setRegister("sdt",300);
setRegister("s10b",1);
setRegister("s8b",1);
setRegister("stc",0);
setRegister("sc8b",3);
setRegister("sc10b",3);
setRegister("srat",0);
setRegister("sbip",true);
setRegister("sbfm",true);
setRegister("sdcks",false);
}
const VMM3a::VMM3aSettings& VMM3a::getVMM3aSettings() const {
return *vmm3aSettings;
}
vmmStatus VMM3a::setRegister(std::string feature, int val) {
vmmStatus status = vmmSuccess;
status = updateRegisterMap(feature, val);
if (status == vmmParamNotFound)
std::cout << "ERROR register " << feature << " does not exist." << std::endl;
else if (status == vmmBadValue)
std::cout << "Value " << val << " is not valid to register: " << feature << std::endl;
return status;
}
vmmStatus VMM3a::setRegister(std::string feature, int val, int ch) {
vmmStatus status = vmmSuccess;
status = updateRegisterMap(feature, val, ch);
if (status == vmmParamNotFound)
std::cout << "ERROR register " << feature << " does not exist." << std::endl;
else if (status == vmmBadValue)
std::cout << "Value " << val << " is not valid to register: " << feature << std::endl;
else if (status == vmmChannelOutRange)
std::cout << "Channel " << ch << " out of the range (0 - 63)" << std::endl;
return status;
}
vmmStatus VMM3a::getRegister(std::string feature, unsigned short& result) const {
vmmStatus status = vmmSuccess;
if(vmm3aSettings->globalRegisters.find(feature)!=vmm3aSettings->globalRegisters.end())
result = vmm3aSettings->globalRegisters.at(feature);
else
status = vmmParamNotFound;
return status;
}
vmmStatus VMM3a::getRegister(std::string feature, int ch, unsigned short& result) const {
vmmStatus status = vmmSuccess;
if (ch >= 0 && ch < 64) {
auto it = vmm3aSettings->channels[ch].find(feature);
if (it != vmm3aSettings->channels[ch].end())
result = it->second;
else
status = vmmParamNotFound;
}
else status = vmmChannelOutRange;
return status;
}
vmmStatus VMM3a::updateRegisterMap(std::string feature, int value) {
vmmStatus status = vmmSuccess;
auto it = vmm3aSettings->globalRegisters.find(feature);
if (it != vmm3aSettings->globalRegisters.end()) {
auto range = featureRanges.find(feature);
if (range != featureRanges.end()) {
int minVal = range->second.first;
int maxVal = range->second.second;
if (feature == "sm5_sm0") {
if(value >= 0 && value <= 63) {
vmm3aSettings->globalRegisters.at("scmx") = 1;
vmm3aSettings->globalRegisters.at("sm5_sm0") = value;
} else if (value >= 64 && value <= 67) {
//Attention: Starts at 1: 1=Pulser_DAC, 2=Threshold_DAC, 3=Bandgap_reference, 4=Temperature_sensor
vmm3aSettings->globalRegisters.at("scmx") = 0;
vmm3aSettings->globalRegisters.at("sm5_sm0") = value - 63;
} else status = vmmBadValue;
}
else {
if (value >= minVal && value <= maxVal)
vmm3aSettings->globalRegisters.at(feature) = value;
else status = vmmBadValue;
}
}
// If not in the featureRanges, the param expects boolean value.
else {
if(value >= 0 && value <= 1)
vmm3aSettings->globalRegisters.at(feature) = value;
else status = vmmBadValue;
}
}
else { status = vmmParamNotFound; }
return status;
}
vmmStatus VMM3a::updateRegisterMap(std::string feature, int value, int ch) {
vmmStatus status = vmmSuccess;
if(ch >= 0 && ch < 64) {
auto range = featureChannelRanges.find(feature);
if (range != featureChannelRanges.end()) {
int minVal = range->second.first;
int maxVal = range->second.second;
if (value >= minVal && value <= maxVal)
vmm3aSettings->channels[ch][feature] = value;
else status = vmmBadValue;
}
else status = vmmParamNotFound;
}
else status = vmmChannelOutRange;
return status;
}
vmmStatus VMM3a::getInfo(const std::string& feature, std::string& result) {
vmmStatus status = vmmSuccess;
if (vmmInfo.find(feature) != vmmInfo.end())
result = vmmInfo[feature];
else
status = vmmParamNotFound;
return status;
}
vmmStatus VMM3a::setInfo(const std::string& feature, const std::string& value) {
vmmStatus status = vmmSuccess;
if (vmmInfo.find(feature) != vmmInfo.end())
vmmInfo[feature] = value;
else
status = vmmParamNotFound;
return status;
}
VMM3a::~VMM3a(){}
vmmTblApp/src/vmm3a.h deleted 100644 → 0
+ 0
− 37
View file @ d1df55d9
#pragma once
#include <string>
#include <map>
#include <vector>
#include <memory>
#include <iostream>
#include "vmm_params.h"
class VMM3a {
public:
VMM3a();
~VMM3a();
void LoadDefault();
struct VMM3aSettings{
std::map<std::string, unsigned short> channels[CHANNELS_PER_VMM];
std::map<std::string, unsigned short> globalRegisters;
};
const VMM3aSettings& getVMM3aSettings() const;
vmmStatus setRegister(std::string feature, int val);
vmmStatus setRegister(std::string feature, int val, int ch);
vmmStatus getRegister(std::string feature, unsigned short& result) const;
vmmStatus getRegister(std::string feature, int ch, unsigned short& result) const;
vmmStatus getInfo(const std::string& feature, std::string& result);
vmmStatus setInfo(const std::string& feature, const std::string& value);
private:
vmmStatus updateRegisterMap(std::string feature, int value);
vmmStatus updateRegisterMap(std::string feature, int value, int ch);
std::unique_ptr<VMM3aSettings> vmm3aSettings;
std::map<std::string, std::string> vmmInfo = {{"all_sc", "0"}, {"all_sl", "0"}, {"all_st", "0"}, {"all_sth", "0"},{"all_sm", "0"}, {"all_sd", "0"},{"all_smx", "0"},
{"all_sz10b", "0"},{"all_sz08b", "0"}, {"all_sz06b", "0"},{"adc_value", ""}, {"description",""}};
};
\ No newline at end of file
vmmTblApp/src/vmm_params.h deleted 100644 → 0
+ 0
− 9
View file @ d1df55d9
#pragma once
#define CHANNELS_PER_VMM 64
#define VMMS_PER_HYBRID 2
#define HYBRIDS_PER_FEN 5
typedef enum {
vmmSuccess,vmmTimeout,vmmParamNotFound,vmmBadValue,vmmChannelOutRange
}vmmStatus;
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment