Looking for help modifing registers for GPIO (IDFGH-14010)

[ulao]

Answers checklist.

• I have read the documentation ESP-IDF Programming Guide and the issue is not addressed there.
• I have updated my IDF branch (master or release) to the latest version and checked that the issue is present there.
• I have searched the issue tracker for a similar issue and not found a similar issue.

General issue report

I had to use the register to change my pin state because of my timing requirement. I have most of it working but I can not get the input to release the state of the pin.

my goal is something like

set to output so I can hold pins high or low
set to input so I can read the start of an external pin.

I got the output working and my input is not, these are my defines.

#define PINPULLUP(p) asm volatile ("ee.setbitgpioout %0" : : "I"(p) : );
#define PIN_PULLDOWN(p) __asm __volatile ("ee.clr_bit_gpio_out %0" : : "I"(p) : );

#define PIN_MODE_OUTPUT(p) do { GPIO.enable_w1ts = (uint32_t)(1 << p); WRITE_PERI_REG((REG_IO_MUX_BASE + ( (p+1) * 4) ), (READ_PERI_REG(REG_IO_MUX_BASE + ( (p+1) * 4))|(1<<9))); } while (0);

#define PIN_MODE_INPUT(p) do { GPIO.enable_w1tc = (uint32_t)(1 << p); WRITE_PERI_REG((REG_IO_MUX_BASE + ( (p+1) * 4) ), (READ_PERI_REG(REG_IO_MUX_BASE + ( (p+1) * 4)) & ~(1<<9))); } while (0);

to write a pin state I do this
PIN_MODE_OUTPUT(1<<1);
then I can use either PIN_PULLDOWN or PIN_PULLUP
This works

to read I do
PIN_MODE_INPUT(1<<1);
but my wires stay low. and my external resister can not pull up. did I miss something?

[ulao]

Does the gpio_output_disable need to be set? I'm not sure if that prevents me from checking pin status or not?

I need to do a
input mode, so that I can read the pin states
output mode so that I can set the pin states.
I have an external resister.

setting gpio_output_disable on the pins seems to allow the external resister to and device to pull on the pins but I can not check the status now.

[songruo]

Please check our Technical Reference Manual, IO MUX and GPIO Matrix (GPIO, IO MUX) chapter should have the steps stated clearly.

Take ESP32S3 TRM as an example:

[ulao]

Hi could you post a link to the manual I'm confused where that is.

but just for understanding the "n" I figured was an indication I replace that with a number. but in searching it seems the register name has the letter n in it. i.e GPIO_FUNCn_OUT_SEL_CFG_REG. Also the (x) is confusing still, is index (0x100) what I need for the GPIO? In other words if I want to set pin 1 I do

GPIO_FUNCn_OUT_SEL_CFG_REG(0x100) ;
WRITE_PERI_REG( GPIO_OUT_REG[0], REG_READ(GPIO_OUT_REG[0] |= 0x02) );

Also, I still need to use my GPIO Bundle right?

[songruo]

S2 TRM link: https://www.espressif.com/sites/default/files/documentation/esp32-s2_technical_reference_manual_en.pdf

ESP-IDF Programming Guide is mainly for those uses our peripheral driver APIs. Since you want to work with registers directly, I would say TRM is your reference.

The 'n' and 'x' both correspond to the gpio number. You should first configure the pin as a simple input, and then also configure it as a simple output, following the guide stated in the TRM.

BTW, you sure you don't want to try our upper GPIO driver APIs, but play around with the registers? :)

[ulao]

"BTW, you sure you don't want to try our upper GPIO driver APIs, but play around with the registers? :)"
-- my only requirement is speed. I work with many device that require a transition in ttl around 50ns. If you think the API is fast enough and easier to work with I can try.

so if I got this right and want to out GPIO1 as high I do this

GPIO_FUNC1_OUT_SEL_CFG_REG ( 256 ) //n in this case is 1, use 256 for peripheral
WRITE_PERI_REG( GPIO_OUT_REG[0], REG_READ(GPIO_OUT_REG[0] |= 0x01) );//flip first bit
WRITE_PERI_REG( GPIO_ENABLE_REG[0], REG_READ(GPIO_ENABLE_REG[0] |= 0x01) );;//flip first bit

[ulao]

so I as playing around with a few registers and I found the issue I had was my GPIO bundles. Apparently once you set those up, you can not use the ports as input. Also the register modification are not as precise as the bundle code, nor is it as fast. I'm wondering if I can set up input bundles?

This is how I set them up

dedic_gpio_bundle_handle_t createBundle( const int arr[], int size, bool makeBundle)
{
gpio_config_t io_conf;

for (int i = 0; i <size; i++) 
{
    io_conf.intr_type = GPIO_INTR_DISABLE;
    io_conf.mode = GPIO_MODE_INPUT_OUTPUT;
    io_conf.pin_bit_mask = (1ULL<<i);
    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
    gpio_config(&io_conf);
}


// Create bundleA,
dedic_gpio_bundle_handle_t bundleA = NULL;
dedic_gpio_bundle_config_t bundleA_config =
{
    .gpio_array = arr,
    .array_size = size,
    .flags = {
    .out_en = 1,
    .in_en = 1,
    },
};
if (makeBundle)  dedic_gpio_new_bundle(&bundleA_config, &bundleA);
 return bundleA;

}

I thought that was both input and output? Or maybe I need to know how to change direction?

I use this to set my output pin states
asm volatile ("ee.set_bit_gpio_out %0" : : "I"(p) : );

I think this will read states
asm volatile ( "ee.get_gpio_in %[r]" : [r] "=r" (r));

but how to change from output to input? You'd think GPIO.pin[p].pad_driver =0; was enough but that does not work in bundle mode.

[songruo]

If you want to use Dedicated GPIO module, then it is a different story than using GPIO module to read/write the IOs. For configuring an IO to be used as a dedicated GPIO, you don't need to call gpio_config. Your call to dedic_gpio_new_bundle looks correct, it should be able to make IO1 both readable and writeable. Try reading the states with dedic_gpio_bundle_read_in first, see if you can get desired result.

[ulao]

for a test, I changed everything to open drain
io_conf.mode = GPIO_MODE_INPUT_OUTPUT_OD;
and everything works, expect in OD mode my transition for high to low is a max of 696 nS

But in normal GPIO_MODE_INPUT_OUTPUT my transition are much much faster, however I can not find a way to get my input wire conditions? If I do a read, it just shows what I see on the wires. So its working but I need to tell the GPIO to stop pulling high or low on the wires so my device can operate. Externally I use a 1k so that should be strong enough. but in this mode my device is not able to send data over the wire.

to read I can use
asm volatile ( "ee.get_gpio_in %[r]" : [r] "=r" (r));

but I still need a way to disable the external pulling, or at least stop what seems to be preventing my device from using the lines.

dedic_gpio_bundle_read_inworks too
W (357) start: ====8 when red is up
W (367) start: ====0 when red is down

[wanckl]

@ulao Hi, I think just adjust your external resister to 100~300 ohm and have a try!

1k will work like 3v3/1k=3.3mA which still weak compare to GPIO.

To allow more than one node output on one wire correctly, operate as wire and, you need config pin as OC not Push_Pull,
just like IIS bus, with 4.7k pull up work with OC, can speed up to 400K

You set GPIO_MODE_INPUT_OUTPUT will config pin as Push_Pull, which let your device can't output.

[ulao]

Hi thx, my external pullups are fixed ( they are part of another device ) I can not change them or change the values.

but in my tests bitbaning the pins from the registers works just fine in GPIO_MODE_INPUT_OUTPUT mode.

I guess I'm consed on the modes, is GPIO_MODE_INPUT_OUTPUT not what I want?

Setting to GPIO_MODE_INPUT_OUTPUT I can output but I was not able to read pins, that only seems to work in GPIO_MODE_INPUT_OUTPUT_OD mode?

[wanckl]

@ulao I'm confiused,

what you mean just fine in GPIO_MODE_INPUT_OUTPUT mode, in this mode you can NOT read.

I mean decrase your external resister, so even if now you have a fixed internal pullup in other device, you can also parallio another resister do pullup, and change gpio mode to OD

[ulao]

Sorry for any confusion will try to itemize here.

1. I can not decrease the external resister because my other devise will not work properly. But this works for avr and its a 30k pull up. so it should work in this case too.

2. " in this mode you can NOT read." -- in GPIO_MODE_INPUT_OUTPUT I do not know how to change to input or OD ( without completely rebuilding the bundle). This is my main issue. For AVR its simple and I know its an 8 bit mcu but life is so much simpler there..

output
DDRD |= 0x01;

to set pins
PORTD |= 0x01; //high
PORTD |= 0x01; //low

input
DDRD &= ~0x01;
PORTD |= 0x01; //pull up. 30k

I just change from output to input and I can bitbang. But with the ESP, things are a bit more complicated. I get that the bundle code is needed to group my pairs for faster reaction, that is very understandable. I also understand GPIO_MODE_INPUT_OUTPUT is the best mode for output. But what is still unclear, is how to change the directional modes? It woudl seem by default that the mode is output and I can use the following to change the pin states.

#define PIN_PULLUP(p) asm volatile ("ee.set_bit_gpio_out %0" : : "I"(p) : );
#define PIN_PULLDOWN(p) asm volatile ("ee.clr_bit_gpio_out %0" : : "I"(p) : );

I have tested this and it works great. but I'm not sure how to change from output to input. I need to swtich relatively fast. So I can not delete my bundle and remake it. I tried modifying the REG_IO_MUX_BASE and READ_PERI_REG registers but that didnt work. I'm just very confused how the registers work in the ESP for GPIO. There must be a simple way to change the pin to inputs and use no pullups. I was able to do this on a stm32 platform once before but documentation was a bit more available. If that does not exist is there a way to change to OD mode without rebuilding the bundle?