Azure Sphere Secure IOT - I2C Compass

Hi Andy,

If you're running this on a laptop, it could be worth unplugging it from the PSU temporarily, just to check if it is being caused by current through the ground connection.

Also, it's a pain when APIs use High and Low for open drain, because it's never completely clear if the high means floating high, or pulled to ground (because in open drain, when the signal is asserted, it is pulled low, whereas with normal push-pull, when it is asserted, it is pulled high). So it is easier if they'd use the term asserted.

But it sounds like you've already checked that since you connected an LED. And if you've stepped through the code it seems like all is well there.. I think it could be worth replacing the 10k with 2.2k, just in case the load is too high.

Hi Andy,

If you're running this on a laptop, it could be worth unplugging it from the PSU temporarily, just to check if it is being caused by current through the ground connection.

Also, it's a pain when APIs use High and Low for open drain, because it's never completely clear if the high means floating high, or pulled to ground (because in open drain, when the signal is asserted, it is pulled low, whereas with normal push-pull, when it is asserted, it is pulled high). So it is easier if they'd use the term asserted.

But it sounds like you've already checked that since you connected an LED. And if you've stepped through the code it seems like all is well there.. I think it could be worth replacing the 10k with 2.2k, just in case the load is too high.

Cheers, Shabaz, actually from the desktop, I know that the USB ground is connected to the probe ground on the Picoscope but both devices are coming from the same computer so the ground should be ok... ? The example where I did get it to record was when the scope ground was disconnected. The Picoscope still resets the bus even when no probes are connected so I think the only way I'm going to get that to play is with something like a USB 3 PCI (or higher current USB 2 PCI) card.

I am now getting some form of communication with the device but it's not quite right yet.

There's three convenient status registers that return fixed values. 72  52 51

I can get these to return properly but only if I read the middle register twice. If I try to read multiple bytes it all goes wrong. Reading other registers does not seem too predictable either although I think the status register returns ok. That's also a single byte and you get a 1 or 0 depending on if the magnetic readings are ready.

Setup

    const unsigned char msg1[2] = { HMC5883_REGISTER_MAG_CRA_REG_M, 0x00 }; // 8 average samples, 15Hz, Normal Bias
    const unsigned char msg2[2] = { HMC5883_REGISTER_MAG_CRB_REG_M, HMC5883_MAGGAIN_4_7 }; // Gain
    const unsigned char msg3[2] = { HMC5883_REGISTER_MAG_MR_REG_M, 0x00 }; // Enable Magnetometer, Continuous mode, Low Speed I2C 
    i2c_bb_tx(&i2cbus1, HMC5883_ADDRESS_MAG, &msg1[0], 2);
    i2c_bb_tx(&i2cbus1, HMC5883_ADDRESS_MAG, &msg2[0], 2);
    i2c_bb_tx(&i2cbus1, HMC5883_ADDRESS_MAG, &msg3[0], 2);

Reading

unsigned char rec[15];        
         i2c_bb_rx(&i2cbus1, HMC5883_ADDRESS_MAG, HMC5883_REGISTER_MAG_IRA_REG_M, &rec[0], 1);
         i2c_bb_rx(&i2cbus1, HMC5883_ADDRESS_MAG, HMC5883_REGISTER_MAG_IRB_REG_M, &rec[1], 1);
         i2c_bb_rx(&i2cbus1, HMC5883_ADDRESS_MAG, HMC5883_REGISTER_MAG_IRB_REG_M, &rec[1], 1); // Why twice?
         i2c_bb_rx(&i2cbus1, HMC5883_ADDRESS_MAG, HMC5883_REGISTER_MAG_IRC_REG_M, &rec[2], 1);
Log_Debug("Reading: %d  %d %d \n", rec[0], rec[1],rec[2]);

Changing the clock speed makes no difference. Changing the resistors makes no difference. I've can confirm that the correct address (with the lowest bit as R/!W) is getting sent.

I have tweaked the code to match the data sheet although I guess I've got a timing or signal issue somewhere.

https://cdn-shop.adafruit.com/datasheets/HMC5883L_3-Axis_Digital_Compass_IC.pdf

#include <applibs/gpio.h>
#include <applibs/log.h>
#include <stdbool.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include "i2cbb.h"


#define BIT0 1


//Port from https://github.com/AlaskaResearchCubeSat/bit-bang-I2C


/// <summary>
///     setup bit bang I2C pins
/// </summary>
/// <returns>0 on success, or -1 on failure</returns>
int i2c_bb_setup(i2cbus_t* bus) {
    //set pins as outputs opendrain
    bus->sclFd = GPIO_OpenAsOutput(bus->scl, GPIO_OutputMode_OpenDrain, GPIO_Value_High);
    if (bus->sclFd < 0) {
        Log_Debug("ERROR: Could not open SCL GPIO: %s (%d).\n", strerror(errno), errno);
        return -1;
    }
    bus->sdaFd = GPIO_OpenAsOutput(bus->sda, GPIO_OutputMode_OpenDrain, GPIO_Value_High);
    if (bus->sdaFd < 0) {
        Log_Debug("ERROR: Could not open SDA GPIO: %s (%d).\n", strerror(errno), errno);
        return -1;
    }
    return 0;
}


//wait for 1/2 of I2C clock period (50000 = 10Khz clock)
void i2c_bb_hc(void) {
    const struct timespec clockhalftime = { 0, 50000 };
    //wait for 0.05ms
    nanosleep(&clockhalftime, NULL);
}


int setSDA(i2cbus_t* bus, GPIO_Value_Type val) {
    int result = GPIO_SetValue(bus->sdaFd, val);
    if (result != 0) {
        Log_Debug("ERROR: Could not set SDA output value: %s (%d).\n", strerror(errno), errno);
        return -1;
    }
    return 0;
}


int setSCL(i2cbus_t* bus, GPIO_Value_Type val) {
    int result = GPIO_SetValue(bus->sclFd, val);
    if (result != 0) {
        Log_Debug("ERROR: Could not set SCL output value: %s (%d).\n", strerror(errno), errno);
        return -1;
    }
    return 0;
}


unsigned char getSDA(i2cbus_t* bus) {
    GPIO_Value_Type val;
    int result = GPIO_GetValue(bus->sdaFd, &val);
    if (result != 0) {
        Log_Debug("ERROR: Could not read SDA value: %s (%d).\n", strerror(errno), errno);
    }
    return val;
}


void i2c_bb_start(i2cbus_t* bus) {
    i2c_bb_hc();
    //float SCL
    setSCL(bus, GPIO_Value_High);
    //wait for 1/2 clock first
    i2c_bb_hc();
    //pull SDA low
    setSDA(bus, GPIO_Value_Low);
    //wait for 1/2 clock for end of start
    i2c_bb_hc();
}


void i2c_bb_stop(i2cbus_t* bus) {
    i2c_bb_hc();
    //pull SDA low
    setSDA(bus, GPIO_Value_Low);
    //wait for 1/2 clock for end of start
    i2c_bb_hc();
    //float SCL
    setSCL(bus, GPIO_Value_High);
    //wait for 1/2 clock
    i2c_bb_hc();
    //float SDA
    setSDA(bus, GPIO_Value_High);
    //wait for 1/2 clock
    i2c_bb_hc();
}


//send value over I2C return 1 if slave ACKed
short i2c_bb_tx_byte(i2cbus_t* bus, unsigned char val) {
    int i;
    //shift out bits
    for (i = 0;i < 8;i++) {
        //pull SCL low
        setSCL(bus, GPIO_Value_Low);
        //check bit
        if (val & 0x80) {
            //float SDA
            setSDA(bus, GPIO_Value_High);
        }
        else {
            //pull SDA low
            setSDA(bus, GPIO_Value_Low);
        }
        //shift
        val <<= 1;
        //wait for 1/2 clock
        i2c_bb_hc();
        //float SCL
        setSCL(bus, GPIO_Value_High);
        //wait for 1/2 clock
        i2c_bb_hc();
    }
    //check ack bit
    //pull SCL low
    setSCL(bus, GPIO_Value_Low);
    //float SDA
    setSDA(bus, GPIO_Value_High);
    //wait for 1/2 clock
    i2c_bb_hc();
    //float SCL
    setSCL(bus, GPIO_Value_High);
    //wait for 1/2 clock
    i2c_bb_hc();
    //sample SDA
    val = getSDA(bus);
    //pull SCL low
    setSCL(bus, GPIO_Value_Low);
    //return sampled value
    return !val;
}
//send value over I2C return 1 if slave ACKed
unsigned char i2c_bb_rx_byte(i2cbus_t* bus, unsigned short ack) {
    unsigned char val;
    int i;
    val = 0;


    //shift out bits
    for (i = 0;i < 8;i++) {
        //pull SCL low
        setSCL(bus, GPIO_Value_Low);
        //wait for 1/2 clock
        i2c_bb_hc();
        //float SCL
        setSCL(bus, GPIO_Value_High);
        //wait for 1/2 clock
        i2c_bb_hc();


        //shift value to make room
        val <<= 1;


        //sample data
        unsigned char readbit;
        readbit = getSDA(bus);


        if (readbit == GPIO_Value_High) {
            val |= 1;
        }
    }


    //check ack bit
    //pull SCL low
    setSCL(bus, GPIO_Value_Low);
    //check if we are ACKing this byte
    if (ack) {
        //pull SDA low for ACK
        setSDA(bus, GPIO_Value_Low);
    }
    else {
        //float SDA for NACK
        setSDA(bus, GPIO_Value_High);
    }
    //wait for 1/2 clock
    i2c_bb_hc();
    //float SCL
    setSCL(bus, GPIO_Value_High);
    //wait for 1/2 clock
    i2c_bb_hc();
    //pull SCL low
    setSCL(bus, GPIO_Value_Low);
    //float SDA
    setSDA(bus, GPIO_Value_High);
    //return value
    return val;
}


short i2c_bb_tx(i2cbus_t* bus, unsigned char addr, const unsigned char *dat, unsigned short len) {
    short ack;
    int i;
    //send start
    i2c_bb_start(bus);
    //send address with W bit
    ack = i2c_bb_tx_byte(bus, (addr << 1));
    //send data bytes
    for (i = 0;i < len && ack;i++) {
        //transmit next byte
        ack = i2c_bb_tx_byte(bus, dat[i]);
    }
    //transmit stop
    i2c_bb_stop(bus);
    //return if slave NACKed
    return ack;
}


short i2c_bb_rx(i2cbus_t* bus, unsigned char addr, unsigned char reg, unsigned char *dest, unsigned short len) {
    int i;
    //send start
    i2c_bb_start(bus);
    //send address with W bit
    if (!i2c_bb_tx_byte(bus, (addr << 1))) {
        //got NACK return error
        return 0;
    }
    //send register to read from
    if (!i2c_bb_tx_byte(bus, reg)) {
        //got NACK return error
        return 0;
    }
    i2c_bb_stop(bus);


    i2c_bb_start(bus);
    //send address with R bit
    if (!i2c_bb_tx_byte(bus, (addr << 1) | BIT0)) {
        //got NACK return error
        return 0;
    }
    //receive data bytes
    for (i = 0;i < len;i++) {
        //receive next byte
        dest[i] = i2c_bb_rx_byte(bus, i == len - 1);
    }
    //transmit stop
    i2c_bb_stop(bus);
    //return if slave NACKed
    return 1;
}

Here's an obvious question about my bitscope issue.

Is there any reason I can't just create a USB adapter cable that provides the 5v line from an external power supply. Would I need to load the 5v from the computer in anyway? If so would something like an LED be sufficient.

Hey Andy,

I'm so sorry, I missed seeing this earlier : (

Let me take a look today, get back to you this afternoon.

Hi Andy,

I think the Picoscope will be guaranteed to run at <=500mA, so there should be no overload to be honest, the USB port on the computer should support it. Are you using an external hub by they way? or directly into a USB port? Is it a laptop, or desktop?

It's a desktop but I've previously applied to to the laptop where it overloaded too.

https://www.picotech.com/support/topic21021.html   ≈ 350mA

I tried it via a powered hub but that didn't seem to help.

I do have a USB current monitor but I'm not sure if I can get a reading as it all shuts down.