size_t UartBridge::write(byte value) {
/*
Write byte to UART.
*/
while (readRegister(TXLVL) == 0) {
// Wait for space in TX buffer
};
writeRegister(THR, value);
return 1;
}
/*
* setIWU (void) - sets the Inertial Wake-UP interrupt
*/
uint8_t MakeSureACC::setIWU(void)
{
// clear the FF interrupt if active
unsetIWU();
// configure the different registers to
// handle acceleration detection on the X, Y, or Z axis
writeRegister(CTRL_REG3,0x00);
writeRegister(INT1_THS,0x10);
writeRegister(INT1_DURATION,0x00);
writeRegister(INT1_CFG,0x0A);
// attach the hardware interrupt to the pin
enableInterrupts(ACC_INT);
// IWU interruption set
accInt=IWU_INT;
return flag;
}
void ADXL345::setRange(range_t range)
{
switch(range)
{
case RANGE_16G:
case RANGE_8G:
case RANGE_4G:
case RANGE_2G:
writeRegister(ADXL345::DATA_FORMAT, 1, (byte *)&range);
break;
}
}
bool
LSM9DS1_G::activate(void)
{
uint8_t data;
data = readRegister(addr(), AG_CTRL_REG1_G);
//data |= POWER_UP;
data |= AG_ODR_SET;
writeRegister(addr(), AG_CTRL_REG1_G, data);
return true;
}
Magnetometer::Magnetometer(): I2cDevice(LSM303_ADDRESS_MAG){
//enable magnetometer at 220hz
writeRegister(LSM303_REGISTER_MAG_CRA_REG_M,LSM303_MAGRATE_220 << 2);
//set to continuous conversion
writeRegister(LSM303_REGISTER_MAG_MR_REG_M,0x00);
//assume its all good
//uint8_t reg1_a = readRegister(LSM303_REGISTER_ACCEL_CTRL_REG1_A);
//DEBUGSPRINTLN((reg1_a,HEX));
//set gain
writeRegister(LSM303_REGISTER_MAG_CRB_REG_M,LSM303_MAGGAIN_1_3 << 4);
xOffset = 0;
yOffset = 0;
zOffset = 0;
ready = true;
}
/*
* set6DPosition (void) - sets the Inertial Wake-UP interrupt
*/
uint8_t MakeSureACC::set6DPosition(void)
{
// clear the FF interrupt if active
unset6DPosition();
// configure the different registers to
// handle acceleration detection on the X, Y, or Z axis
writeRegister(CTRL_REG3,0x04);
writeRegister(INT1_THS,0x10); // threshold L
writeRegister(INT1_DURATION,0x00); // threshold H
writeRegister(INT1_CFG,0xFF); // event duration
// attach the hardware interrupt to the pin
enableInterrupts(ACC_INT);
// 6D Position interruption set
accInt=_6DPOS_INT;
return flag;
}
void TICC1100::initChip()
{
try
{
if(_fileDescriptor->descriptor == -1)
{
_out.printError("Error: Could not initialize TI CC1100. The spi device's file descriptor is not valid.");
return;
}
reset();
int32_t index = 0;
for(std::vector<uint8_t>::const_iterator i = _config.begin(); i != _config.end(); ++i)
{
writeRegister((Registers::Enum)index, *i, true);
index++;
}
writeRegister(Registers::Enum::FSTEST, 0x59, true);
writeRegister(Registers::Enum::TEST2, 0x81, true); //Determined by SmartRF Studio
writeRegister(Registers::Enum::TEST1, 0x35, true); //Determined by SmartRF Studio
writeRegister(Registers::Enum::PATABLE, _settings->txPowerSetting, true);
sendCommandStrobe(CommandStrobes::Enum::SFRX);
usleep(20);
enableRX(true);
}
catch(const std::exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(BaseLib::Exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(...)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
}
void TLC59116::begin() {
if (_begun == 0) {
Wire.begin();
writeRegister(TLC59116_MODE1, 0x01);
delay(1);
writeRegister(TLC59116_MODE2, 0x00);
writeRegister(TLC59116_LEDOUT0, 0b10101010);
writeRegister(TLC59116_LEDOUT1, 0b10101010);
writeRegister(TLC59116_LEDOUT2, 0b10101010);
writeRegister(TLC59116_LEDOUT3, 0b10101010);
this->analogWrite(0, 0);
this->analogWrite(1, 0);
this->analogWrite(2, 0);
this->analogWrite(3, 0);
this->analogWrite(4, 0);
this->analogWrite(5, 0);
this->analogWrite(6, 0);
this->analogWrite(7, 0);
this->analogWrite(8, 0);
this->analogWrite(9, 0);
this->analogWrite(10, 0);
this->analogWrite(11, 0);
this->analogWrite(12, 0);
this->analogWrite(13, 0);
this->analogWrite(14, 0);
this->analogWrite(15, 0);
setPinMapping(pinmap);
}
_begun = 1;
}
unsigned int PerformFIX(const unsigned int opcode)
{
FPA11 *fpa11 = GET_FPA11();
unsigned int Fn = getFm(opcode);
struct roundingData roundData;
roundData.mode = SetRoundingMode(opcode);
roundData.precision = SetRoundingPrecision(opcode);
roundData.exception = 0;
switch (fpa11->fType[Fn]) {
case typeSingle:
{
writeRegister(getRd(opcode), float32_to_int32(&roundData, fpa11->fpreg[Fn].fSingle));
}
break;
case typeDouble:
{
writeRegister(getRd(opcode), float64_to_int32(&roundData, fpa11->fpreg[Fn].fDouble));
}
break;
#ifdef CONFIG_FPE_NWFPE_XP
case typeExtended:
{
writeRegister(getRd(opcode), floatx80_to_int32(&roundData, fpa11->fpreg[Fn].fExtended));
}
break;
#endif
default:
return 0;
}
if (roundData.exception)
float_raise(roundData.exception);
return 1;
}
boolean SpiUartDevice::uartConnected() {
/*
Check that UART is connected and operational.
*/
// Perform read/write test to check if UART is working
const char TEST_CHARACTER = 'H';
writeRegister(SPR, TEST_CHARACTER);
return (readRegister(SPR) == TEST_CHARACTER);
}
void DW1000::sendFrame(uint8_t* message, uint16_t length) {
if (length >= 125) length = 125; // check for maximim length a frame can have with 127 Byte frames
writeRegister(DW1000_TX_BUFFER, 0, message, length); // fill buffer
uint8_t backup = readRegister8(DW1000_TX_FCTRL, 1); // put length of frame
length += 2; // including 2 CRC Bytes
length = ((backup & 0xFC) << 8) | (length & 0x03FF);
writeRegister16(DW1000_TX_FCTRL, 0, length);
stopTRX(); // stop receiving
writeRegister8(DW1000_SYS_CTRL, 0, 0x02); // trigger sending process by setting the TXSTRT bit
startRX(); // enable receiver again
}
static PDDebugState update(void* userData, PDAction action, PDReader* reader, PDWriter* writer)
{
PluginData* plugin = (PluginData*)userData;
plugin->hasUpdatedRegistes = false;
plugin->hasUpdatedExceptionLocation = false;
onAction(plugin, action);
processEvents(plugin, reader, writer);
updateEvents(plugin, writer);
if (plugin->hasUpdatedRegistes)
{
PDWrite_eventBegin(writer, PDEventType_setRegisters);
PDWrite_arrayBegin(writer, "registers");
writeStatusRegister(writer, "flags", plugin->regs.flags);
writeRegister(writer, "pc", 2, plugin->regs.pc, 1);
writeRegister(writer, "sp", 1, plugin->regs.sp, 0);
writeRegister(writer, "a", 1, plugin->regs.a, 0);
writeRegister(writer, "x", 1, plugin->regs.x, 0);
writeRegister(writer, "y", 1, plugin->regs.y, 0);
PDWrite_arrayEnd(writer);
PDWrite_eventEnd(writer);
}
if (plugin->hasUpdatedExceptionLocation)
{
PDWrite_eventBegin(writer, PDEventType_setExceptionLocation);
PDWrite_u64(writer, "address", plugin->regs.pc);
PDWrite_u8(writer, "address_size", 2);
PDWrite_eventEnd(writer);
}
return plugin->state;
}
void PTApplicationCardPlugin::setSPIClock(unsigned short pCLKData,SPI_SELECT peSPISelect)
{
unsigned short l_nSPICLKArray[6] =
{
PT_APPCARD_MODULES::PT_SPI1_APPCARD_SCLKDIV,
PT_APPCARD_MODULES::PT_SPI2_APPCARD_SCLKDIV,
PT_APPCARD_MODULES::PT_SPI3_APPCARD_SCLKDIV,
PT_APPCARD_MODULES::PT_SPI4_APPCARD_SCLKDIV,
PT_APPCARD_MODULES::PT_SPI5_APPCARD_SCLKDIV,
PT_APPCARD_MODULES::PT_SPI6_APPCARD_SCLKDIV
};
writeRegister(pCLKData,l_nSPICLKArray[peSPISelect-1]);
}
void PTApplicationCardPlugin::setDSOReceiveFIFOConfiguration(DSO_RECEIVE_FIFO pSelFIFO,bool pADC1Rst,bool pADC1ClkDivRst,bool pFIFORst)
{
unsigned short l_nReceFIFO[2]= {PT_APPCARD_MODULES::PT_DSOR1FIFO_CFG,
PT_APPCARD_MODULES::PT_DSOR2FIFO_CFG};
unsigned short l_nData=0;
if(pADC1Rst == true)
l_nData = 1;
if(pADC1ClkDivRst==true)
l_nData |= 2;
if(pFIFORst == true)
l_nData |=4;
writeRegister(l_nData,l_nReceFIFO[pSelFIFO-1]);
}
void PTApplicationCardPlugin::setSPITXMSW(unsigned short pMSWData, SPI_SELECT peSPISelect)
{
unsigned short l_nTXARRAY[6]= {PT_APPCARD_MODULES::PT_SPI1_APPCARD_TXR_MSW,
PT_APPCARD_MODULES::PT_SPI2_APPCARD_TXR_MSW,
PT_APPCARD_MODULES::PT_SPI3_APPCARD_TXR_MSW,
PT_APPCARD_MODULES::PT_SPI4_APPCARD_TXR_MSW,
PT_APPCARD_MODULES::PT_SPI5_APPCARD_TXR_MSW,
PT_APPCARD_MODULES::PT_SPI6_APPCARD_TXR_MSW,
};
// qDebug()<<"SPITXMSW"<<"\tData:"<<hex<<pMSWData<<"\tAddress:"<<hex<<l_nTXARRAY[peSPISelect-1];
writeRegister(pMSWData,l_nTXARRAY[peSPISelect-1]);
}
uint8_t nrf24l01p::setPower(uint8_t power) {
uint8_t nrf_power = 0;
switch(power) {
case PWRLOW: nrf_power = 0; break;
case PWRMEDIUM: nrf_power = 1; break;
case PWRHIGH: nrf_power = 2; break;
case PWRMAX: nrf_power = 3; break;
default: nrf_power = 0; break;
};
// Power is in range 0..3 for nRF24L01
rf_setup = (rf_setup & 0xF9) | ((nrf_power & 0x03) << 1);
return writeRegister(RF_SETUP, rf_setup);
}
void Adafruit_ADS1015::startComparator_SingleEnded(uint8_t channel, int16_t threshold)
{
uint16_t value;
// Start with default values
uint16_t config = ADS1015_REG_CONFIG_CQUE_1CONV | // Comparator enabled and asserts on 1 match
ADS1015_REG_CONFIG_CLAT_LATCH | // Latching mode
ADS1015_REG_CONFIG_CPOL_ACTVLOW | // Alert/Rdy active low (default val)
ADS1015_REG_CONFIG_CMODE_TRAD | // Traditional comparator (default val)
ADS1015_REG_CONFIG_DR_1600SPS | // 1600 samples per second (default)
ADS1015_REG_CONFIG_MODE_CONTIN | // Continuous conversion mode
ADS1015_REG_CONFIG_PGA_6_144V | // +/- 6.144V range (limited to VDD +0.3V max!)
ADS1015_REG_CONFIG_MODE_CONTIN; // Continuous conversion mode
// Set single-ended input channel
switch (channel)
{
case (0):
config |= ADS1015_REG_CONFIG_MUX_SINGLE_0;
break;
case (1):
config |= ADS1015_REG_CONFIG_MUX_SINGLE_1;
break;
case (2):
config |= ADS1015_REG_CONFIG_MUX_SINGLE_2;
break;
case (3):
config |= ADS1015_REG_CONFIG_MUX_SINGLE_3;
break;
}
// Set the high threshold register
// Shift 12-bit results left 4 bits for the ADS1015
writeRegister(m_i2cAddress, ADS1015_REG_POINTER_HITHRESH, threshold << m_bitShift);
// Write config register to the ADC
writeRegister(m_i2cAddress, ADS1015_REG_POINTER_CONFIG, config);
}
/*
* setFF (void) - sets the Free Fall interrupt
*/
uint8_t WaspACC::setFF(void)
{
// reboot ACC in order to clean the ACC Interruption
// pin in the it has been locked to '1'
boot();
delay(100);
// clear the FF interrupt if active
unsetFF();
// configure the different registers to
// handle acceleration detection on the X, Y, or Z axis
// set latch interrupt request: when an interrupt condition is applied,
// the interrupt signal remains high even if the condition returns to a
// non-interrupt status, until a reading of the INTx_SRC register is performed.
writeRegister(CTRL_REG2,0x00);
writeRegister(CTRL_REG3,0x04);
// set Free-Fall threshold. Beware of the full scale selection!
uint8_t val=INT1_THS_val*2/fsSelection;
writeRegister(INT1_THS, val);
// set minimum event duration
writeRegister(INT1_DURATION, INT1_DURATION_val);
// set interrupt configuration
writeRegister(INT1_CFG, INT1_CFG_val);
// Free-Fall interruption set
accInt=FF_INT;
delay(100);
// attach the hardware interrupt to the pin
enableInterrupts(ACC_INT);
return flag;
}
unsigned int PerformSTF(const unsigned int opcode)
{
unsigned int __user *pBase, *pAddress, *pFinal;
unsigned int nRc = 1, write_back = WRITE_BACK(opcode);
struct roundingData roundData;
roundData.mode = SetRoundingMode(opcode);
roundData.precision = SetRoundingPrecision(opcode);
roundData.exception = 0;
pBase = (unsigned int __user *) readRegister(getRn(opcode));
if (REG_PC == getRn(opcode)) {
pBase += 2;
write_back = 0;
}
pFinal = pBase;
if (BIT_UP_SET(opcode))
pFinal += getOffset(opcode);
else
pFinal -= getOffset(opcode);
if (PREINDEXED(opcode))
pAddress = pFinal;
else
pAddress = pBase;
switch (opcode & MASK_TRANSFER_LENGTH) {
case TRANSFER_SINGLE:
storeSingle(&roundData, getFd(opcode), pAddress);
break;
case TRANSFER_DOUBLE:
storeDouble(&roundData, getFd(opcode), pAddress);
break;
#ifdef CONFIG_FPE_NWFPE_XP
case TRANSFER_EXTENDED:
storeExtended(getFd(opcode), pAddress);
break;
#endif
default:
nRc = 0;
}
if (roundData.exception)
float_raise(roundData.exception);
if (write_back)
writeRegister(getRn(opcode), (unsigned long) pFinal);
return nRc;
}
// reset for vs10xx
void VS10XX::reset()
{
putInReset();
delay(100);//it is a must
/* Send dummy SPI byte to initialize atmel SPI */
////SPIPutCharWithoutWaiting(0xFF);
deselectControlBus();
deselectDataBus();
releaseFromReset();
while (!readDREQ());
/* Set clock register, doubler etc. */
writeRegister(SPI_CLOCKF, 0xc0, 0x00);
/* Wait for DREQ */
while (!readDREQ());
softReset();//comment this, as it will be executed everytime playing a music file.
writeRegister(SPI_WRAMADDR, 0xc0, 0x13);
/* Switch on the analog parts */
setVolume(40,40);
//setVolume(0xff,0xff);
//SPISetFastClock();
}
RGBC ColorSensor::read() {
RGBC color = RGBC();
writeRegister(CTRL, 0x01);
while (readRegister(CTRL) != 0)
;
color.red = readRegisterLong(DATA_RED_LO);
color.green = readRegisterLong(DATA_GREEN_LO);
color.blue = readRegisterLong(DATA_BLUE_LO);
color.clear = readRegisterLong(DATA_CLEAR_LO);
return color;
}
/////////////////////////////////////
// Method: Setup to receive continuously
//////////////////////////////////////
void startReceiving(int Channel)
{
// writeRegister(Channel, REG_MODEM_CONFIG, Config.LoRaDevices[Channel].ImplicitOrExplicit | Config.LoRaDevices[Channel].ErrorCoding | Config.LoRaDevices[Channel].Bandwidth);
// writeRegister(Channel, REG_MODEM_CONFIG2, Config.LoRaDevices[Channel].SpreadingFactor | CRC_ON);
// writeRegister(Channel, REG_MODEM_CONFIG3, 0x04 | Config.LoRaDevices[Channel].LowDataRateOptimize); // 0x04: AGC sets LNA gain
// writeRegister(Channel, REG_DETECT_OPT, (readRegister(Channel, REG_DETECT_OPT) & 0xF8) | ((Config.LoRaDevices[Channel].SpreadingFactor == SPREADING_6) ? 0x05 : 0x03)); // 0x05 For SF6; 0x03 otherwise
// writeRegister(Channel, REG_DETECTION_THRESHOLD, (Config.LoRaDevices[Channel].SpreadingFactor == SPREADING_6) ? 0x0C : 0x0A); // 0x0C for SF6, 0x0A otherwise
// writeRegister(Channel, REG_PAYLOAD_LENGTH, Config.LoRaDevices[Channel].PayloadLength);
// writeRegister(Channel, REG_RX_NB_BYTES, Config.LoRaDevices[Channel].PayloadLength);
writeRegister(Channel, REG_PAYLOAD_LENGTH, 255);
writeRegister(Channel, REG_RX_NB_BYTES, 255);
// writeRegister(Channel, REG_HOP_PERIOD,0xFF);
// writeRegister(Channel, REG_FIFO_ADDR_PTR, readRegister(Channel, REG_FIFO_RX_BASE_AD));
writeRegister(Channel, REG_FIFO_RX_BASE_AD, 0);
writeRegister(Channel, REG_FIFO_ADDR_PTR, 0);
// Setup Receive Continous Mode
setMode(Channel, RF96_MODE_RX_CONTINUOUS);
}
//[[--------------------------------------- Receive Relays -----------------------------------------------
void PTApplicationCardPlugin::setReceiversConfiguration(RECEIVER_CONF peReceConf, R1CR pSTReceiver1)
{
unsigned short l_nR1CR =0;
if(pSTReceiver1.m_bHSHA == true)
l_nR1CR = 1;
if(pSTReceiver1.m_bHAAC == true)
l_nR1CR|= 1 << 1;
if(pSTReceiver1.m_bRMSIN == true)
l_nR1CR|= 1 << 2;
if(pSTReceiver1.m_bRMSGAIN == true)
l_nR1CR|= 1 << 3;
if(pSTReceiver1.m_bRMSAVG == true)
l_nR1CR|= 1 << 4;
if(pSTReceiver1.m_bHAIPR1_ICMSELR2 == true) // ICM Selection for Receiver 2
l_nR1CR|= 1 << 5;
if(pSTReceiver1.m_bHSVI == true)
l_nR1CR|= 1 << 6;
l_nR1CR|= pSTReceiver1.m_eCoupling << 7;
if(peReceConf == RECEIVER1)
writeRegister(l_nR1CR,PT_APPCARD_MODULES::PT_RECERLY_APPCARD_R1CR);
if(peReceConf == RECEIVER2)
writeRegister(l_nR1CR,PT_APPCARD_MODULES::PT_RECERLY_APPCARD_R2CR);
}
void PTApplicationCardPlugin::setSPI1CommandWord(SPI1_CONFIGURATION m_stSPI1)
{
unsigned short l_nSPI1CW=0;
l_nSPI1CW = m_stSPI1.m_eCSSEL;
l_nSPI1CW |= (m_stSPI1.m_eCSEN) << 5;
if(m_stSPI1.m_bLDAC_AD5318 == true)
l_nSPI1CW |= (1) << 4;
if(m_stSPI1.m_bCD == true)
l_nSPI1CW |= (1) << 3;
l_nSPI1CW |= m_stSPI1.m_eMode << 1;
if(m_stSPI1.m_bSD == true)
l_nSPI1CW |= 1;
writeRegister(l_nSPI1CW,PT_APPCARD_MODULES::PT_SPI1_APPCARD_CR);
}
void PTApplicationCardPlugin::setDDSConfiguration1(DDSR1CONFIG pObjR1Configuration)
{
unsigned short l_nDDRR1Configuration=0;
if(pObjR1Configuration.m_bSINEorCOSINE == false)
l_nDDRR1Configuration |= (1<<3);
if(pObjR1Configuration.m_bBaseClockorMSBRAM == false)
l_nDDRR1Configuration |= (1<<2);
if(pObjR1Configuration.m_bPTWRAMorREG == false)
l_nDDRR1Configuration |= (1<<1);
if(pObjR1Configuration.m_bFTWRAMorREG== false)
l_nDDRR1Configuration |= 1;
writeRegister(l_nDDRR1Configuration,PT_APPCARD_MODULES::PT_DDS_APPCARD_CFG1R);
}
void config_rf(){
// Sets the important registers in the MiRF module and powers the module
// in receiving mode
// NB: channel and payload must be set now.
/* set tranceiver address */
setRADDR((uint8_t*)"robot");
//uint8_t result = 0x07;
uint8_t result = 0x27;
writeRegister(RF_SETUP,&result,1);//1mbps
// Set RF channel
writeRegister(RF_CH,&channel,1);
// Set length of incoming payload
writeRegister(RX_PW_P0, &payload,1);
writeRegister(RX_PW_P1, &payload,1);
// Start receiver
powerUpRx();
flushRx();
}
void UartBridge::configureCommunication(byte databit, byte stopbit, boolean parity) {
/*
Configure the settings of the UART.
*/
// TODO: Improve with use of constants and calculations.
// setBaudRate(baudrate);
byte bits = 0; // same with the default
bits |= LCR_WORD_LENGTH_BITS & (databit - 5);
if ( stopbit != 1 ) {
bits |= LCR_NUMBER_OF_STOP_BITS;
}
if ( parity ) {
bits |= LCR_SET_PARITY | LCR_PARITY_TYPE_SELECT | LCR_PARITY_ENABLE;
}
writeRegister(LCR, bits);
writeRegister(EFR, EFR_ENABLE_ENHANCED_FUNCTIONS); // enable enhanced registers
writeRegister(FCR, FCR_TXFIFO_RESET | FCR_RXFIFO_RESET); // reset TXFIFO, reset RXFIFO
// wait two clock
writeRegister(FCR, FCR_FIFO_ENABLE); // enable FIFO mode
}
void QRF24::startWrite( const void* buf, quint8 len )
{
// Transmitter power-up
writeRegister(CONFIG, ( readRegister(CONFIG) | _BV(PWR_UP) ) & ~_BV(PRIM_RX) );
delayMicroseconds(150);
// Send the payload
writePayload( buf, len );
// Allons!
bcm2835_gpio_write(ce_pin, HIGH);
delayMicroseconds(15);
bcm2835_gpio_write(ce_pin, LOW);
}
//configure
Gyroscope::Gyroscope(): I2cDevice(L2GD20H_ADDRESS){
//check if device is correct
uint8_t who = readRegister(GYRO_REGISTER_WHO_AM_I);
if(who != 0xd7){
DEBUGSPRINTLN("expecting gyroscope! invalid device");
DEBUGSPRINTLN((who,HEX));
ready = false;
return;
}
//clear and set config reg 1
writeRegister(GYRO_REGISTER_CTRL_REG1,0x00);
writeRegister(GYRO_REGISTER_CTRL_REG1,0xef);
//set config reg 4, default 245 dps
maxAngularVelocity = DPS500;
writeRegister(GYRO_REGISTER_CTRL_REG4,maxAngularVelocity);
x=0;y=0;z=0;
xOffset=0;yOffset=0;zOffset=0;
ready = true;
}
uint16_t RFduinoProXShield::analogRead(uint8_t pin){
if (pin > 15) {
pin = 15;
}
uint8_t gpio;
// read the GPIOA output latches and reset the lower 4 MUX address bits
gpio = readRegister(MCP23017_OLATA) & 0xF0;
// write the new GPIO value with the MUX address bits OR'd in
writeRegister(MCP23017_GPIOA,gpio|pin);
return ::analogRead(GPIO_MUX_COMMON);
}
