def __init():
global __I2C
if __I2C is None:
from machine import Pin, I2C
__I2C = I2C(-1, Pin(physical_pin('i2c_scl')),
Pin(physical_pin('i2c_sda')))
return __I2C
def pinmap():
# Return module used PIN mapping
return {
'l298speed': physical_pin('l298speed'),
'l298dir_1': physical_pin('l298dir_1'),
'l298dir_2': physical_pin('l298dir_2')
}
def pinmap():
# Return module used PIN mapping
return {
'redgb': physical_pin('redgb'),
'rgreenb': physical_pin('rgreenb'),
'rgbue': physical_pin('rgbue')
}
def __init__(self, mode):
# Mode: FULL / HALF
if mode == 'FULL':
# FULL STEP - ~508
self.mode = [[1, 0, 1, 0],
[0, 1, 1, 0],
[0, 1, 0, 1],
[1, 0, 0, 1]]
self.delay = 10
else:
# HALF STEP - ~1016
self.mode = [[0, 0, 0, 1],
[0, 0, 1, 1],
[0, 0, 1, 0],
[0, 1, 1, 0],
[0, 1, 0, 0],
[1, 1, 0, 0],
[1, 0, 0, 0],
[1, 0, 0, 1]]
self.delay = 2
# Init stepper pins
self.pin1 = Pin(physical_pin('stppr_1'), Pin.OUT)
self.pin2 = Pin(physical_pin('stppr_2'), Pin.OUT)
self.pin3 = Pin(physical_pin('stppr_3'), Pin.OUT)
self.pin4 = Pin(physical_pin('stppr_4'), Pin.OUT)
# Initialize all value to 0 - "OFF"
self.reset()
def __init_bme280_i2c():
global BME280_OBJ
if BME280_OBJ is None:
i2c = I2C(scl=Pin(physical_pin('i2c_scl')),
sda=Pin(physical_pin('i2c_sda')),
freq=10000)
BME280_OBJ = BME280(i2c=i2c)
return BME280_OBJ
def pinmap():
# Return module used PIN mapping
return {
'switch_1': physical_pin('switch_1'),
'switch_2': physical_pin('switch_2'),
'switch_3': physical_pin('switch_3'),
'switch_4': physical_pin('switch_4')
}
def __init__(self, address=57):
self.i2c = I2C(-1,
Pin(physical_pin('i2c_scl')),
Pin(physical_pin('i2c_sda')),
freq=9600)
self.address = address
self.init()
self._started = False
def __l9110_init():
global __L9110_OBJS
if len(__L9110_OBJS) == 0:
from machine import Pin, PWM
__L9110_OBJS.append(PWM(Pin(physical_pin('l9110dir_1')), freq=1024))
__L9110_OBJS.append(PWM(Pin(physical_pin('l9110dir_2')), freq=1024))
__L9110_OBJS[0].duty(0) # Set default speed (PWM)
__L9110_OBJS[1].duty(0) # Set default speed (PWM)
return __L9110_OBJS
def init_pled():
# CALL FROM ConfigHandler
if TinyPLed is None:
if physical_pin('builtin') is not None:
# Progress led for esp8266/esp32/etc
DebugCfg.PLED_OBJ = Pin(physical_pin('builtin'), Pin.OUT)
else:
# Progress led for TinyPico
DebugCfg.PLED_OBJ = TinyPLed.init_APA102()
def __cwww_init():
if Data.CWWW_OBJS[0] is None or Data.CWWW_OBJS[1] is None:
from machine import Pin, PWM
cw = Pin(physical_pin('cwhite'))
ww = Pin(physical_pin('wwhite'))
if platform == 'esp8266':
Data.CWWW_OBJS = (PWM(cw, freq=1024), PWM(ww, freq=1024))
else:
Data.CWWW_OBJS = (PWM(cw, freq=20480), PWM(ww, freq=20480))
return Data.CWWW_OBJS
def __init_HCSR04():
global __TRIGGER_OBJ, __ECHO_OBJ
if __TRIGGER_OBJ is None or __ECHO_OBJ is None:
trigger_pin = physical_pin('hcsrtrig')
echo_pin = physical_pin('hcsrecho')
# Init trigger pin (out)
__TRIGGER_OBJ = Pin(trigger_pin, mode=Pin.OUT, pull=None)
__TRIGGER_OBJ.value(0)
# Init echo pin (in)
__ECHO_OBJ = Pin(echo_pin, mode=Pin.IN, pull=None)
return __TRIGGER_OBJ, __ECHO_OBJ
def __l298n_init():
global __L298N_OBJS
if len(__L298N_OBJS) == 0:
from machine import Pin, PWM
__L298N_OBJS.append(PWM(Pin(physical_pin('l298speed')), freq=50))
__L298N_OBJS.append(Pin(physical_pin('l298dir_1'), Pin.OUT))
__L298N_OBJS.append(Pin(physical_pin('l298dir_2'), Pin.OUT))
__L298N_OBJS[0].duty(0) # Set default speed (PWM)
__L298N_OBJS[1].value(0) # Set default direction for dc motor1
__L298N_OBJS[2].value(1) # Set default direction for dc motor1
return __L298N_OBJS
def __RGB_init():
if Data.RGB_OBJS[0] is None or Data.RGB_OBJS[1] is None or Data.RGB_OBJS[
2] is None:
from machine import Pin, PWM
red = Pin(physical_pin('redgb'))
green = Pin(physical_pin('rgreenb'))
blue = Pin(physical_pin('rgbue'))
if platform == 'esp8266':
Data.RGB_OBJS = (PWM(red, freq=1024), PWM(green, freq=1024),
PWM(blue, freq=1024))
else:
Data.RGB_OBJS = (PWM(red, freq=20480), PWM(green, freq=20480),
PWM(blue, freq=20480))
return Data.RGB_OBJS
def __init_DHT22():
global __DHT_OBJ
if __DHT_OBJ is None:
from dht import DHT22
from machine import Pin
__DHT_OBJ = DHT22(Pin(physical_pin('dhtpin')))
return __DHT_OBJ
def __init_ADC():
"""
Setup ADC
read 0(0V)-1024(1,2-3,3V)
"""
global __ADC, __ADC_PROP
if __ADC is None:
if 'esp8266' in platform:
__ADC = ADC(physical_pin('ph')) # 1V measure range
__ADC_PROP = (1023, 1.0)
else:
__ADC = ADC(Pin(physical_pin('ph')))
__ADC.atten(ADC.ATTN_11DB) # 3.6V measure range
__ADC.width(ADC.WIDTH_10BIT) # Default 10 bit ADC
__ADC_PROP = (1023, 3.6)
return __ADC
def __digital_out_init(pin):
"""
Init Digital output
"""
if not isinstance(pin, int):
pin = physical_pin(pin)
return Pin(pin, Pin.OUT)
def __digital_in_init(pin):
"""
Init Digital output
"""
if not isinstance(pin, int):
pin = physical_pin(pin)
return Pin(pin, Pin.IN, Pin.PULL_UP)
def __servo_init():
if Data.S_OBJ is None:
try:
pin = Pin(physical_pin('servo_1'))
Data.S_OBJ = PWM(pin, freq=50)
del pin
except Exception as e:
return str(e)
return Data.S_OBJ
def __init_tempt6000():
"""
Setup ADC
read 0(0V)-1024(1,2V) MAX 1V input on esp8266
read 0(0V)-1024(1,2-3,3V) input on esp32 (based on settings)
read_u16 0 - 65535 range
"""
global __ADC, __ADC_PROP
if __ADC is None:
from machine import ADC, Pin
if 'esp8266' in platform:
__ADC = ADC(physical_pin('temp6000'))
__ADC_PROP = (1023, 1.0) # Resolution on esp8266
else:
__ADC = ADC(Pin(physical_pin('temp6000')))
__ADC.atten(ADC.ATTN_11DB) # 0 - 3,6V sampling range
__ADC_PROP = (4095, 3.6) # Resolution on esp32
return __ADC
def __servo2_init():
if Data.S_OBJ2 is None:
try:
pin = Pin(physical_pin('servo_2')) # Alternative wiring
Data.S_OBJ2 = PWM(pin, freq=50)
del pin
except Exception as e:
return str(e)
return Data.S_OBJ2
def __pwm_init(pin, freq):
"""
Init PWM signal
"""
if not isinstance(pin, int):
pin = physical_pin(pin)
if platform == 'esp8266':
return PWM(pin, freq=freq)
return PWM(Pin(pin), freq=freq)
def touch(triglvl=300):
"""
triglvl - trigger level, value < triglvl decide touched
"""
from machine import TouchPad, Pin
from LogicalPins import physical_pin
t = TouchPad(Pin(physical_pin('touch_0')))
value = t.read() # Returns a smaller number when touched
return {'isTouched': True if value < triglvl else False, 'value': value}
def __get_resistance():
"""
Returns the resistance of the sensor in kOhms // -1 if not value got in pin
10.0 - 'RLOAD' The load resistance on the board
"""
global __ADC, __ADC_PROP
if __ADC is None:
if 'esp8266' in platform:
__ADC = ADC(physical_pin('co2')) # 1V measure range
__ADC_PROP = (1023, 1.0)
else:
__ADC = ADC(Pin(physical_pin('co2')))
__ADC.atten(ADC.ATTN_11DB) # 3.6V measure range
__ADC.width(ADC.WIDTH_10BIT) # Default 10 bit ADC
__ADC_PROP = (1023, 3.6)
value = __ADC.read()
if value == 0:
return -1
return (float(__ADC_PROP[0]) / value - 1.) * 10.0
def __dimmer_init():
global __DIMMER_OBJ
if __DIMMER_OBJ is None:
from machine import Pin, PWM
dimmer_pin = Pin(physical_pin('dim_1'))
if platform == 'esp8266':
__DIMMER_OBJ = PWM(dimmer_pin, freq=1024)
else:
__DIMMER_OBJ = PWM(dimmer_pin, freq=20480)
return __DIMMER_OBJ
def __buzzer_init():
global __BUZZER_OBJ
if __BUZZER_OBJ is None:
from machine import Pin, PWM
dimmer_pin = Pin(physical_pin('buzzer'))
if platform == 'esp8266':
__BUZZER_OBJ = PWM(dimmer_pin, freq=600)
else:
__BUZZER_OBJ = PWM(dimmer_pin, freq=600)
__BUZZER_OBJ.duty(512) # 50%
return __BUZZER_OBJ
def __init__(self, pin):
self.adc = None
self.adp_prop = ()
if not isinstance(pin, int):
pin = physical_pin(pin)
if 'esp8266' in platform:
self.adc = ADC(pin) # 1V measure range
self.adp_prop = (1023, 1.0)
else:
self.adc = ADC(Pin(pin))
self.adc.atten(ADC.ATTN_11DB) # 3.3V measure range
self.adp_prop = (4095, 3.6)
def __init_NEOPIXEL(n=24):
"""
Init NeoPixel module
n - number of led fragments
"""
if Data.NEOPIXEL_OBJ is None:
from neopixel import NeoPixel
from machine import Pin
neopixel_pin = Pin(
physical_pin('neop')) # Get Neopixel pin from LED PIN pool
Data.NEOPIXEL_OBJ = NeoPixel(neopixel_pin,
n) # initialize for max 8 segments
del neopixel_pin
return Data.NEOPIXEL_OBJ
def adc_page():
def __visualize(p):
max_w = 50
percent = p * 0.01
size = round(percent * max_w)
size = 1 if size < 1 else size
# Visualize percentage
oled.rect(0, 9, size, size, fill=True)
# Visualize percentages scale
steps = int(max_w / 10)
for scale in range(steps, max_w + 1, steps):
if scale < size:
oled.rect(0, 9, scale, scale, state=0)
else:
oled.rect(0, 9, scale, scale, state=1)
data = SmartADC.get_singleton(physical_pin('genadc')).get()
__visualize(p=data['percent'])
oled.text("{} %".format(data['percent']), 65, 20)
oled.text("{} V".format(data['volt']), 65, 40)
return True
def initEventIRQs():
"""
EVENT INTERRUPT CONFIGURATION - multiple
"""
irqdata = ((cfgget("irq1"), cfgget("irq1_trig"), cfgget("irq1_cbf")),
(cfgget("irq2"), cfgget("irq2_trig"), cfgget("irq2_cbf")),
(cfgget("irq3"), cfgget("irq3_trig"), cfgget("irq3_cbf")),
(cfgget("irq4"), cfgget("irq4_trig"), cfgget("irq4_cbf")))
# [*] hardcopy parameters to be able to resolve cbf-s
cbf_resolver = {}
for i, data in enumerate(irqdata):
irq, trig, cbf = data
console_write("[IRQ] EXTIRQ SETUP - EXT IRQ{}: {} TRIG: {}".format(i+1, irq, trig))
console_write("|- [IRQ] EXTIRQ CBF: {}".format(cbf))
pin = physical_pin('irq{}'.format(i+1)) # irq1, irq2, etc.
if irq and pin:
# [*] update cbf dict by pin number (available in irq callback)
cbf_resolver['Pin({})'.format(pin)] = cbf
trig = trig.strip().lower()
# Init event irq with callback function wrapper
# pin_obj = Pin(pin, Pin.IN, Pin.PULL_UP) # TODO: expose parameter
pin_obj = Pin(pin, Pin.IN, Pin.PULL_DOWN)
# [IRQ] - event type setup
if trig == 'down':
# pin_obj.irq(trigger=Pin.IRQ_FALLING, handler=lambda pin: print("[down] {}:{}".format(pin, cbf_resolver[str(pin)])))
pin_obj.irq(trigger=Pin.IRQ_FALLING,
handler=lambda pin: exec_lm_pipe_schedule(cbf_resolver[str(pin)]))
continue
if trig == 'both':
# pin_obj.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=lambda pin: print("[both] {}:{}".format(pin, cbf_resolver[str(pin)])))
pin_obj.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING,
handler=lambda pin: exec_lm_pipe_schedule(cbf_resolver[str(pin)]))
continue
# Default
# pin_obj.irq(trigger=Pin.IRQ_RISING, handler=lambda pin: print("[up] {}:{}".format(pin, cbf_resolver[str(pin)])))
pin_obj.irq(trigger=Pin.IRQ_RISING,
handler=lambda pin: exec_lm_pipe_schedule(cbf_resolver[str(pin)]))
def pinmap():
# Return module used PIN mapping
return {'hcsrtrig': physical_pin('hcsrtrig'), 'hcsrecho': physical_pin('hcsrecho')}
