Detecting short circuits of outputs to GND or 3.3V

[sosi-deadeye]

I got the inspiration from this Issue, which was a false claim. The use of GPIO12 does not brick an ESP32. The problem was related to another GPIO used by external SPIFLASH.

Then I wanted to know if a short circuit of outputs could be detected. The answer is yes.

from machine import Pin

UART_PINS = {1, 3}
FLASH_PINS = {6, 7, 8, 11, 16, 17}
NO_MUX = {20, 24, 28, 29, 30, 31}
NO_VALUE = {2}
INTERNAL_FLASH = {6, 7, 8, 9, 10, 11}

# tested with ESP32 WROVER, which has an additional SPIRAM
# other versions may have lesser limitations

BAD_PINS = UART_PINS | FLASH_PINS | NO_MUX | NO_VALUE | INTERNAL_FLASH
GOOD_PINS = [number for number in range(0, 34) if number not in BAD_PINS]


def short_circuit(pin_number):
    pin = Pin(pin_number, mode=Pin.OUT, drive=Pin.DRIVE_0, value=0)

    short_3v3 = pin.value() != 0
    pin.value(1)
    short_gnd = pin.value() != 1

    # changing mode to input without pull_up and pull_down resistors
    # https://docs.micropython.org/en/latest/library/machine.Pin.html#constructors
    pin.init(mode=Pin.IN, pull=None)

    return short_3v3, short_gnd


for pin_number in GOOD_PINS:
    short_3v3, short_gnd = short_circuit(pin_number)

    if short_3v3:
        print(f"GPIO{pin_number} has a short circuit to 3.3V")
    elif short_gnd:
        print(f"GPIO{pin_number} has a short circuit to GND")
    else:
        print(f"GPIO{pin_number} is ok")

Example where GPIO33 is connected to 3.3V and GPIO4, GPIO18 and GPIO19 to GND.

GPIO0 is ok
GPIO4 has a short circuit to GND
GPIO5 is ok
GPIO12 is ok
GPIO13 is ok
GPIO14 is ok
GPIO15 is ok
GPIO18 has a short circuit to GND
GPIO19 has a short circuit to GND
GPIO21 is ok
GPIO22 is ok
GPIO23 is ok
GPIO25 is ok
GPIO26 is ok
GPIO27 is ok
GPIO32 is ok
GPIO33 has a short circuit to 3.3V

[robert-hh]

The constant OPEN_DRAIN is intended to be used for the mode=xx argument. For the pull=xxx argument the PULL_UP (value=2), PULL_DOWN (value=1) constants should be use. In your case OPEN_DRAIN (value 7) worked, since it has bit 1 set and PULL_UP is checked after PULL_DOWN and supersedes a previous PULL_DOWN setting.
Anyhow, with your method you check is the Pin is pulled low with a an impedance less than ~20kOhm, which may be a device connected to it, or just a load. You can was well check for a short to GND, if you set the Pin to output mode, set it to high and read back the value. If driven low with really low impedance of less than ~30 Ohm, you will read back 0, otherwise 1. Switch back to input fast to avoid an overload of the output driver..

[sosi-deadeye]

• Changed pull to None
• fixed typo

The function short_circuit checks only one GPIO for a very short duration, with 5 mA set by drive=DRIVE_0.

What happens, if too much current was drawn from many GPIOs? Does it brick or brown out?

[robert-hh]

What happens, if too much current was drawn from many GPIOs?

Hard to say. It could overheat and get permanently damaged.

[dhalbert]

Perhaps of slight interest: C code we use in CircuitPython to detect adequate pull-ups on I2C. Similar code in other ports:
https://github.com/adafruit/circuitpython/blob/ce3df829e161743c7c44decb5cb50e114297f6f0/ports/atmel-samd/common-hal/busio/I2C.c#L83-L106

[peterhinch]

Using code to detect short circuits is evil. It should be done with a multimeter before first applying power.

[rkompass]

It should be done with a multimeter before first applying power.

I also did that in the past and was wondering at the same time whether that was safe.

[peterhinch]

It's standard practice in the electronics industry. I've never heard of a multimeter on ohms range causing damage.

[robert-hh]

I tested that with my multimeters here. The highest current was in Diode test mode, with 0.3 to 1.6mA between the different multimeters.

[rkompass]

Thank you. Good to know (and relax).

[rkompass]

While your approach, @sosi-deadeye does not damage the pins because the current is limited in time to short pulses, it has the risk of perhaps damaging the pin in the rare case that something interrupts and prevents the switching back. It might be an interrupt that does not return. However in practice I found the pins to be robust even in such cases. By we don't know how new hardware behaves.

The other approach presented by @dhalbert leads to the more general alternative:
Use pin.init(mode=Pin.IN, pull=Pin.PULL_UP) instead of pin.value(1) and pin.init(mode=Pin.IN, pull=PIN.PULL_DOWN) instead of
pin.value(0), insert a short delay of some microseconds (time.sleep_us(10) perhaps again) before querying the pin.value() to overcome small capacities and with that the above code should work as intended, but in a safer way.

[peterhinch]

Designing code to be faster than the time it takes for a semiconductor to blow up is, er, brave :)

[rkompass]

I continued to work on this idea (nice inspiration @sosi-deadeye) .
Motivation: We may test in different modes:

• pull up/down with internal resistors, but test in free floating input
• pull up/down with internal resistors, and test in this mode
• drive high/low and test in this mode (as an option, now called "brave_mode" TM @peterhinch )

Preliminary program:

# Explore external connectivity of pins / of a pin.

from utime import sleep_us
from machine import disable_irq, enable_irq
from machine import Pin

# Check the pin state among
#   - free float  -->   0
#   - weak pull   --> +1/-1 to Vcc/GND   (weaker than intenal pull)
#   - strong pull --> +2/-2 to Vcc / Gnd (stronger than internal pull)
#   - force       --> +3/-3 to Vcc/Gnd   (stronger than internal drive)
#
def pin_state(pin, brave_mode=False):
    PULL_NONE = Pin.PULL_NONE if hasattr(Pin, 'PULL_NONE') else None
    
    pin.init(mode=Pin.IN, pull=Pin.PULL_UP)
    sleep_us(20)
    pin.init(mode=Pin.IN, pull=PULL_NONE)
    sleep_us(10)
    pu0 = pin()
    pin.init(mode=Pin.IN, pull=Pin.PULL_DOWN)
    sleep_us(20)
    pin.init(mode=Pin.IN, pull=PULL_NONE)
    sleep_us(10)
    pd0 = pin()
    if pu0 > pd0:
        return 0
    if pu0 < pd0:
        raise ValueError('paradoxical result, perhaps inductance at pin?')
    # now pu0 = pd0
    if pd0:                 # pu0 = pd0 = 1: we conclude at least weak pull up
        pin.init(mode=Pin.IN, pull=Pin.PULL_DOWN)
        sleep_us(10)
        pd = pin()#
        pin.init(mode=Pin.IN, pull=PULL_NONE)
        if pd0 > pd:
            return 1        # weak pull up, overcome with pull down
        if not brave_mode:
            return 2        # at least stronger pull up
        else:
            irq_state = disable_irq()
            pin.init(mode=Pin.OUT, value=0)
            pdf = pin.value()
            sleep_us(10)
            pin.init(mode=Pin.IN, pull=PULL_NONE)
            enable_irq(irq_state)
            if pd > pdf:
                return 2    # strong pull up there, but drive low is stronger
            else:
                return 3    # forced to high, not even drive sets low

    else:                   # pu0 = pd0 = 0: we conclude at least weak pull down
        pin.init(mode=Pin.IN, pull=Pin.PULL_UP)
        sleep_us(10)
        pu = pin()#
        pin.init(mode=Pin.IN, pull=PULL_NONE)
        if pu0 < pu:
            return -1       # weak pull down, overcome with pull up
        if not brave_mode:
            return -2       # at least stronger pull down
        else:
            irq_state = disable_irq()
            pin.init(mode=Pin.OUT, value=1)
            puf = pin.value()
            sleep_us(10)
            pin.init(mode=Pin.IN, pull=PULL_NONE)
            enable_irq(irq_state)
            if pu < puf:
                return -2   # strong pull down there, but drive high is stronger
            else:
                return -3   # forced to low, not even drive sets high

from sys import platform as Platform

if Platform in ('rp2'):
    pin_set = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
               13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 26, 27, 28]
elif Platform in ('w600'):
    pin_set = ['PA0','PA1','PB6','PB7','PB8','PB9','PB10','PB11',
               'PB12','PB13','PB14','PB15','PB16','PB17','PB18']
elif Platform in ('esp8266'):
    pin_set = [0, 1, 2, 3, 4, 5, 12, 13, 14, 15, 16, 17]


pin_interpr = {0: 'not conn.',
               1: 'weak pull high',  2: 'strong pull high', 3: 'forced high',
              -1:  'weak pull low', -2: 'strong pull low', -3: 'forced low'}

for p_name in pin_set:
    state = pin_state(Pin(p_name), brave_mode=True)
    print(f'{p_name}: {pin_interpr[state]}')

Findings:

1. It works flawlessly in RP2: 0: weak pull high 1: strong pull low 2: forced high 3: not conn. 4: not conn. 5: not conn.
   Connection to high/low with R=10 Ohms is reported as forced high/low,
   connection with R=4.7 Kiloohms is reported as strong pull high/low and
   connection with R=100 Kiloohms is reported as weak pull high/low, otherwise not. conn. reported.
2. On the RP2 the Pin class has no attribute PULL_NONE, instead None has to be provided as pull argument.
   Can we proceed on unifying the Pin classes in this respect
3. On the w600 all pins report strong pull up, if not connected or driven low.
   I / we have to investigate this.
4. On the ESP8266 there is no Pin.PULL_DOWN.
   This is due to a hardware limitation:

GPIO 0-15 on the esp8266 only have the hardware to allow configurable pullup. GPIO16 is different and only has the hardware to allow configurable pulldown.

So on the ESP8266 there is no easy/safe general testing for free float possible, it seems. Except taking the risk and going to "brave mode"!?!