Maple equivalent for Arduino PORT registers

LeafLabs Garden » Support » Maple Hardware Support

Maple equivalent for Arduino PORT registers

(8 posts) (5 voices)

Started 4 years ago by mcstellar
Latest reply from tlgosser

mcstellar
Member

I've read this post from 7 months ago in the forum regarding PORT registers on the Maple:

http://forums.leaflabs.com/topic.php?id=737#post-4337

I am trying to set multiple pins at the same time. For example, I use the Arduino code to set all the PORTD pins to 0 simultaneously:

PORTD = B00000000;

Is the method described in the above forum post still the recommended method of doing this or is there a better way these days? I'll be doing this to 30+ pins on the board, so it would seem using digitalWrite() on a pin by pin basis would have a lot of overhead.

Thanks!

Posted 4 years ago #
mikep
Member

It seems setting the appropriate BSRR register would be suitable for what you are trying to do. I think the post you mentioned (http://forums.leaflabs.com/topic.php?id=737#post-4338) is the right way to do this if all of the pins are on the same port.

Posted 4 years ago #
gbulmer
Moderator
mcstellar - there are a few useful threads in the forum as well as the one you found:

http://forums.leaflabs.com/topic.php?id=1184#post-7237
http://forums.leaflabs.com/topic.php?id=1071
http://forums.leaflabs.com/topic.php?id=1133
http://forums.leaflabs.com/topic.php?id=226

There are several different approaches to using the General Purpose Input/Output (GPIO) pins.
digitalRead() and digitalWrite() are the simplest to use because the pin numbers printed on the Maple are the same numbers to use when calling those functions.

An STM32F GPIO port has more functionality than an Arduino (ATmega) GPIO Port.
The ports are defined in "loving detail" in the ST Micro manual RM0008:
http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf
In section 9.1 "GPIO functional description"

Every STM32F GPIO port is 16 pins wide, though in some STM32F packages, not all of the pins are actually available on the external connections to the package.

If you are intent on speed, then there two fundamental approaches.

When a single GPIO pin is to be manipulated, then use 'Bit Banding' addresses. The principle is some of the hardware performs a 'trick' to give every pin a unique address so that it can be read or changed without effecting neighbouring pins in the same port. This has no speed cost, it all happens invisibly.

When using multiple pins (which you seem to be describing), the fastest technique uses the ports registers.

Each port has a set of associated registers which are at specific memory addresses. The RM0008 manual uses a unique name for every port register, but LeafLabs have chosen to define a C struct to map onto a ports registers (already done in maple header files).
Each port has a predefined base memory address name, e.g. GPIOA_BASE, GPIOB_BASE, GPIOC_BASE, etc.
Then the registers' struct names are offsets within a port, e.g. GPIOB_BASE->ODR, GPIOB_BASE->BSRR, GPIOB_BASE->BRR, etc.
(To help read RM0008, these would be called GPIOB_ODR, GPIOB_BSRR, GPIOB_BRR, but are exactly the same addresses.)

If all of the pins you want to use for output are on the same port, and no other pins on the same port are used, then
GPIOB_BASE->ODR = 0b0011000100001110;
would do. BUT this effects every GPIO pin in the port, all 16 will be given a value, and so might not be what you need.

If all you need to do is clear a subset of the pins in the port to 0, then
GPIOB_BASE->BRR = 0b0100010000001111;
will only effect the pins with 1 in that bit position, by setting the pin to 0, and none of the other pins will be effected.

Then as mikep has written, the BSRR register supports setting and clearing (ARM say reset) a subset of the pins atomically (in one instruction) in a port, without effecting other pins.
Let us assume the pins used are the central 8 in Port C, so the mask would be 0b0000111111110000.
The BSRR register has 32 active bits; bits set in the bottom 16 places set a subset of pins to 1, and bits set in the upper 16 bits clear (reset) the pins to 0. So you'll see expressions like
GPIOC_BASE->BSRR = (zerobits << 16) | (onebits);
There is an extra rule to using BSRR. If the corresponding pin position is 1 in the top and bottom 16 bits, the pin is set to 1.
So BSRR could always be set (in this example) using:
GPIOC_BASE->BSRR = (0b0000111111110000 << 16) | (onebits);
(The compiler should do something smart with (0b0000111111110000 << 16), so it shouldn't cost anything, and reminds me that the top 16 bits are being manipulated more clearly than using the equivalent 0b00001111111100000000000000000000.)

I'd likely want to wrap the specific expressions needed in macros or functions.
If the bits were a nice simple pattern, it might be as easy as:
```
inline void setMyPortBits(uint16 onebits) {
    GPIOC_BASE->BSRR = (0b0000111111110000 << 16) | (onebits << 4);
}
```
(WARNING: I have not compiled or tested any of the code)
(Full disclosure: I am not a member of LeafLabs staff)
Posted 4 years ago #
poslathian
LeafLabs

you might also use the libmaple gpio module (see https://github.com/leaflabs/libmaple/blob/master/libmaple/gpio.h) although even that activates only one pin at a time. Unless you have a strong need to configure gpio pin modes in a single write, then it might be easier to just write a quick function, perhaps like:

`
void init_pins(uint8* pins, uint8 num_pins) {
int i;
for (i=0;i<num_pins,i++) { pinMode(pins[i],OUTPUT);}
}

void setup() {
uint8 my_pins[4] = {12,15,16,20};
init_pins(my_pins, 4);
}

EDIT: the init_pins call was wrong, now fixed. Thanks gbulmer!

Posted 4 years ago #

poslathian - I'd suggest this might be tidier, more robust (and might work:-):

void init_output_pins(uint8 pins[], int num_pins) {
    for (int i=0; i<num_pins; i++) { pinMode(pins[i], OUTPUT); }
}

void setup() {
    uint8 my_pins[] = {12,15,16,20};
    init_output_pins(my_pins, sizeof(my_pins)/sizeof(typeof(my_pins)));
}

(Warning: I haven't tested his code)

Posted 4 years ago #

poslathian
LeafLabs

oops, yea the code I had written was wrong. Fixed now.

Using sizeof is a good idea. I am generally weary of using sizeof because struct packing makes some objects different sizes than youd expect. But here its fine.

Posted 4 years ago #
gbulmer
Moderator
poslathian -

... I am generally weary of using sizeof because struct packing makes some objects different sizes than youd expect. ...

Would you give a concrete example?

I believe sizeof(struct anything) (or sizeof(any arbitrary object)) will always give correct results, though that value might not be the same as adding up the size of individual fields, e.g. sizeof(field 1)+...+sizeof(fieldN), depending on memory layout, e.g. struct packing.

Are you thinking of that example vs
```
struct foo {unit16 v16, uint32 v32; uint8 v8; };
struct foo a[8] = { ... };
```
where the size of the fields of struct foo might appear to be 7 bytes, but some versions of ARM CPU would require that struct to be 12 bytes because they only implemented access to 4-byte aligned values?
Posted 4 years ago #
tlgosser
Member

/*If anyone is still interested you could tailor the code in this table to engage multiple pins per port at once. I wrote it just to help me keep things straight.

Blink - substitution for digitalWrite using BSRR and array table.
Works for all io pins on the Leaf Maple. Approx 3x faster than digitalWrite.
You must manually specify GPIOA,GPIOB,or GPIOC (listed as 0,1,or 2 in last column for convenience).
*/

#include <gpio.h>

const int digtalWriteFast[44][3] = {
{0b00000000000010000000000000000000,0b0000000000001000,0},
{0b00000000000001000000000000000000,0b0000000000000100,0},
{0b00000000000000010000000000000000,0b0000000000000001,0},
{0b00000000000000100000000000000000,0b0000000000000010,0},
{0b00000000001000000000000000000000,0b0000000000100000,1},
{0b00000000010000000000000000000000,0b0000000001000000,1},
{0b00000001000000000000000000000000,0b0000000100000000,0},
{0b00000010000000000000000000000000,0b0000001000000000,0},
{0b00000100000000000000000000000000,0b0000010000000000,0},
{0b00000000100000000000000000000000,0b0000000010000000,1},
{0b00000000000100000000000000000000,0b0000000000010000,0},
{0b00000000100000000000000000000000,0b0000000010000000,0},
{0b00000000010000000000000000000000,0b0000000001000000,0},
{0b00000000001000000000000000000000,0b0000000000100000,0},
{0b00000001000000000000000000000000,0b0000000100000000,1},
{0b00000000000000010000000000000000,0b0000000000000001,2},

{0b00000000000000100000000000000000,0b0000000000000010,2},
{0b00000000000001000000000000000000,0b0000000000000100,2},
{0b00000000000010000000000000000000,0b0000000000001000,2},
{0b00000000000100000000000000000000,0b0000000000010000,2},
{0b00000000001000000000000000000000,0b0000000000100000,2},
{0b00100000000000000000000000000000,0b0010000000000000,2},
{0b01000000000000000000000000000000,0b0100000000000000,2},
{0b10000000000000000000000000000000,0b1000000000000000,2},
{-1,-1,-1},
{-1,-1,-1},
{0b00000100000000000000000000000000,0b0000010000000000,2},
{0b00000000000000010000000000000000,0b0000000000000001,1},
{0b00000000000000100000000000000000,0b0000000000000010,1},
{0b00000100000000000000000000000000,0b0000010000000000,1},
{0b00001000000000000000000000000000,0b0000100000000000,1},
{0b00010000000000000000000000000000,0b0001000000000000,1},

{0b00100000000000000000000000000000,0b0010000000000000,1},
{0b01000000000000000000000000000000,0b0100000000000000,1},
{0b10000000000000000000000000000000,0b1000000000000000,1},
{0b00000000010000000000000000000000,0b0000000001000000,2},
{0b00000000100000000000000000000000,0b0000000010000000,2},
{0b00000001000000000000000000000000,0b0000000100000000,2},
{0b00000010000000000000000000000000,0b0000001000000000,2},
{-1,-1,-1},
{0b01000000000000000000000000000000,0b0100000000000000,0},
{0b10000000000000000000000000000000,0b1000000000000000,0},
{0b00000000000010000000000000000000,0b0000000000001000,1},
{0b00000000000100000000000000000000,0b0000000000010000,1}
};

void setup() {
// Set up the built-in LED pin as an output:
pinMode(13, OUTPUT);
}

void loop() {
(GPIOA_BASE)->BSRR = digtalWriteFast[13][1]; // sets pin 13, and ignores the other bits in the port
delay(1000); // Wait for 1 second (1000 milliseconds)
(GPIOA_BASE)->BSRR = digtalWriteFast[13][0]; // clears pin 13, and ignores the other bits in the port
delay(1000); // Wait for 1 second (1000 milliseconds)
}

Posted 3 years ago #

RSS feed for this topic

Reply

You must log in to post.