How to set multiple GPIO pins?

[alethiophile]

I'm currently working with a circuit that has multiple GPIO ports wired up in parallel to a peripheral. I need to set all of them at once using a single write instruction. The C driver I'm using as a reference does this using assignment to the GPIO.out_w1ts field.

What's the best way to do this in Rust? Just grabbing all the pins from the Io struct and setting them manually seems unlikely to work, since it'll presumably issue multiple writes.

[bjoernQ]

You are right - there is no such API and creating such an API in a sane (= safe) way might be challenging.

Out of curiosity: what is the use-case where you need the edges in absolute sync?

Options which come to my mind

• unsafely write to the out_w1ts register in your code
• ab-use some peripheral (depending on the number of pins you need) - e.g. half-duplex SPI, PARL_IO

[alethiophile]

Unfortunately, the component I'm working with (an E-ink display) is one I don't have a datasheet for. (Inquiries are ongoing.) So I don't actually know the requirement for how tight the edges are. However, changing the usage to use multiple writes per set seems like a potential source of bugs, and anyway it's ugly.

I'll probably just use unsafe and write to w1ts/w1tc directly. I guess in a Rust context this probably means I have to take ownership of the whole GPIO peripheral, but this is probably fine for my use case.

[Dominaezzz]

Does this E-Ink display happen to be from InkPlate (Recycled Kindle screen)?

Also which ESP32 chip are you working with?

means I have to take ownership of the whole GPIO peripheral

It should be enough to take ownership of the specific pins.

[alethiophile]

Yes, this is an Inkplate 5. The chip is an ESP32-WROVER-E (core processor being I believe an ESP32-D0WD-V3), which I believe is of the "ESP32" architecture rather than any of the more specific ones.

(The display is, according to the BOM, an ED052TC2. I'm not sure if this is a recycled Kindle display or not. However, I can't find a datasheet for it wherever I look, so I'm trying to closely follow the behavior of the working driver, which is C++/Arduino code.)

[Dominaezzz]

I figured, I did similar research some months ago trying to figure out how to drive the screens and the only option I found was just to look at the source code to see what it's doing.

I think you could probably use the I2S in LCD mode to write to the display but there isn't a driver for this in esp-hal yet.

So for now you're stuck with w1ts/w1tc like the InkPlate drivers do.

I'm interested in bringing Rust to InkPlate so let me know how it goes with the porting.

[yanshay]

I had a similar need some time ago and eventually implemented two options:

1. Use w1ts and w1tc (so one is to set and the other is to clear bits) - I think this has the con of set and clear not coming out together.
2. Fast GPIO - that's more involved but allows setting up to 8 bits at the same time (and is much faster if you need that) but more involved in setting it up the bits in advance.

I can search that code and send what I have if it will help, don't know if it still compiles today as many changes were made, but it will provide some direction.

[DavidAntliff]

In the ESP-IDF, there is a way to program the interconnect/GPIO-mux so that you can "link" multiple outputs together. For example, you can make two LEDs, on two different pins, change state simultaneously with just one pin write.

You can also connect output pins to internal peripherals directly, so that, say, an external LED changes state with the output of the PWM peripheral. This is similar, but different to the example above. But combined together, you can have an internal peripheral update multiple pins automatically.

One program I wrote uses the PWM peripheral to generate a timing signal, which is routed to the PCNT counter and an LED, allowing the program to both blink the LED and measure time without a software loop.

I've been trying to find a way to replicate this with the esp_hal's interconnect module, but I haven't had much luck. This discussion suggests that this use-case isn't supported by the API currently.

How difficult would it be to add support for these kinds of applications?

[bugadani]

I've been trying to find a way to replicate this with the esp_hal's interconnect module, but I haven't had much luck. This discussion suggests that this use-case isn't supported by the API currently.

You can probably take a look at our tests, we use this approach pretty commonly. In essence, you'd set up your LED GPIO as output, split() it, pass the output half to PWM, and the input part to PCNT (or others). The module will probably undergo changes in the future, but it should be capable to support this use case.

You can even connect a peripheral's output to multiple GPIOs, but that is a bit more involved process.