A micropython exapmle for DS2413 chip

Main
A micropython exapmle for DS2413 chip

Connection diagram of the Simple Smart Home system extension module to the esp32 devkit board:

Micropython

Micropython provides an easy and quick start for simple tasks, as well as to explore the capabilities of IoT devices, all the main interfaces of microcontrollers, such as I2C, OneWire, GPIO, ADC, PWM, etc. We will consider examples based on the esp32 devkit ver.1 board with Micropython firmware for this microchip and devices presented on our website.

The following are the texts of the three files that must be placed on the device’s file system using the micropython IDE, e.g. Thonny .
boot.py - it is executed during the boot of micropython, in this example we are connecting to the WiFi network.
main.py - the main program that implements the logic of the device. In the example, the status of the button connected to channel A of the device and, if pressed, the relay status (channel B) switches to the opposite.
ds2413.py - library for working with the relay extension module / sensor.

boot.py
main.py
ds2413.py

import network

#to connect a local wifi network
wlan = network.WLAN(network.STA_IF)
wlan.active(True)

def do_connect ( ap, pw ):
    wlan.connect(ap, pw)

	# wait a connection max 20 secondes
    for i in range(20):
        if not wlan.isconnected():
            time.sleep(1)
        else:
            break
    return wlan.isconnected()

do_connect ("WIFI-AP-NAME", "PASSWORD")
print('network config:', wlan.ifconfig())

# activate WEBREPL protocol to connect the device over a wifi network
import webrepl
webrepl.start()

import binascii
import time
from machine import Pin

# use GPIO 04 - D4 of the dev board
line = Pin(4)
from onewire import OneWire

ow = OneWire (line)
# 1-wire reset
ow.reset()
# get all devices on the 1-wire line
devs = ow.scan()
for d in devs:
    # get a device address as a string
    res = ''.join('%02x'%i for i in d)
    print (res)

# to assign a relay/sensor module address, this is for the example.
addr = "3a08e63b000000a4"
baddr = bytearray(binascii.unhexlify(addr))

# import ds2413 library
import ds2413

# init the object of one wire module
ds = ds2413.DS2413 (ow, baddr)

# button on IOA
button = ds.IOA
button.direction = ds2413.INPUT

# relay on IOB
relay = ds.IOB

# Loop forever
while True:
    # Check for button press
    if button.value:
        # Print a message.
        print("Button pressed!")
        # Toggle the relay
        relay.value = not relay.value
        # A little debounce
        time.sleep(1)

"""
`adafruit_ds2413` based * Author(s): Carter Nelson
====================================================
Python driver for the DS2413 one wire 2 channels.
Micropython original onewire driver is used.

The original library: https://github.com/adafruit/Adafruit_CircuitPython_DS2413.git
"""

__version__ = "0.1"

from onewire import OneWire
from micropython import const

_DS2413_ACCESS_READ = 0xF5
_DS2413_ACCESS_WRITE = 0x5A
_DS2413_ACK_SUCCESS = 0xAA
_DS2413_ACK_ERROR = 0xFF

INPUT = const(0)
OUTPUT = const(1)

class DS2413Pin():
    """Class which provides interface to single DS2413 GPIO pin."""

    def __init__(self, number, host, direction=OUTPUT):
        if number not in (0, 1):
            raise ValueError("Incorrect pin number.")
        self._number = number
        self._host = host
        self._mask = 1 << (number * 2)
        self._direction = None      # create it, and then...
        self.direction = direction  # set it through setter

    @property
    def direction(self):
        """The direction of the pin, either INPUT or OUTPUT."""
        return self._direction

    @direction.setter
    def direction(self, direction):
        if direction not in (INPUT, OUTPUT):
            raise ValueError("Incorrect direction setting.")
        self._direction = OUTPUT
        self.value = False
        self._direction = direction

    @property
    def value(self):
        """The pin state if configured as INPUT. The output latch state
        if configured as OUTPUT. True is HIGH/ON, False is LOW/OFF."""
        # return Pin State if configured for INPUT
        # return Latch State if configured for OUTPUT
        # NOTE: logic is re-inverted to make it more normally
        return not self._host.pio_state & (self._mask << self._direction)

    @value.setter
    def value(self, state):
        # This only makes sense if the pin is configured for OUTPUT.
        if self._direction == INPUT:
            raise RuntimeError("Can't set value when pin is set to input.")
        # We jump through some hoops in order to only set/clear the bit
        # for the channel associated with this pin object.
        current = self._host.pio_state
        #       PIOB Output Latch       PIOA Output Latch
        new = (current >> 2 & 0x02) | (current >> 1 & 0x01)
        # To switch the output transistor on, the corresponding bit value is 0.
        # To switch the output transistor off (non-conducting) the bit must be 1.
        if state:
            # clear it (transistor = ON)
            new &= ~(1 << self._number)
        else:
            # set it (transistor = OFF)
            new |= 1 << self._number
        self._host.pio_state = new

class DS2413():
    """Class which provides interface to DS2413 GPIO breakout."""

    def __init__(self, bus, address):
        if address[0] == 0x3A:
            self._address = address
            self._device = bus
            self._buf = bytearray(3)
            self._IOA = None
            self._IOB = None
        else:
            raise RuntimeError('Incorrect family code in device address.')

    @property
    def IOA(self):
        """The pin object for channel A."""
        if self._IOA is None:
            self._IOA = DS2413Pin(0, self)
        return self._IOA

    @property
    def IOB(self):
        """The pin object for channel B."""
        if self._IOB is None:
            self._IOB = DS2413Pin(1, self)
        return self._IOB

    @property
    def pio_state(self):
        """The state of both PIO channels."""
        return self._read_status()

    @pio_state.setter
    def pio_state(self, value):
        return self._write_latches(value)

    def _read_status(self):
        self._device.reset()
        self._device.select_rom( self._address )
        self._device.writebyte(_DS2413_ACCESS_READ)
        self._buf[0] = self._device.readbyte()
        return self._buf[0]

    def _write_latches(self, value):
        # top six bits must be 1
        value |= 0xFC
        self._buf[0] = _DS2413_ACCESS_WRITE
        self._buf[1] = value
        self._buf[2] = ~value
        self._device.reset()
        self._device.select_rom( self._address )
        self._device.write(self._buf)
        self._buf[0] = self._device.readbyte()
        if not self._buf[0] == _DS2413_ACK_SUCCESS:
            raise RuntimeError('ACK failure.')

info@1vp.ru

@sasha_demidoff