Group Actions
Engagement
  • Author Author: Jan Cumps
  • Date Created: Date Created
  • Views 845 views
  • Likes 6 likes
  • Comments 12 comments
Related
Recommended

embedded C++: add cheap bitwise conversion to a register structure

Jan Cumps

This blog is based on real world work. I'm controlling a TI DRV8711 stepper motor controller via SPI.

I need to modify 16-bit registers of that IC. TI provided a header file with register definitions, and code to convert that struct to a 16 bit unsigned integer. That integer can then be sent over SPI.

C code

register struct (TI example: the control register)

 // CTRL Register
 struct CTRL_Register
 {
     uint16_t Address;	// bits 14-12
     uint16_t DTIME;		// bits 11-10
     uint16_t ISGAIN;	// bits 9-8
     uint16_t EXSTALL;	// bit 7
     uint16_t MODE;		// bits 6-3
     uint16_t RSTEP;		// bit 2
     uint16_t RDIR;		// bit 1
     uint16_t ENBL;		// bit 0
 };

code to convert an instance of the struct (reg) to a 16 bit unsigned int and write to SPI:

    uint16_t data;
    // prepare CTRL Register
    data = (reg.Address << 12) | (reg.DTIME << 10) | (reg.ISGAIN << 8) |(reg.EXSTALL << 7) | (reg.MODE << 3) | (reg.RSTEP << 2) | (reg.RDIR << 1) | (reg.ENBL);
    spi_write(data);

C++ code

in C++, we can teach the structure to convert itself to a 16 bit unsigned int (the operator uint16_t() below): 
I also encapsulated the address of the register. It's fixed, so your firmware should not have to deal with that.

 // CTRL Register
 struct CTRL_Register
 {
     uint16_t DTIME;		// bits 11-10
     uint16_t ISGAIN;	// bits 9-8
     uint16_t EXSTALL;	// bit 7
     uint16_t MODE;		// bits 6-3
     uint16_t RSTEP;		// bit 2
     uint16_t RDIR;		// bit 1
     uint16_t ENBL;		// bit 0
     inline operator uint16_t() const {
        return (0x0000 << 12) | (DTIME << 10) | (ISGAIN << 8) |(EXSTALL << 7) | (MODE << 3) | (RSTEP << 2) | (RDIR << 1) | (ENBL);
     }
 };

and then write the struct directly to SPI (conversion is done by the struct when being passed to this call - because we trained it how to do that).

    spi_write(reg);

Note that there is no conversion in your user code - the struct will do it. We can just pass the struct to the SPI write procedure.
All knowledge on what fields are available in the register, and how to club it into the 16 bits, is contained within the struct.

The code does not add anything to the runtime / firmware. But the register's bit structure knowledge is fully contained within the struct. Your client software doesn't need to shift bits.

Thank you for reading. Critique is welcome.

bonus pub quiz question: why did I put const in the conversion function's declaration?

Parents

  • What happens if ENBL = 2u  ?

    and

    what does the generated assembler code look like ?

    and

    why not use bit fields, although in C the assignment of an out of range value to a bit field is implementation dependent (don't know about C++).

    MK

  • in reply to michaelkellett

    > What happens if ENBL = 2u ?

    Exactly the same as with TI's code. 

    > what does the generated assembler code look like ?

    Exercise for the reader. There is an online compiler that will show the assembler. Somewhere ... Slight smile

    My expectation is that it ''ll be close to the procedural code. Because the function is inline and not virtual.

    > why not use bit fields, although in C the assignment of an out of range value to a bit field is implementation dependent 

    It's a choice that TI made with the struct for the drv8711. Bitfield will work in C and C++, at (a bit of) cost of runtime execution.

    The example is not out-of-range safe, as you spotted with comment #1. 

    What I wanted to show: you can teach a structure tricks. In this case how to represent itself as a 16 bit unsigned.

    You could also learn it to validate the fields for range and valid combinations. But that would come with code space and runtime cost.

  • in reply to Jan Cumps

    > There is an online compiler that will show the assembler.

    found it back: compiler explorer https://godbolt.org/

  • in reply to Jan Cumps 
    #include <cstdint>
    struct CTRL_Register {
        uint16_t DTIME;     // bits 11-10
        uint16_t ISGAIN;    // bits 9-8
        uint16_t EXSTALL;   // bit 7
        uint16_t MODE;      // bits 6-3
        uint16_t RSTEP;     // bit 2
        uint16_t RDIR;      // bit 1
        uint16_t ENBL;      // bit 0
        inline operator uint16_t() const {
           return (0x0000 << 12) | (DTIME << 10) | (ISGAIN << 8) |(EXSTALL << 7) | (MODE << 3) | (RSTEP << 2) | (RDIR << 1) | (ENBL);
        }
    };

    CTRL_Register reg;

    int main() {
        uint16_t data;
        // prepare CTRL Register
        data = reg;
        return (int)data;
    }

    image

  • in reply to Jan Cumps

      , comparison:

    image

    It's virtually identical. You 'll see a little change, because I didn't (have to) use the Address field in the 2nd version.

    I'll do a second compare, where I alter TI's code to also not hold the address, but directly pass it. I'm fairly sure that assembler is identical then ...

Comment Children
  • in reply to Jan Cumps

    No overhead in the C++ version:

    image

    No penalty for using an object. No penalty for the member function

  • in reply to Jan Cumps

    if you like to experiment with this, here is the  C version (TI's code):

    #include <stdint.h>
    struct CTRL_Register {
        uint16_t DTIME;     // bits 11-10
        uint16_t ISGAIN;    // bits 9-8
        uint16_t EXSTALL;   // bit 7
        uint16_t MODE;      // bits 6-3
        uint16_t RSTEP;     // bit 2
        uint16_t RDIR;      // bit 1
        uint16_t ENBL;      // bit 0
    };

    CTRL_Register reg;

    int main() {
        uint16_t data;
        data = (0x0000 << 12) | (reg.DTIME << 10) | (reg.ISGAIN << 8) |(reg.EXSTALL << 7) | (reg.MODE << 3) | (reg.RSTEP << 2) | (reg.RDIR << 1) | (reg.ENBL);
        return (int)data;
    }
    and C++
    #include <cstdint>
    struct CTRL_Register {
        uint16_t DTIME;     // bits 11-10
        uint16_t ISGAIN;    // bits 9-8
        uint16_t EXSTALL;   // bit 7
        uint16_t MODE;      // bits 6-3
        uint16_t RSTEP;     // bit 2
        uint16_t RDIR;      // bit 1
        uint16_t ENBL;      // bit 0
        inline operator uint16_t() const {
           return (0x0000 << 12) | (DTIME << 10) | (ISGAIN << 8) |(EXSTALL << 7) | (MODE << 3) | (RSTEP << 2) | (RDIR << 1) | (ENBL);
        }
    };

    CTRL_Register reg;

    int main() {
        uint16_t data;
        data = reg;
        return (int)data;
    }
  • in reply to Jan Cumps

    Thanks for all that Jan, I'm mega busy the next few days but I should get  a chance to play with it at the end of the week.

    I don't use C++ but my usual tools can compile it so I'll do some comparisons when I get  a chance.

    MK

  • in reply to michaelkellett

    In my C++ posts, I try to distinguish between generic development content, and µController scale topics.

    When I put "embedded" in the subject, I think that the technique is usable in a controller with resources comparable to the smallest ARM family. Most of them also with the tiny ATMEL range - although modern toolchain support is more limiting than the controller's resources in this case.