unsigned char
ds1631ReadRegister(struct ds1631_t* ds, unsigned char cmd)
{
unsigned char result;
i2cStart((ds->addr & 0xFE));
i2cWrite(cmd);
i2cStop();
i2cStart(ds->addr);
result = i2cReadNAK();
i2cStop();
return result;
}
void
ds1631WriteConfig(struct ds1631_t* ds, unsigned char data)
{
i2cStart((ds->addr & 0xFE));
i2cWrite(data);
i2cStop();
}
void I2C::close(){
if(!(--refcnt)){
clk_mgr_req_hsi();
i2cStop(&driver);
clk_mgr_noreq_hsi();
}
}
boolean i2cMasterTransfer(const I2C_DEVICE* device, size_t wlen, const uint8_t *wdata, size_t rlen, uint8_t * rdata){
boolean ack = false;
if(device){
const I2C_ABSTRACT_BUS* i2c = device->bus;
// Write the data
ack = i2cStart(i2c,device->addr,TRUE);
if(ack){
// send the data
while(ack && wlen--){
ack &= i2cPut(i2c,*wdata++);
}
}
// Read the response
if(ack){
ack = i2cStart(i2c,device->addr,FALSE); // repeated start
}
if(ack){
// Read the data
while(rlen--){
*rdata++ = i2cGet(i2c, (rlen) ? FALSE : TRUE);
}
}
// Stop
i2cStop(i2c);
}
return ack;
}
/**
* @brief Deactivates the LPS25H Complex Driver peripheral.
*
* @param[in] devp pointer to the @p LPS25HDriver object
*
* @api
*/
void lps25hStop(LPS25HDriver *devp) {
uint8_t cr[2];
osalDbgCheck(devp != NULL);
osalDbgAssert((devp->state == LPS25H_STOP) || (devp->state == LPS25H_READY),
"lps25hStop(), invalid state");
if (devp->state == LPS25H_READY) {
#if (LPS25H_USE_I2C)
#if LPS25H_SHARED_I2C
i2cAcquireBus((devp)->config->i2cp);
i2cStart((devp)->config->i2cp,
(devp)->config->i2ccfg);
#endif /* LPS25H_SHARED_I2C */
cr[0] = LPS25H_AD_CTRL_REG1;
cr[1] = 0;
lps25hI2CWriteRegister(devp->config->i2cp, devp->config->slaveaddress,
cr, 1);
i2cStop((devp)->config->i2cp);
#if LPS25H_SHARED_I2C
i2cReleaseBus((devp)->config->i2cp);
#endif /* LPS25H_SHARED_I2C */
#endif /* LPS25H_USE_I2C */
}
devp->state = LPS25H_STOP;
}
/* Places 'data' into register 'reg' */
void MAX7300_SetRegister(uint8_t address, uint8_t reg, uint8_t data)
{
i2cAddress(address, TW_WRITE);
i2cTransmit(reg);
i2cTransmit(data);
i2cStop();
}
tS8
i2cMyWrite(tU8 addr,
tU8 *pData,
tU16 len) {
tS8 retCode = 0;
tU8 i = 0;
do {
/* generate Start condition */
retCode = i2cStart();
if (retCode != I2C_CODE_OK)
break;
/* write address */
retCode = i2cWriteWithWait(addr);
if (retCode != I2C_CODE_OK)
break;
for (i = 0; i < len; i++) {
retCode = i2cWriteWithWait(*pData);
if (retCode != I2C_CODE_OK)
break;
pData++;
}
} while (0);
/* generate Stop condition */
i2cStop();
return retCode;
}
/**
* @brief Deactivates the LSM6DS0 Complex Driver peripheral.
*
* @param[in] devp pointer to the @p LSM6DS0Driver object
*
* @api
*/
void lsm6ds0Stop(LSM6DS0Driver *devp) {
osalDbgCheck(devp != NULL);
osalDbgAssert((devp->state == LSM6DS0_STOP) || (devp->state == LSM6DS0_READY),
"lsm6ds0Stop(), invalid state");
#if (LSM6DS0_USE_I2C)
if (devp->state == LSM6DS0_STOP) {
#if LSM6DS0_SHARED_I2C
i2cAcquireBus((devp)->config->i2cp);
i2cStart((devp)->config->i2cp,
(devp)->config->i2ccfg);
#endif /* LSM6DS0_SHARED_I2C */
if((devp)->config->acccfg != NULL) {
lsm6ds0I2CWriteRegister(devp->config->i2cp,
devp->config->slaveaddress,
LSM6DS0_AD_CTRL_REG6_XL,
LSM6DS0_ACC_ODR_PD);
}
if((devp)->config->gyrocfg != NULL) {
lsm6ds0I2CWriteRegister(devp->config->i2cp,
devp->config->slaveaddress,
LSM6DS0_AD_CTRL_REG9,
LSM6DS0_GYRO_SLP_ENABLED);
}
i2cStop((devp)->config->i2cp);
#if LSM6DS0_SHARED_I2C
i2cReleaseBus((devp)->config->i2cp);
#endif /* LSM6DS0_SHARED_I2C */
}
#endif /* LSM6DS0_USE_I2C */
devp->state = LSM6DS0_STOP;
}
static uint32_t getTemperatureStr(char * temperatureStr)
{
float temperature = 0;
float pressure = 0;
spiAcquireBus(&CC3000_SPI_DRIVER);
i2cAcquireBus(&I2C_DRIVER);
i2cStart(&I2C_DRIVER, &i2cConfig);
if (RDY_OK != mplOneShotReadBarometer(&I2C_DRIVER,
MPL3115A2_DEFAULT_ADDR,
&pressure,
&temperature))
{
return 1;
}
i2cStop(&I2C_DRIVER);
i2cReleaseBus(&I2C_DRIVER);
spiReleaseBus(&CC3000_SPI_DRIVER);
temperature += CELSIUS_TO_KELVIN;
snprintf(temperatureStr, TEMPERATURE_STRING_SIZE, "%.2f K", temperature);
temperatureStr[TEMPERATURE_STRING_SIZE-1] = 0;
return 0;
}
/**
* @brief Deactivates the LSM6DS0 Complex Driver peripheral.
*
* @param[in] devp pointer to the @p LSM6DS0Driver object
*
* @api
*/
void lsm6ds0Stop(LSM6DS0Driver *devp) {
uint8_t cr[2];
osalDbgCheck(devp != NULL);
osalDbgAssert((devp->state == LSM6DS0_STOP) || (devp->state == LSM6DS0_READY),
"lsm6ds0Stop(), invalid state");
if (devp->state == LSM6DS0_READY) {
#if LSM6DS0_USE_I2C
#if LSM6DS0_SHARED_I2C
i2cAcquireBus(devp->config->i2cp);
i2cStart(devp->config->i2cp, devp->config->i2ccfg);
#endif /* LSM6DS0_SHARED_I2C */
/* Disabling accelerometer.*/
cr[0] = LSM6DS0_AD_CTRL_REG6_XL;
cr[1] = 0;
lsm6ds0I2CWriteRegister(devp->config->i2cp, devp->config->slaveaddress,
cr, 1);
/* Disabling gyroscope.*/
cr[0] = LSM6DS0_AD_CTRL_REG9;
cr[1] = LSM6DS0_CTRL_REG9_SLEEP_G;
lsm6ds0I2CWriteRegister(devp->config->i2cp, devp->config->slaveaddress,
cr, 1);
i2cStop(devp->config->i2cp);
#if LSM6DS0_SHARED_I2C
i2cReleaseBus(devp->config->i2cp);
#endif /* LSM6DS0_SHARED_I2C */
#endif /* LSM6DS0_USE_I2C */
}
devp->state = LSM6DS0_STOP;
}
static uint32_t getPressureStr(char * pressureStr)
{
float pressure;
float temperature;
spiAcquireBus(&CC3000_SPI_DRIVER);
i2cAcquireBus(&I2C_DRIVER);
i2cStart(&I2C_DRIVER, &i2cConfig);
if (RDY_OK != mplOneShotReadBarometer(&I2C_DRIVER,
MPL3115A2_DEFAULT_ADDR,
&pressure,
&temperature))
{
return 1;
}
i2cStop(&I2C_DRIVER);
i2cReleaseBus(&I2C_DRIVER);
spiReleaseBus(&CC3000_SPI_DRIVER);
pressure /= 1000; /* kPa */
snprintf(pressureStr, PRESSURE_STRING_SIZE, "%.2f kPa", pressure);
pressureStr[PRESSURE_STRING_SIZE-1] = 0;
return 0;
}
/**
* Implementing the CHAR dev write API.
*
* Note, this doesn't implement ulFlags specific options yet!
**/
static BT_ERROR i2cWrite(BT_HANDLE hI2C, BT_u16 usDevice, BT_u8 *pucSource, BT_u32 ulLength) {
BT_ERROR Error = BT_ERR_NONE;
i2cStart(hI2C);
Error = i2cSendAddress(hI2C, usDevice, BT_I2C_WRITE_ACCESS);
if (Error) goto err_out;
Error = i2cSendData(hI2C, pucSource, ulLength);
if (Error) goto err_out;
Error = i2cStop(hI2C);
return Error;
err_out:
i2cStop(hI2C);
return Error;
}
int SMBusGet(I2CDriver * driver, uint8_t addr, uint8_t command, uint16_t* data){
uint8_t tx[1] = {command};
uint8_t rx[2];
i2cflags_t errors;
i2cAcquireBus(driver);
msg_t status = i2cMasterTransmitTimeout(driver, addr, tx, sizeof(tx), rx, sizeof(rx), I2C_TIMEOUT);
switch(status){
case RDY_OK:
i2cReleaseBus(driver);
break;
case RDY_RESET:
errors = i2cGetErrors(driver);
i2cReleaseBus(driver);
return errors;
case RDY_TIMEOUT:
/* On a timeout ChibiOS will set the bus into I2C_LOCKED, which will
* cause an assert to be hit if a bus transfer is tried again.
* I2C_LOCKED can only be cleared by i2cStart(), but i2cStart will hit
* an assert if i2cStop is not issued before restarting.
* This seems like a really terrible way to handle timeous*/
i2cStop(driver);
i2cStart(driver, driver->config);
i2cReleaseBus(driver);
return RDY_TIMEOUT;
default:
i2cReleaseBus(driver);
}
*data = DATA_FROM_BYTES(rx[0], rx[1]);
return RDY_OK;
}
void rtcGetTime(unsigned char * h, unsigned char * m, unsigned char * s)
{
i2cStart();
i2cWrite(0xD0);
i2cWrite(0);
i2cStop();
i2cStart();
i2cWrite(0xD1);
* s = i2cRead(1);
* m = i2cRead(1);
* h = i2cRead(0);
i2cStop();
}
static msg_t temp_thread(void *arg) {
(void)arg;
chRegSetThreadName("I2C Temp samp");
uint8_t rxbuf[10];
uint8_t txbuf[10];
msg_t status = RDY_OK;
systime_t tmo = MS2ST(5);
i2caddr_t temp_addr = 0x48;
hw_start_i2c();
chThdSleepMilliseconds(10);
for(;;) {
if (i2c_running) {
txbuf[0] = 0x00;
i2cAcquireBus(&HW_I2C_DEV);
status = i2cMasterTransmitTimeout(&HW_I2C_DEV, temp_addr, txbuf, 1, rxbuf, 2, tmo);
i2cReleaseBus(&HW_I2C_DEV);
if (status == RDY_OK){
int16_t tempi = rxbuf[0] << 8 | rxbuf[1];
float temp = (float)tempi;
temp /= 128;
temp_now = temp;
} else {
// Try to restore the i2c bus
i2cAcquireBus(&HW_I2C_DEV);
palSetPadMode(HW_I2C_SCL_PORT, HW_I2C_SCL_PIN,
PAL_STM32_OTYPE_OPENDRAIN |
PAL_STM32_OSPEED_MID1 |
PAL_STM32_PUDR_PULLUP);
for(int i = 0;i < 16;i++) {
palClearPad(HW_I2C_SCL_PORT, HW_I2C_SCL_PIN);
chThdSleep(1);
palSetPad(HW_I2C_SCL_PORT, HW_I2C_SCL_PIN);
chThdSleep(1);
}
palSetPadMode(HW_I2C_SCL_PORT, HW_I2C_SCL_PIN,
PAL_MODE_ALTERNATE(HW_I2C_GPIO_AF) |
PAL_STM32_OTYPE_OPENDRAIN |
PAL_STM32_OSPEED_MID1 |
PAL_STM32_PUDR_PULLUP);
i2cStop(&HW_I2C_DEV);
i2cStart(&HW_I2C_DEV, &i2cfg);
i2cReleaseBus(&HW_I2C_DEV);
}
}
chThdSleepMilliseconds(100);
}
return 0;
}
void i2c_write_reg(u8 dev_adr, u8 reg_adr, u8 value)
{
i2cStart();
i2cWrite(dev_adr); /*slave address, write command*/
i2cWrite(reg_adr); /*send reg address*/
i2cWrite(value);
i2cStop();
}
static BT_ERROR i2cRead(BT_HANDLE hI2C, BT_u16 usDevice, BT_u8 *pucDest, BT_u32 ulLength) {
BT_ERROR Error = BT_ERR_NONE;
i2cStart(hI2C);
Error = i2cSendAddress(hI2C, usDevice, BT_I2C_READ_ACCESS);
if (Error) goto err_out;
Error = i2cGetData(hI2C, pucDest, ulLength);
if (Error) goto err_out;
Error = i2cStop(hI2C);
return Error;
err_out:
i2cStop(hI2C);
return Error;
}
//write a byte to eeprom
void writeEEPROM(short address, BYTE data){
i2cStart(I2C2);
i2cSendByte(I2C2, 0x50 << 1);
i2cSendByte(I2C2, (address & 0xFF00)>> 8);
i2cSendByte(I2C2, address & 0xFF);
i2cSendByte(I2C2, data);
i2cStop(I2C2);
}
void tm1637::power(bool state)
{
_power = (state?TM1637_CMD_POWER_ON:TM1637_CMD_POWER_OFF);
i2cStart();
i2cWrite( _power | _brightness );
i2cAck();
i2cStop();
}
/* Public Methods *******************************************/
void tm1637::setBrightness(uint8_t b)
{
_brightness = (b & 0b111);
i2cStart();
i2cWrite( _power | _brightness );
i2cAck();
i2cStop();
}
void tm1637::initDisplay(void)
{
i2cStart();
i2cWrite(0x40);
i2cAck();
i2cStop();
clear();
}
void rtcInit(void)
{
i2cInit();
i2cStart();
i2cWrite(0xD0); // Address the RTC to write
i2cWrite(0x07);
i2cWrite(0x00);
i2cStop();
}
//set one of the four digits [0 - 3]
//value [0 - 9]
void tm1637::writeDigit(uint8_t digit, uint8_t value)
{
i2cStart();
i2cWrite(0xc0 | digit);
i2cAck();
i2cWrite(data[value]);
i2cAck();
i2cStop();
}
void i2c_init(void){
i2cStop(&I2CD1);
i2cStop(&I2CD2);
/* tune ports for I2C1*/
palSetPadMode(GPIOB, 8, PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_PUPDR_FLOATING); // SCL
palSetPadMode(GPIOB, 9, PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_PUPDR_FLOATING); // SDA
/* tune ports for I2C2*/
palSetPadMode(GPIOB, 10, PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_PUPDR_FLOATING); // SCL
palSetPadMode(GPIOB, 11, PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_PUPDR_FLOATING); // SDA
i2cStart(&I2CD1, &i2cfg1);
i2cStart(&I2CD2, &i2cfg2);
/* startups. Pauses added just to be safe */
chThdSleepMilliseconds(100);
}
/**
* Prüft, ob ein I2C-Device antwortet.
*
* @param [in] ucAdr
* die I2C-Adresse des gewünschten Gerätes
*
* @return
* EC_SUCCESS falls der Slave immer mit ACK geantwortet hat
* EC_I2C_NO_ANSWER falls I2C-Gerät nicht geantwortet hat
*/
tError i2cTest(uint8 adr)
{
tError result;
result = i2cStart(adr, TRUE);
if (result != EC_SUCCESS) return result;
i2cStop();
return EC_SUCCESS;
}
void rtcSetTime(unsigned char h,unsigned char m, unsigned char s)
{
i2cStart();
i2cWrite(0xD0);
i2cWrite(0);
i2cWrite(s);
i2cWrite(m);
i2cWrite(h);
i2cStop();
}
void srf08SetRange(uint16_t range)
{
// range is calculated: ((Range Register x 43mm) + 43mm)
uint8_t actualValue = (range /= 43) & 0xff;
i2cStart();
i2cTransmit(currentAddress); // select current device
i2cTransmit(0x02); // select range register
i2cTransmit(actualValue); // write the range value
i2cStop();
}
//read a byte from the eeprom
BYTE readEEPROM(BYTE address){
i2cStart(I2C2);
i2cSendByte(I2C2, 0x50 << 1);
i2cSendByte(I2C2, (address & 0xFF00)>> 8);
i2cSendByte(I2C2, address & 0xFF);
i2cRepeatedStart(I2C2);
i2cSendByte(I2C2, 0x50 << 1 | 0x01);
BYTE temp = i2cRecieveByte(I2C2, FALSE);
i2cStop(I2C2);
return temp;
}
void srf08SetGain(uint8_t gain)
{
if(gain > 31)
gain = 31;
i2cStart();
i2cTransmit(currentAddress);
i2cTransmit(0x01); // select gain register
i2cTransmit(gain);
i2cStop();
}
msg_t I2C::receive(i2caddr_t addr, uint8_t* rxbuf, size_t rxbytes,
systime_t timeout){
msg_t msg;
lock();
msg = i2cMasterReceiveTimeout(&driver, addr, rxbuf, rxbytes, timeout);
if(msg == RDY_TIMEOUT){
i2cStop(&driver);
i2cStart(&driver, &config);
}
unlock();
return msg;
}
