LeafLabs Garden » Topic: Maple equivalent for Arduino PORT registers

LeafLabs Garden » Topic: Maple equivalent for Arduino PORT registers http://forums.leaflabs.com/topic.php?id=1206 A place to share, learn, and grow... en-US Fri, 22 Jan 2016 00:15:16 +0000 http://bbpress.org/?v=1.0.2 <![CDATA[Search]]> q http://forums.leaflabs.com/search.php tlgosser on "Maple equivalent for Arduino PORT registers" http://forums.leaflabs.com/topic.php?id=1206#post-11387 Tue, 26 Jun 2012 16:40:58 +0000 tlgosser 11387@http://forums.leaflabs.com/ /*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) } gbulmer on "Maple equivalent for Arduino PORT registers" http://forums.leaflabs.com/topic.php?id=1206#post-7397 Mon, 19 Dec 2011 13:17:13 +0000 gbulmer 7397@http://forums.leaflabs.com/ poslathian - <blockquote>... I am generally weary of using sizeof because struct packing makes some objects different sizes than youd expect. ... </blockquote> Would you give a concrete example? I believe <code>sizeof(struct anything)</code> (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 <pre><code>struct foo {unit16 v16, uint32 v32; uint8 v8; }; struct foo a[8] = { ... };</code></pre> 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? poslathian on "Maple equivalent for Arduino PORT registers" http://forums.leaflabs.com/topic.php?id=1206#post-7365 Fri, 16 Dec 2011 17:20:58 +0000 poslathian 7365@http://forums.leaflabs.com/ 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. gbulmer on "Maple equivalent for Arduino PORT registers" http://forums.leaflabs.com/topic.php?id=1206#post-7329 Mon, 12 Dec 2011 22:23:26 +0000 gbulmer 7329@http://forums.leaflabs.com/ poslathian - I'd suggest this might be tidier, more robust (and might work:-): <pre><code>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))); }</code></pre> (Warning: I haven't tested his code) poslathian on "Maple equivalent for Arduino PORT registers" http://forums.leaflabs.com/topic.php?id=1206#post-7318 Mon, 12 Dec 2011 18:51:18 +0000 poslathian 7318@http://forums.leaflabs.com/ you might also use the libmaple gpio module (see <a href="https://github.com/leaflabs/libmaple/blob/master/libmaple/gpio.h)" rel="nofollow">https://github.com/leaflabs/libmaple/blob/master/libmaple/gpio.h)</a> 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! gbulmer on "Maple equivalent for Arduino PORT registers" http://forums.leaflabs.com/topic.php?id=1206#post-7295 Fri, 09 Dec 2011 12:38:24 +0000 gbulmer 7295@http://forums.leaflabs.com/ mcstellar - there are a few useful threads in the forum as well as the one you found: <a href="http://forums.leaflabs.com/topic.php?id=1184#post-7237" rel="nofollow">http://forums.leaflabs.com/topic.php?id=1184#post-7237</a> <a href="http://forums.leaflabs.com/topic.php?id=1071" rel="nofollow">http://forums.leaflabs.com/topic.php?id=1071</a> <a href="http://forums.leaflabs.com/topic.php?id=1133" rel="nofollow">http://forums.leaflabs.com/topic.php?id=1133</a> <a href="http://forums.leaflabs.com/topic.php?id=226" rel="nofollow">http://forums.leaflabs.com/topic.php?id=226</a> 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: <a href="http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf" rel="nofollow">http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf</a> 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 <code>GPIOB_BASE->ODR = 0b0011000100001110;</code> 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 <code>GPIOB_BASE->BRR = 0b0100010000001111;</code> 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 <code>GPIOC_BASE->BSRR = (zerobits << 16) | (onebits);</code> 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: <code>GPIOC_BASE->BSRR = (0b0000111111110000 << 16) | (onebits);</code> (The compiler should do something smart with <code>(0b0000111111110000 << 16)</code>, so it shouldn't cost anything, and reminds me that the top 16 bits are being manipulated more clearly than using the equivalent <code>0b00001111111100000000000000000000</code>.) 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: <pre><code>inline void setMyPortBits(uint16 onebits) { GPIOC_BASE->BSRR = (0b0000111111110000 << 16) | (onebits << 4); }</code></pre> (WARNING: I have not compiled or tested any of the code) (Full disclosure: I am not a member of LeafLabs staff) mikep on "Maple equivalent for Arduino PORT registers" http://forums.leaflabs.com/topic.php?id=1206#post-7286 Thu, 08 Dec 2011 13:19:06 +0000 mikep 7286@http://forums.leaflabs.com/ It seems setting the appropriate BSRR register would be suitable for what you are trying to do. I think the post you mentioned (<a href="http://forums.leaflabs.com/topic.php?id=737#post-4338" rel="nofollow">http://forums.leaflabs.com/topic.php?id=737#post-4338</a>) is the right way to do this if all of the pins are on the same port. mcstellar on "Maple equivalent for Arduino PORT registers" http://forums.leaflabs.com/topic.php?id=1206#post-7284 Thu, 08 Dec 2011 00:27:58 +0000 mcstellar 7284@http://forums.leaflabs.com/ I've read this post from 7 months ago in the forum regarding PORT registers on the Maple: <a href="http://forums.leaflabs.com/topic.php?id=737#post-4337" rel="nofollow">http://forums.leaflabs.com/topic.php?id=737#post-4337</a> 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!