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')}