Accessing raw ports in byte-wise fashion

LeafLabs Garden » Support » Maple Hardware Support

Accessing raw ports in byte-wise fashion

(9 posts) (3 voices)

Started 4 years ago by gruvin
Latest reply from gruvin

gruvin
Member

Hello

For efficiencies sake in a high speed interrupt service routine, I really need to be able to access an entire 8-bit wide port as a single byte, rather than using the likes of digitalWrite(pin, 0|1). Specifically, I want to be able to assemble bit value in a byte register and then write them all to a physical port in one go. I then also need to reset them all in a single instruction. Well, you get the idea. Pretty common stuff.

To help save me a bunch of time and learning curve with the Maple, can someone please give me an example of how to write and read to an 8-bit wide data port, directly, on the Maple Rev5?

Also -- where do I go looking for a pin map of which 'Arduino' pin numbers are connected to what ports on the Maple Rev.5's MCU?

Thanks!

Post-ample ...

I'm very familiar with how to do all this, having programmed MCU's without Wirish etc for years. I guess what I'm asking for then is some pointers on how to best get under the hood (libmaple?) to get this done in the sort of best, 'libmaple friendly' way -- if that makes sense.

Obviously, my code will not be necessarily compatible from board to board. That's OK. I'm targeting the Maple Rev5 only for this project.

Of course, I *could* just go to the SMT32 data sheets and look up the register addresses, etc. But I'm sure there's "better" ways to handle things, given what I have been able to absorb from the libmaple docs. It's all just a bit overwhelming right now.

Meanwhile, I'll keep reading. Maybe I'll I figure out before someone replies. *gulp*

Thanks again!

Posted 4 years ago #
gruvin
Member

Perhaps I should be more specific ...

Lets say I wanted my Maple Rev.5's pin numbers 0-to-7 to be set to represent the binary value 10101010 (0xAA), LSb on pin 0. What command could I execute to make that happen in a single instruction?

There. Now that was a bunch less to wade through, wasn't it! :P

Thanks again, again.

Posted 4 years ago #
gruvin
Member
Oh yeah, I forgot -- 16-bit physical ports.

So I need to figure out how to do a read/modify/write, I guess -- if I only want to affect 8 bits.

Is it as simple as something like ...
```
gpio_dev *dev = PIN_MAP[0].gpio_device;
dev->ODR = (dev->IDR & 0x00ff) | 0xAA;
```
???

I still need to know exactly what port pins actually connect to which Maple pins, of course. Still having some trouble finding that.
Posted 4 years ago #
gruvin
Member

Oh, there's constants pre-defined gpio_dev pointers for each port, GPIOA, GPIOB, etc.

See, I told you I needed help getting used to libmaple. :P

Posted 4 years ago #
cbrunschen
Member

Generally, you can set all the pins that correspond to a single _port_ – 'A', 'B', etc – in one go by writing to the corresponding register. The mapping from port bits to pins is in the documentation, for the Maple it's at

http://leaflabs.com/docs/hardware/maple.html#gpio-port-pin-map

General GPIO docs are at

http://leaflabs.com/docs/gpio.html

including links to the STM32 docs at the bottom of that page.

Basically, you identify the port (A, B, C, or similar) that you want to write. For each port, there is a corresponding output register, GPIOx_ODR - for port A, this would be GPIOA_ODR. To set all of the bits to the values you want in one go, simply write the value you want to that register.

There are also ways to just set and/or reset _some_ bits of a port in an atomic fashion, but without changing other bits about whose values you don't at the moment care.

For more detailed information, look at the manual at

http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf

and in particular section 9, GPIO.

Best wishes,

// Christian Brunschen

Posted 4 years ago #
gruvin
Member

Ah... OK. I've found ~/wirish/boards/maple.cpp

It seems the digital pin are not actually distributed in the way I wanted, for the most part. Pins are quite 'randomly' scattered about the place, without on single strip of contiguous 8-bits to be found. The closest I can find would be PB10-PB15, on the external header. But they're not in a nice neat row like I'd hoped for.

Oh well, that's the end of that then. *sigh*

Thanks for reading. :D

Posted 4 years ago #
cbrunschen
Member

Keep in mind that even on the chip itself, pins from the same port are generally not placed contiguously. On the other hand, as long as all of the pins of a port are available, you can always route the signals together to where you want them.

Note that not all ports have all their bits available on pins / headers; but you should be able to find several combinations of 8 bits within a port that are all available, even if not pin-contiguously.

Best wishes,

// Christian Brunschen

Posted 4 years ago #
gbulmer
Moderator
gruvin - as cbrunschen has written, the pins are not necessarily in a tidy 'row', but this need not have much impact on you.

By writing to the Port bit set/reset register, or Port bit reset register (GPIOx_BRR) you can atomically update any subset of 16 pins in a port with a single instruction.

See manual the ST Micro manual RM0008 sections 9.2.5 "Port bit set/reset register (GPIOx_BSRR)", and 9.2.6 "Port bit reset register (GPIOx_BRR)" referenced at http://leaflabs.com/docs/gpio.html#recommended-reading

The BSRR register is a sneaky idea, A 16-bit port is mapped to both 16-bit halves of the register.
Bits that are 0 do not effect any pins.
Bits set in the top 16 bits of the register clear the corresponding port pin to 0, or low.
Bits set in the bottom 16 bits of the register set the corresponding port pin to 1 or high.

It is quite nice to use, e.g. `(GPIOB_BASE)->BSRR = BIT(3) | BIT(4) | BIT(6) | BIT(9) | BIT(14)
| ((BIT(5) | BIT(8) | BIT(15)) << 16;`

If speed were very critical, I might use a table to map from a value to the inconvenient layout of port pins, e.g.
```
uint32 pinmapB[256] __FLASH__ = {
(BIT(3) | BIT(4) | (BIT(5) | BIT(6) | BIT(8) | BIT(9) | BIT(14) |  BIT(15) << 16),
(BIT(3) | BIT(4) | (BIT(5) | BIT(6) | BIT(8) | BIT(9) | BIT(14)  << 16) |  BIT(15),
// ... etc.
};
...
(GPIOB_BASE)->BSRR = pinmapB[val];
```
But otherwise, maybe write a macro or an inline function to construct it on the fly.

I often write a little program to generate all the values for a table, with the appropriate C syntax and layout, redirect the text into a file, and #include the file directly into my program:
```
uint32 pinmapB[256] __FLASH__ = {
#include "pinmapB_data.h"
};
```
Posted 4 years ago #
gruvin
Member

Thanks for the replies @cbrunschen and @gbulmer -- even though it's two years later now! Apparently, I didn't see these helpful replies, way back then. I was just Googling, as a refresher on GPIO register names and stumbled on this old post. Took a while before I realised it was mine. LOL

Of course, I've now actually read up all the data sheets and all is clear. I've also learnt a lot about 32-bit ARM and MIPS MCU architecture in general, since then. So everything really does make a lot more sense now!

I guess the biggest problem/shock for me back then, having come the 8-bit MCU world, was in realising just how much more configurable and flexible the STM32F10x GPIO ports are! I was thinking in way too small a bubble and well, had a bad attitude about how, "unnecessarily difficult" it all seemed. It's way better! That's why! (And not hard at all, actually.)

Well, thanks again.

Posted 1 year ago #

RSS feed for this topic

Reply

You must log in to post.