XL9535 I2C relay board module

[vodkawasserfall]

hey, has anyone controlled an XL9535 I2C relay board before? i'm not enough of a programmer to figure it out (yet).
tried looking at https://github.com/esphome/esphome/discussions/5710 which (seems to) implement this board in ESPhome

example listing of the modlues i have; https://www.aliexpress.us/item/3256805588736472.html

do i need to do anything other than write to a register to turn on a relay? a short list of hints i need to do/research would be really much appreciated :)

[mcauser]

I haven't come across this board yet. A quick google reveals the datasheet:
https://datasheet.lcsc.com/lcsc/2205271545_XINLUDA-C3029626_C3029626.pdf
Page 12 shows the registers and commands.

Looks like the chip support 2x 8-bit ports (powering up to 8 relays each port).
That Aliexpress listing shows a 16 relay board, which would be using both ports.

Yes, a few simple I2C writes and you'll be able to control this from a MicroPython.

The chip is an I/O expander, and they would have wired it up so each bit represents a relay.
Reading and writing from the appropriate register(s) should be enough to toggle the relays.

Buy it and we'll help you craft the I2C calls.

[vodkawasserfall]

hey, i've got two if them now, 4relay version.

played around trying to get to the configuration register according to the datasheet you found, thanks.

with this i accidentally switched on 4/4 relays:

i2c.writeto_mem( 36, 6, b'x00')

this switches the relays to every possible combination of 2⁴:

from machine import SoftI2C
i2c= SoftI2C( scl= 23, sda= 22, freq= 400_000)


def ww( i,ii,iii):
    print( 'dev',i, '   addr',ii, ' written',iii, i2c.writeto_mem( i, ii, iii))
    input()


ww(36, 6, b'\x00')
ww(36, 6, b'\x01')
ww(36, 6, b'\x02')
ww(36, 6, b'\x03')
ww(36, 6, b'\x04')
ww(36, 6, b'\x05')
ww(36, 6, b'\x06')
ww(36, 6, b'\x07')
ww(36, 6, b'\x08')
ww(36, 6, b'\x09')
ww(36, 6, b'\x0a')
ww(36, 6, b'\x0b')
ww(36, 6, b'\x0c')
ww(36, 6, b'\x0d')
ww(36, 6, b'\x0e')
ww(36, 6, b'\x0f')

(some of) what i don't understand is:

• thought i needed to set the configuration to output first, how does it control relays without setting the configuration?
• the memory address i've used is an integer, '0x6' isnt in the datasheet, so what happens with writeto_mem( 36, 6, b'x00') ?
• can single bits be written to switch a relay?
  or is this how it should be done?

[mcauser]

I ordered one (4x relay model). I'll write a micropython driver for it once it arrives (around 2 weeks). 🌊 🌊 🚢 📦 🌊 🌊

[vodkawasserfall]

great 👍
really curious how your driver will look like.

i tried 😉
only works once and somehow depends on the sequence ^^

DEBUG__= 1
 
class XL9535:
    def __init__(self, i2c_, id_):
        self.i2c_= i2c_
        self.id_= id_
 
    def relay(self, relay, onoff):
        relay= relay-1    #base 1
        onoff= onoff^1    #invert
 
        oo= self.i2c_.readfrom_mem( self.id_,6,1)
        oo= "{:08b}".format( int(  oo.hex(), 16))
        oo= oo[4:]
        oo= ''.join( reversed( oo))
        oo= oo[:relay] + str( onoff) + oo[relay+1:]
        oo= ''.join( reversed( oo))
        DEBUG__ and print(oo)
 
        oo= hex( int( '0000'+ oo ,2))
        self.i2c_.writeto_mem( self.id_, 6, oo)
 
        DEBUG__ and input()
 
    def on(self, relay):
        self.relay( relay, 1)
 
    def off(self, relay):
        self.relay( relay, 0)
 
    def allOff(self):
        self.i2c_.writeto_mem( self.id_, 6, b'\x0f')
        DEBUG__ and input()
 
    def allOn(self):
        self.i2c_.writeto_mem( self.id_, 6, b'\x00')
        DEBUG__ and input()
 


from machine import SoftI2C
i2c= SoftI2C( scl= 23, sda= 22, freq= 400_000)
 
xl_= XL9535( i2c, 32)   #default 36
 
xl_.on(1)
xl_.off(1)
xl_.on(2)
xl_.off(2)
xl_.on(3)
xl_.off(3)
xl_.on(4)
xl_.off(4)
xl_.allOff()
xl_.allOn()
xl_.allOff()

[mcauser]

I was putting together something like this:

board = xl9535.XL9535_KXV5(i2c, 0x20, 4)

# get state of single relay
board.relay(1)
  False
board.relay(2)
  False

# toggle single relay
board.relay(1, True)
board.relay(2, True)

# get state of all relays
board.relays()
  3
  0b_0000_0000_0000_0011

# turn on 4 relays
board.relays(0b_0000_0000_0000_1111)
aka
board.relays(15)
aka
board.relays(0x000f)

# get state of all relays
board.relays()
  15
  0b_0000_0000_0000_1111

Another IO expander I've written a driver for: https://github.com/mcauser/micropython-mcp23017
It's way more complex and features interrupts, inversion, pull ups, properties, setters, and splitting out the ports into their own class and virtual pin classes.
For this simple relay board, doesn't need to be very complex. Hard code much of the config. ie, it doesn't make sense to make the relays IOs inputs, only outputs.
Could make a generic xl9535.py to unlock all of it's features later. Ideally when there is a breakout on aliexpress to save me designing my own board.

[mcauser]

Here you go: https://github.com/mcauser/micropython-xl9535-kxv5-relay
Supports all 5 variants: 1,2,4,8 and 16 channels.

Each relay is controlled by two registers, config and output. Config is used to enable a relay and output toggles the relay.
I called the configs "circuits" and the outputs "relays".

# switch circuit that controls relay A0 on
board.circuit(0, True)

# actually switch relay A0 on
board.relay(0, True)

I'm using base 0 indexing, to match up with the board's silkscreen labels
(Relay 0 = A0, Relay 7 = A7, Relay 8 = B0, Relay 15 = B7)

[bidrohini]

I could only find this link relevant: https://forums.raspberrypi.com/viewtopic.php?t=348333
I don't think you'll find an already-existing micropython library for I2C relay module.
By the way, if you ever want, you can make an I2C Relay module with selectable address for use with the ESP-12E I2C Base Board

[mahnunchik]

Could you please tell me if it is necessary to supply power in addition to the I2C interface power? The power indicator lights up after only the I2C interface is connected.

[scruss]

... At 5VDC each relay (when on) uses ~70mA. (You may want to double check/test this) If you need to trip 16 of them at once, that's at least 1.12 amps to hold them on.

So you'll always need external power, then? Some MCUs are only rated at 50 mA total for their power out pins

[mcauser]

Well, you're not powering the relay directly through an IO pin. The (I2C) IOs drive the XL9535 IO expander, which drives opto-isolated FETs, which drive the relays. So as long as your power source for the MCU has enough amps left over to power the relay board, should be ok.

[scruss]

Thanks!

So to the OP: Depends on the power supply of your Raspberry Pi. The +5V pin on the header can deliver the full current of your mains adaptor, less that used by the Pi itself. The 3.3 V pin is much more limited: 500 mA is given as a rule of thumb

Personally, if at all possible, I'd use an external power supply and skip the 5 V connection at the Grove I2C pin. I wouldn't want relay switching to cause my delicate Raspberry Pi filesystem to glitch out.

[pioskala]

What about connecting two or more boards in a row when using 3.3 V logic? When first board logic is connected to 3.3 V and relays to 5 V separately then second board connected with JST on the right will get 5V for I2C. Will it not fry something?

[csxdotcc]

remove J1 on every board to remove any 5V pull-up on the bus.
if 3V3 pull up is to weak, add 3V3 to VIN of another board or use an external pull up to 3V3.

[christophermp]

Has anyone found a schematic for this board?

[mcauser]

Not a schematic, but the block diagram can be found in the datasheet:
https://github.com/mcauser/micropython-xl9535-kxv5-relay/blob/master/docs/XL9535.pdf