uint8_t MAX3421E::getRevision() {
uint8_t revision = 0;
readRegister(REVISION, &revision);
return revision;
}
// most registers are 1 byte, so here is a convenience function
int MMA8452::readRegister(char addr, char *dst) {
return readRegister(addr,dst,1);
}
bool
xpcc::Bma180<I2cMaster>::writeMaskedRegister(bma180::Register reg, uint8_t mask, uint8_t value)
{
readRegister(reg);
return writeRegister(reg, (buffer[0] & ~mask) | value);
}
void ADNS2051::updateStatus(void)
{
_status = readRegister(Motion_Status);
//Serial.println(_status);
}
int MMA8452::getDeviceID(char *dst) {
return readRegister(MMA8452_WHO_AM_I,dst);
}
void PAN3101::updateStatus(void)
{
_status = readRegister(Motion_Status);
}
void ADNS2051::updateStatus(void)
{
_status = readRegister(Motion_Status);
}
uint8_t DW1000::readRegister8(uint8_t reg, uint16_t subaddress)
{
uint8_t result;
readRegister(reg, subaddress, &result, 1);
return result;
}
uint16_t DW1000::readRegister16(uint8_t reg, uint16_t subaddress)
{
uint16_t result;
readRegister(reg, subaddress, (uint8_t*)&result, 2);
return result;
}
/* ======================================================================
Function: getConfig
Purpose : Get device configuration register
Input : pointer where the return value will be filled
Output : Arduino Wire library return code (0 if ok)
Comments:
====================================================================== */
uint8_t TH02::getConfig(uint8_t * pvalue)
{
return (readRegister(TH02_CONFIG, pvalue));
}
void DW1000::receiveString(char* message)
{
readRegister(DW1000_RX_BUFFER, 0, (uint8_t*)message, getFramelength()); // get data from buffer
}
/* ======================================================================
Function: getStatus
Purpose : Get device status register
Input : pointer where the return value will be filled
Output : Arduino Wire library return code (0 if ok)
Comments:
====================================================================== */
uint8_t TH02::getStatus(uint8_t * pvalue)
{
return (readRegister(TH02_STATUS, pvalue));
}
/* ======================================================================
Function: getId
Purpose : Get device ID register
Input : pointer where the return value will be filled
Output : Arduino Wire library return code (0 if ok)
Comments: -
====================================================================== */
uint8_t TH02::getId(uint8_t * pvalue)
{
return (readRegister(TH02_ID, pvalue));
}
//! Send keep-alive signal.
void
keepAlive(void)
{
readRegister(ADR_PRIV);
}
void MAX30100::setSamplingRate(SamplingRate samplingRate)
{
uint8_t previous = readRegister(MAX30100_REG_SPO2_CONFIGURATION);
writeRegister(MAX30100_REG_SPO2_CONFIGURATION, (previous & 0xe3) | (samplingRate << 2));
}
uint64_t DW1000::getEUI()
{
uint64_t result;
readRegister(DW1000_EUI, 0, (uint8_t*)&result, 8);
return result;
}
void ServerNetworkHandler::inMessage(std::string pMessage, int pSocket){
pMessage = Tokenizer::cleanEntry(pMessage);
std::string command = Tokenizer::getCommandSpace(pMessage, 1);
if (_sessionID == -1 && command != "connect" && command != "adduser"){
outMessage("?Error: No se ha inciado sesión\n", pSocket);
} else {
std::string param = Tokenizer::getParameters(pMessage);
std::cout<<param<<std::endl;
if (command == "get"){
get(param, pSocket);
} else if (command == "cd"){
cd(param, pSocket);
} else if (command == "rm"){
rm(param, pSocket);
} else if (command == "touch"){
touch(param, pSocket);
} else if (command == "connect"){
connect(param, pSocket);
} else if (command == "mkdir"){
mkdir(param, pSocket);
} else if (command == "adduser"){
adduser(param, pSocket);
} else if (command == "openfile"){
openfile(param, pSocket);
} else if (command == "appendReg"){
appendReg(param, pSocket);
} else if (command == "delReg"){
if (param == ""){
delActualReg(pSocket);
} else {
delReg(param, pSocket);
}
} else if (command == "write"){
write(param, pSocket);
} else if (command == "seek"){
seek(param, pSocket);
} else if (command == "addReg"){
addReg(param, pSocket);
} else if (command == "read"){
if (param == ""){
readActual(pSocket);
} else {
readRegister(param, pSocket);
}
} else if (command == "close"){
close(pSocket);
} else if (command == "consoleMode"){
consoleMode(param, pSocket);
} else {
outMessage("?Error: No se ha encontrado la instrucción " + command + '\n', pSocket);
}
consoleUI(pSocket);
}
}
static void printStatus(niport *pniport, const char *source)
{
sprintf(pniport->errorMessage, "%s "
"isr1 %2.2x isr2 %2.2x ADSR %2.2x\n",
source, pniport->isr1,pniport->isr2,readRegister(pniport,ADSR));
}
signed char PAN3101::dy(void)
{
return (signed char) readRegister(Delta_Y);
}
void ni1014(void *pvt)
{
niport *pniport = (niport *)pvt;
transferState_t state = pniport->transferState;
epicsUInt8 isr1,isr2,octet;
char message[80];
pniport->isr2 = isr2 = readRegister(pniport,ISR2);
pniport->isr1 = isr1 = readRegister(pniport,ISR1);
writeRegister(pniport,CSR1,2); /*acknowledge interrupt*/
if(isr2&SRQI) callbackRequest(&pniport->callback);
if(isr1&ERR) {
if(state!=transferStateIdle) {
sprintf(pniport->errorMessage,"\n%s interruptHandler ERR state %d\n",
pniport->portName,state);
pniport->status = asynError;
epicsEventSignal(pniport->waitForInterrupt);
}
goto exit;
}
switch(state) {
case transferStateCmd:
if(!isr2&CO)
goto exit;
if(pniport->bytesRemainingCmd == 0) {
pniport->transferState = pniport->nextTransferState;
if(pniport->transferState==transferStateIdle) {
epicsEventSignal(pniport->waitForInterrupt);
} else {
writeRegister(pniport,AUXMR,AUXGTS);
}
break ;
}
octet = *pniport->nextByteCmd;
writeRegister(pniport,CDOR,(epicsUInt8)octet);
--(pniport->bytesRemainingCmd); ++(pniport->nextByteCmd);
break;
case transferStateWrite:
if(!isr1&DO)
goto exit;
if(pniport->bytesRemainingWrite == 0) {
pniport->transferState = transferStateIdle;
writeRegister(pniport,AUXMR,AUXTCA);
epicsEventSignal(pniport->waitForInterrupt);
break ;
}
if(pniport->bytesRemainingWrite==1) writeRegister(pniport,AUXMR,AUXEOI);
octet = *pniport->nextByteWrite;
writeRegister(pniport,CDOR,(epicsUInt8)octet);
--(pniport->bytesRemainingWrite); ++(pniport->nextByteWrite);
break;
case transferStateRead:
if(!isr1&DI) break;
octet = readRegister(pniport,DIR);
*pniport->nextByteRead = octet;
--(pniport->bytesRemainingRead); ++(pniport->nextByteRead);
if((pniport->eos != -1 ) && (octet == pniport->eos))
pniport->eomReason |= ASYN_EOM_EOS;
if(ENDRX&isr1) pniport->eomReason |= ASYN_EOM_END;
if(pniport->bytesRemainingRead == 0) pniport->eomReason |= ASYN_EOM_CNT;
if(pniport->eomReason) {
pniport->transferState = transferStateIdle;
writeRegister(pniport,AUXMR,AUXTCS);
epicsEventSignal(pniport->waitForInterrupt);
break;
}
writeRegister(pniport,AUXMR,AUXFH);
break;
case transferStateIdle:
if(!isr1&DI)
goto exit;
octet = readRegister(pniport,DIR);
sprintf(message,"%s ni1014IH transferStateIdle received %2.2x\n",
pniport->portName,octet);
epicsInterruptContextMessage(message);
}
exit:
/* Force synchronization of VMEbus writes on PPC CPU boards. */
readRegister(pniport,ADSR);
}
signed char ADNS2051::dx(void)
{
return (signed char) readRegister(Delta_X);
}
unsigned int HDC1050::getManufacturerID()
{
readRegister(REG_ManufactureID, 2);
return buf[0] << 8 | buf[1];
}
signed char ADNS2051::dy(void)
{
//return (signed char) readRegister(Delta_Y);
return readRegister(Delta_Y);
}
unsigned int HDC1050::getDeviceID()
{
readRegister(REG_DeviceID, 2);
return buf[0] << 8 | buf[1];
}
int MMA8452::getStatus(char* dst) {
return readRegister(MMA8452_STATUS,dst);
}
bool MAX30100::isTemperatureReady()
{
return !(readRegister(MAX30100_REG_MODE_CONFIGURATION) & MAX30100_MC_TEMP_EN);
}
void MMA8452::debugRegister(char reg) {
// get register value
char v = 0;
if(readRegister(reg,&v)) {
MMA8452_DBG("Error reading specified register");
return;
}
// print out details
switch(reg) {
case MMA8452_CTRL_REG_1:
MMA8452_DBG("CTRL_REG_1 has value: 0x%x",v);
MMA8452_DBG(" 7 ALSP_RATE_1: %d",(v&0x80)>>7);
MMA8452_DBG(" 6 ALSP_RATE_0: %d",(v&0x40)>>6);
MMA8452_DBG(" 5 DR2: %d", (v&0x20)>>5);
MMA8452_DBG(" 4 DR1: %d", (v&0x10)>>4);
MMA8452_DBG(" 3 DR0: %d", (v&0x08)>>3);
MMA8452_DBG(" 2 LNOISE: %d", (v&0x04)>>2);
MMA8452_DBG(" 1 FREAD: %d", (v&0x02)>>1);
MMA8452_DBG(" 0 ACTIVE: %d", (v&0x01));
break;
case MMA8452_XYZ_DATA_CFG:
MMA8452_DBG("XYZ_DATA_CFG has value: 0x%x",v);
MMA8452_DBG(" 7 Unused: %d", (v&0x80)>>7);
MMA8452_DBG(" 6 0: %d", (v&0x40)>>6);
MMA8452_DBG(" 5 0: %d", (v&0x20)>>5);
MMA8452_DBG(" 4 HPF_Out: %d",(v&0x10)>>4);
MMA8452_DBG(" 3 0: %d", (v&0x08)>>3);
MMA8452_DBG(" 2 0: %d", (v&0x04)>>2);
MMA8452_DBG(" 1 FS1: %d", (v&0x02)>>1);
MMA8452_DBG(" 0 FS0: %d", (v&0x01));
switch(v&0x03) {
case 0:
MMA8452_DBG("Dynamic range: 2G");
break;
case 1:
MMA8452_DBG("Dynamic range: 4G");
break;
case 2:
MMA8452_DBG("Dynamic range: 8G");
break;
default:
MMA8452_DBG("Unknown dynamic range");
break;
}
break;
case MMA8452_STATUS:
MMA8452_DBG("STATUS has value: 0x%x",v);
MMA8452_DBG(" 7 ZYXOW: %d",(v&0x80)>>7);
MMA8452_DBG(" 6 ZOW: %d", (v&0x40)>>6);
MMA8452_DBG(" 5 YOW: %d", (v&0x20)>>5);
MMA8452_DBG(" 4 XOW: %d", (v&0x10)>>4);
MMA8452_DBG(" 3 ZYXDR: %d",(v&0x08)>>3);
MMA8452_DBG(" 2 ZDR: %d", (v&0x04)>>2);
MMA8452_DBG(" 1 YDR: %d", (v&0x02)>>1);
MMA8452_DBG(" 0 XDR: %d", (v&0x01));
break;
default:
MMA8452_DBG("Unknown register address: 0x%x",reg);
break;
}
}
void MAX30100::setLedsPulseWidth(LEDPulseWidth ledPulseWidth)
{
uint8_t previous = readRegister(MAX30100_REG_SPO2_CONFIGURATION);
writeRegister(MAX30100_REG_SPO2_CONFIGURATION, (previous & 0xfc) | ledPulseWidth);
}
uint8_t Adafruit_ADXL345_Unified::getDeviceID(void) {
// Check device ID register
return readRegister(ADXL345_REG_DEVID);
}
uint8_t Nrf24l::getStatus(){
uint8_t rv;
readRegister(STATUS,&rv,1);
return rv;
}
