//**************************************************************************** // //! Read an 8 bit data from a register on the PWM board //! //! \param regAddress: register's address // //! \return 8 bit data //**************************************************************************** static uint8_t read(uint8_t regAddress) { int iRetVal; unsigned char DataBuf[1]; //Construct the data buffer DataBuf[0] = (unsigned char) regAddress; //Send command to the PWM board iRetVal = I2C_IF_Write((unsigned char)PWM_ADDRESS, DataBuf, 1, 1); if(iRetVal == FAILURE) { #ifdef PWM_DEBUG UART_PRINT("I2C Read failed\n\r"); #endif return 0; // TODO: figure out error code, use 0 as temp } //Read the value from the register iRetVal = I2C_IF_Read((unsigned char)PWM_ADDRESS, DataBuf, 1); if(iRetVal == SUCCESS) { #ifdef PWM_DEBUG //UART_PRINT("I2C Read complete\n\r"); #endif return ((uint8_t)DataBuf[0]); } else { #ifdef PWM_DEBUG UART_PRINT("I2C Read failed\n\r"); #endif return 0;// TODO: figure out error code, use 0 as temp } }
//**************************************************************************** // //! Write an 8 bit data to a register on the PWM board //! //! \param regAddress: the address of the register // data: the 8 bit data // //! \return 0: SUCCESS; >0 Failure //**************************************************************************** static int write(uint8_t regAddress, uint8_t data) { unsigned char DataBuf[2]; int iRetVal; //Construct the Data buffer befor sending DataBuf[0] = (unsigned char)regAddress; DataBuf[1] = (unsigned char)data; // Write the data to the register on the PWM Board iRetVal = I2C_IF_Write((unsigned char)PWM_ADDRESS, DataBuf, 2, 1); if(iRetVal == SUCCESS) { #ifdef PWM_DEBUG //UART_PRINT("I2C Write complete\n\r"); #endif return SUCCESS; } else { #ifdef PWM_DEBUG UART_PRINT("I2C Write failed\n\r"); #endif return FAILURE; } }
//**************************************************************************** // //! Parses the write command parameters and invokes the I2C APIs //! //! \param pcInpString pointer to the write command parameters //! //! This function //! 1. Parses the write command parameters. //! 2. Invokes the corresponding I2C APIs //! //! \return 0: Success, < 0: Failure. // //**************************************************************************** int ProcessWriteCommand(char *pcInpString) { unsigned char ucDevAddr, ucStopBit, ucLen; unsigned char aucDataBuf[256]; char *pcErrPtr; int iRetVal, iLoopCnt; // // Get the device address // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); ucDevAddr = (unsigned char)strtoul(pcInpString+2, &pcErrPtr, 16); // // Get the length of data to be written // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); ucLen = (unsigned char)strtoul(pcInpString, &pcErrPtr, 10); //RETERR_IF_TRUE(ucLen > sizeof(aucDataBuf)); for(iLoopCnt = 0; iLoopCnt < ucLen; iLoopCnt++) { // // Store the data to be written // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); aucDataBuf[iLoopCnt] = (unsigned char)strtoul(pcInpString+2, &pcErrPtr, 16); } // // Get the stop bit // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); ucStopBit = (unsigned char)strtoul(pcInpString, &pcErrPtr, 10); // // Write the data to the specified address // iRetVal = I2C_IF_Write(ucDevAddr, aucDataBuf, ucLen, ucStopBit); if(iRetVal == SUCCESS) { UART_PRINT("I2C Write complete\n\r"); } else { UART_PRINT("I2C Write failed\n\r"); return FAILURE; } return SUCCESS; }
struct bm222_ctx *bm222_init(uint8_t addr) { struct bm222_ctx *ctx = (struct bm222_ctx *) calloc(1, sizeof(*ctx)); if (ctx == NULL) return NULL; ctx->addr = addr; { unsigned char val[2] = {BM222_REG_BGW_SOFTRESET, BM222_DO_SOFT_RESET}; if (I2C_IF_Write(addr, val, 2, 1) != 0) goto out_err; osi_Sleep(2 /* ms */); /* t_w,up1 = 1.8 ms */ } if (!bm222_fifo_init(ctx)) return false; { unsigned char val[2] = {BM222_REG_PMU_BW, BM222_PMU_BW_125_HZ}; if (I2C_IF_Write(addr, val, 2, 1) != 0) goto out_err; } return ctx; out_err: free(ctx); return NULL; }
//**************************************************************************** // //! Parses the writereg command parameters and invokes the I2C APIs //! i2c writereg 0x<dev_addr> 0x<reg_offset> <wrlen> <0x<byte0> [0x<byte1> ... ]> //! //! \param pcInpString pointer to the readreg command parameters //! //! This function //! 1. Parses the writereg command parameters. //! 2. Invokes the corresponding I2C APIs //! //! \return 0: Success, < 0: Failure. // //**************************************************************************** int ProcessWriteRegCommand(char *pcInpString) { unsigned char ucDevAddr, ucRegOffset, ucWrLen; unsigned char aucDataBuf[256]; char *pcErrPtr; int iLoopCnt = 0; // // Get the device address // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); ucDevAddr = (unsigned char)strtoul(pcInpString+2, &pcErrPtr, 16); // // Get the register offset to be written // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); ucRegOffset = (unsigned char)strtoul(pcInpString+2, &pcErrPtr, 16); aucDataBuf[iLoopCnt] = ucRegOffset; iLoopCnt++; // // Get the length of data to be written // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); ucWrLen = (unsigned char)strtoul(pcInpString, &pcErrPtr, 10); //RETERR_IF_TRUE(ucWrLen > sizeof(aucDataBuf)); // // Get the bytes to be written // for(; iLoopCnt < ucWrLen + 1; iLoopCnt++) { // // Store the data to be written // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); aucDataBuf[iLoopCnt] = (unsigned char)strtoul(pcInpString+2, &pcErrPtr, 16); } // // Write the data values. // RET_IF_ERR(I2C_IF_Write(ucDevAddr,&aucDataBuf[0],ucWrLen+1,1)); UART_PRINT("I2C Write To address complete\n\r"); return SUCCESS; }
//**************************************************************************** // //! Parses the readreg command parameters and invokes the I2C APIs //! i2c readreg 0x<dev_addr> 0x<reg_offset> <rdlen> //! //! \param pcInpString pointer to the readreg command parameters //! //! This function //! 1. Parses the readreg command parameters. //! 2. Invokes the corresponding I2C APIs //! //! \return 0: Success, < 0: Failure. // //**************************************************************************** int ProcessReadRegCommand(char *pcInpString) { unsigned char ucDevAddr, ucRegOffset, ucRdLen; unsigned char aucRdDataBuf[256]; char *pcErrPtr; // // Get the device address // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); ucDevAddr = (unsigned char)strtoul(pcInpString+2, &pcErrPtr, 16); // // Get the register offset address // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); ucRegOffset = (unsigned char)strtoul(pcInpString+2, &pcErrPtr, 16); // // Get the length of data to be read // pcInpString = strtok(NULL, " "); RETERR_IF_TRUE(pcInpString == NULL); ucRdLen = (unsigned char)strtoul(pcInpString, &pcErrPtr, 10); //RETERR_IF_TRUE(ucLen > sizeof(aucDataBuf)); // // Write the register address to be read from. // Stop bit implicitly assumed to be 0. // RET_IF_ERR(I2C_IF_Write(ucDevAddr,&ucRegOffset,1,0)); // // Read the specified length of data // RET_IF_ERR(I2C_IF_Read(ucDevAddr, &aucRdDataBuf[0], ucRdLen)); UART_PRINT("I2C Read From address complete\n\r"); // // Display the buffer over UART on successful readreg // DisplayBuffer(aucRdDataBuf, ucRdLen); return SUCCESS; }
//**************************************************************************** // //! Sets the value in the specified register //! //! \param ucRegAddr is the offset register address //! \param ucRegValue is the register value to be set //! //! This function //! 1. Returns the value in the specified register //! //! \return 0: Success, < 0: Failure. // //**************************************************************************** int SetRegisterValue(unsigned char ucRegAddr, unsigned char ucRegValue) { unsigned char ucData[2]; // // Select the register to be written followed by the value. // ucData[0] = ucRegAddr; ucData[1] = ucRegValue; // // Initiate the I2C write // if(I2C_IF_Write(BMA222_DEV_ADDR,ucData,2,1) == 0) { return SUCCESS; } else { DBG_PRINT("I2C write failed\n\r"); } return FAILURE; }
int HDC1050::get_tempature_and_humidity(HDC1050::reading &measurement) { // execute pointer write transaction at 0x00 int rc = I2C_IF_Write(DEVICE_ADDRESS,0 /* device address*/, 1 /* bytes to read */, 0 /*no stop bit */); // wait at least 6.5 milliseconds - every 1000 ticks is 12.5 us MAP_UtilsDelay(10000000); static uint8_t temperature[2]; static uint8_t humidity[2]; uint32_t temp = 0; uint32_t hum = 0; // read I2C_IF_Read(DEVICE_ADDRESS + Registers8::temperature, &temperature[0], 2); I2C_IF_Read(DEVICE_ADDRESS + Registers8::humidity , &humidity[0], 2); // process readings temp = temperature[1]; temp = temp << 4; temp += temperature[0]; temp = temp * 165 - 40; temp = temp << 16; measurement.temperature = temp; // celsius hum = humidity[1]; hum *= 100; hum = hum << 16; measurement.humidity = hum; // relative humidty as percentage // todo: check for nack return 0; }
bool bm222_fifo_init(struct bm222_ctx *ctx) { unsigned char val[2] = {BM222_REG_FIFO_CONFIG_1, BM222_FIFO_MODE_FIFO | BM222_FIFO_DATA_ALL}; return (I2C_IF_Write(ctx->addr, val, 2, 1) == 0); }