def __init__(self):
self.i2c = I2C(scl=Pin(5), sda=Pin(4), freq=400000) #i2c settings
self.display = sh1106.SH1106_I2C(
128, 64, self.i2c, Pin(16),
0x3c) #Load the driver and set it to "display"
self.bme = BME280(i2c=self.i2c) #sensor function
self.pump = PWM(Pin(14), freq=0,
duty=0) #create PWM objekt and configure pump forward
#self.pump_reverse = PWM(Pin(12), freq=0, duty=0) #create PWM objekt and configure pump backwards
#self.button = Pin(0, Pin.IN, Pin.PULL_UP) #initialize button
self.adc = ADS1115(
self.i2c, self.addr, self.gain
) #create analog-digtial converter object to read analog humidity sensor
self.time_start = ticks_ms() / 1000 #Sekunden
self.autosetinterval = ticks_ms() / 1000 + 25200 #counter
self.time_current = 0
self.time_start = 0
self.reset = 0
self.epoche = 0
self.water_storage = 1.2
#self.water_use = 0
#self.water_status = True
self.button = Pin(0, Pin.IN, Pin.PULL_UP)
#self.button.irq(trigger=Pin.IRQ_FALLING, handler=self.handle_interrupt)
self.soil_dry = 20000 #CSensor >20000 /Annahme Test offen
self.soil_ok = 15000 #CSensor 15000 bis 10000 /Annahme Test offen
self.soil_humid = 10000 #CSensor 250 - bis 10000 /Annahme Test offen
self.soil_humidity = None
self.activateAndClearDisplay()
def __init__(self):
self.i2c = I2C(scl=Pin(16), sda=Pin(17), freq=400000)
self.display = sh1106.SH1106_I2C(128, 64, self.i2c, Pin(16), 0x3c)
self.display.sleep(False)
self.display.rotate(True, update=True)
self.refresh()
self.y_values = [1, 11, 21, 31, 41, 51]
self.menu_options = list()
def __init__(self, freq=400000):
# ValueError: Pins 16&17 cannot be used if SPIRAM is used
RST = machine.Pin(0)
SDA = machine.Pin(settings.SDA)
SCL = machine.Pin(settings.SCL)
self.i2c = machine.I2C(scl=SCL, sda=SDA, freq=freq)
if 60 in set(self.i2c.scan()):
self.display = sh1106.SH1106_I2C(settings.oledtype[0], settings.oledtype[1], self.i2c, RST, 0x3c)
self.display.sleep(False)
self.display.fill(0)
self.display.rotate(True)
def testOled():
from machine import I2C, Pin
import sh1106
i2c = I2C(scl=Pin(SCL), sda=Pin(SDA), freq=400000)
display = sh1106.SH1106_I2C(128, 64, i2c, Pin(16), 0x3c)
display.fill(0)
display.text('Hello', 0, 0)
display.text('World', 0, 10)
display.rotate(True)
display.show()
def __init__(self):
wemos_d1_pins = {
'D0': 16, # GPIO
'D1': 5, # GPIO, I2C SCL
'D2': 4, # GPIO, I2C SDA
'D3': 0, # GPIO
'D4': 2, # GPIO
'D5': 14, # GPIO, SPI SCK (Serial Clock)
'D6': 12, # GPIO, SPI MISO (Master in, Slave out)
'D7': 13, # GPIO, SPI MOSI (Master out, Slave in)
'D8': 15, # GPIO, SPI SS (Slave select)
'A0': 0, # Analog in, via ADC
'RX': 3, # Receive
'TX': 1 # Transmit
}
# Game pins
self.Buzzer = wemos_d1_pins['D8']
self.Neo = wemos_d1_pins['D4']
self.SDA = wemos_d1_pins['D2']
self.SCL = wemos_d1_pins['D1']
self.X_Sel_Pin = wemos_d1_pins['D6']
self.Y_Sel_Pin = wemos_d1_pins['D5']
self.Joy_Sw = wemos_d1_pins['D3']
self.A_Sw = wemos_d1_pins['D7']
self.B_Sw = wemos_d1_pins['D3']
self.i2c = I2C(scl=Pin(self.SCL), sda=Pin(self.SDA), freq=400000)
self.display = sh1106.SH1106_I2C(128, 64, self.i2c, Pin(16), 0x3c)
# button pins
self.A = Pin(self.A_Sw, Pin.IN, Pin.PULL_UP)
self.B = Pin(self.B_Sw, Pin.IN, Pin.PULL_UP)
# joystick pins
self.X_Sel = Pin(self.X_Sel_Pin, Pin.OUT)
self.Y_Sel = Pin(self.Y_Sel_Pin, Pin.OUT)
self.X_Sel.value(0)
self.Y_Sel.value(0)
self.adc = machine.ADC(wemos_d1_pins['A0'])
#led
self.numLEDs = 19
self.np = NeoPixel(Pin(self.Neo), self.numLEDs)
#sound on
self.playSound = True
class MyMachine:
# physical interfaces
i2c = None
display = None
bme = None
pump = None
pump_reverse = None
button = None
adc = None
# sensor variables
temp = None
hum = None
pres = None
volt = None
water_storage = None
water_storage_max = 1.2
time_current = None
epoche = 0 #Epoche
# fixed values
addr = 0x48
gain = 1
time_start = time.ticks_ms() #start Wert des internen Zählers
#config
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=400000) #i2c settings
display = sh1106.SH1106_I2C(128, 64, i2c, Pin(16),
0x3c) #Load the driver and set it to "display"
display.sleep(False) #activate display
display.fill(0) #clear display
bme = BME280.BME280(i2c=i2c) #sensor function
pumpe = PWM(Pin(14), freq=0,
duty=0) #create PWM objekt and configure pump forward
pumpe_reverse = PWM(
Pin(12), freq=0,
duty=0) #create PWM objekt and configure pump backwards
button = Pin(0, Pin.IN, Pin.PULL_UP) #initialize button
addr = 0x48
gain = 1
adc = ads1x15.ADS1115(
i2c, addr, gain
) #create analog-digtial converter object to read analog humidity sensor
i = 0
start = time.ticks_ms() #start Wert des internen Zaehlers
autosetinterval = 25200 #counter
reset = 0 #reset for time counter
def scanner(self):
display_a = {} #Left for PCB testing
multiplexer_channel = 0
while multiplexer_channel != 8:
self.change_channel(multiplexer_channel)
channel = multiplexer_channel
try:
disp = sh1106.SH1106_I2C(128, 64, i2c, None, 0x3c)
state = 1
except Exception:
state = 0
global displays
displays.append(Xdisplay(channel, state))
display_a.update({multiplexer_channel:
state}) #Left for PCB testing
multiplexer_channel += 1
print(display_a)
return display_a
def display_temperature_and_humidity(temperature, humidity, use_normal_text):
# Note: This is conditionally imported to save memory.
# Since we are running a bunch of different processes
# (measuring using sensors, using wifi, sending data
# to cloud, showing data in the display), all those
# together made ESP8266 run out of memory when calling
# the cloud API to send data. Since the custom font
# processing is one of the most "memory consuming"
# process, we use it only if we are not sending data
# to cloud. If we do, we use normal text in the display
#
if not use_normal_text:
# Import required libraries
import freesans20
import writer
# Initialize I2C interface using the setup display pins
i2c = machine.I2C(scl=machine.Pin(config.DISPLAY_SCL_PIN),
sda=machine.Pin(config.DISPLAY_SDA_PIN),
freq=400000)
# Display detected?
if 60 not in i2c.scan():
print('Cannot find display')
raise RuntimeError('Cannot find display')
# For SSD1306 OLED Display
# display = ssd1306.SSD1306_I2C(128, 64, i2c)
# For SH1106 OLED Display
display = sh1106.SH1106_I2C(128, 64, i2c, machine.Pin(16), 0x3c)
# Custom font writer
font_writer = None
if not use_normal_text:
font_writer = writer.Writer(display, freesans20)
# Load PBM images
temperature_pbm = load_image('temperature.pbm')
units_pbm = load_image(
'fahrenheit.pbm' if config.FAHRENHEIT else 'celsius.pbm')
humidity_pbm = load_image('humidity.pbm')
percent_pbm = load_image('percent.pbm')
# Clean display content
display.fill(0)
# -------- V0 --------
# Prepare text information using 16 pixels per line x 4 lines
# Use formating ({:^16s}) to center text
# Temperature (lines 1 & 2)
# display.text('{:^16s}'.format('Temperature:'), 0, 0)
# display.text('{:^16s}'.format(str(temperature) +
# ('F' if config.FAHRENHEIT else 'C')), 0, 16)
# Humidity (lines 3 & 4)
# display.text('{:^16s}'.format('Humidity:'), 0, 32)
# display.text('{:^16s}'.format(str(humidity) + '%'), 0, 48)
# -------- V1 --------
# Draw a rectangle along the display borders
display.rect(0, 0, 128, 64, 1)
# Draw a line in the middle to separate things
display.line(64, 0, 64, 64, 1)
# Draw temperature symbol
display.blit(temperature_pbm, 24, 4)
# Draw humidity symbol
display.blit(humidity_pbm, 88, 4)
# Draw units symbol
display.blit(units_pbm, 28, 52)
# Draw percent symbol
display.blit(percent_pbm, 92, 52)
# Format current temperature using custom fonts
text = '{:.1f}'.format(temperature)
if use_normal_text:
# Use normal text
display.text(text, (34 - len(text)) // 2, 30)
else:
# Use custom fonts
textlen = font_writer.stringlen(text)
font_writer.set_textpos((64 - textlen) // 2, 30)
font_writer.printstring(text)
# Format current humidity using custom fonts
text = '{:.1f}'.format(humidity)
if use_normal_text:
# Use normal text
display.text(text, 64 + (34 - len(text)) // 2, 30)
else:
# Use custom fonts
textlen = font_writer.stringlen(text)
font_writer.set_textpos(64 + (64 - textlen) // 2, 30)
font_writer.printstring(text)
# Show content
print('Showing content in the display')
display.rotate(config.DISPLAY_ROTATE)
display.show()
# Wait 10 seconds
print('Waiting 10 seconds before display power off')
time.sleep(10)
# Power off display
print('Powering off display')
display.poweroff()
lowBeep()
display.text(str(BPressed), 0, 10)
display.text(str(JoyX), 0, 20)
display.text(str(JoyY), 0, 30)
print(str(JoyX) + "\t" + str(JoyY))
display.pixel(JoyX // 20 + 50, JoyY // 20, 1)
display.rotate(True)
display.show()
count = count + 1
if __name__ == '__main__':
#setup the variables
i2c = I2C(scl=Pin(SCL), sda=Pin(SDA), freq=400000)
display = sh1106.SH1106_I2C(128, 64, i2c, Pin(16), 0x3c)
#button pins
A = Pin(A_Sw, Pin.IN, Pin.PULL_UP)
B = Pin(B_Sw, Pin.IN, Pin.PULL_UP)
#joystick pins
X_Sel = Pin(X_Sel_Pin, Pin.OUT)
Y_Sel = Pin(Y_Sel_Pin, Pin.OUT)
X_Sel.value(0)
Y_Sel.value(0)
adc = machine.ADC(wemos_d1_pins['A0'])
#testOled()
#testNeoPixels()
#playSong()
'''
from machine import I2C, Timer, Pin
import sh1106
import bme280_float as bme280
from time import sleep
import network, utime
import ujson as json
import uP_-_14_40_-_oled_bme_280_IFTTT_modules as modules
led = Pin(21, Pin.OUT)
i2c = I2C(0)
display = sh1106.SH1106_I2C(128, 64, i2c, None, 0x3c)
bme = bme280.BME280( i2c=i2c,
mode=bme280.BME280_OSAMPLE_8,
address=bme280.BME280_I2CADDR ) # Works ok with explicity settings
with open("/wifi_settings_ifttt.json") as credentials_json: # This pattern allows you to open and read an existing file.
settings = json.loads(credentials_json.read())
url = "https://maker.ifttt.com/trigger/uPython/with/key/" + settings["ifttt_key"]
wlan = network.WLAN(network.STA_IF) # This will create a station interface object.
# To create an access point, use AP_IF (not covered here).
def timer_isr(event):
from adafruit_seesaw.digitalio import DigitalIO
from adafruit_seesaw.rotaryio import IncrementalEncoder
import sh1106
def showit():
display.fill(0)
display.text("Position: {}".format(rposition),12,32,1)
display.text("Position: {}".format(lposition),12,43,1)
display.show()
# Create the I2C interface.
i2c = busio.I2C(SCL, SDA,frequency=400000)
display = sh1106.SH1106_I2C(128,64,i2c)
rightseesaw = Seesaw(i2c, addr=0x37)
leftseesaw = Seesaw(i2c, addr=0x38)
right = IncrementalEncoder(rightseesaw)
left = IncrementalEncoder(leftseesaw)
last_rposition = 0
last_lposition = 0
rposition = 0
lposition = 0
showit()
while True:
dirty = False
# read position of the rotary encoder
import sh1106 #display lib
from time import sleep
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=400000) #i2c settings
display = sh1106.SH1106_I2C(128, 64, i2c, Pin(16), 0x3c) #Load the driver and set it to "display"
display.sleep(False) #activate display
display.fill(0) #clear display
temp = 1
hum = 2
pres = 3
volt = 3
Hallo world
def display_output(): #print to display
display.rotate(flag=1) #rotate display 180°
display.fill(0)
display.text('HOT: ' + str(temp), 0, 1)
display.text('AIR: ' + str(hum), 0, 15)
display.text('PRES: ' + str(pres), 0, 30)
display.text('HUMI: ' + str(volt), 0, 45)
display.show()
while True: #main body
display_output() #calls function to print data to display
sleep(60)
import machine
import uos
import sh1106
import utime
from machine import I2C, Pin, ADC
adc = machine.ADC(0)
i2c = I2C(scl=Pin(12), sda=Pin(14))
oled = sh1106.SH1106_I2C(128, 64, i2c)
while True:
for _ in range(500):
x = int(uos.urandom(1)[0] / 2)
y = int(uos.urandom(1)[0] / 4)
oled.pixel(x, y, 1)
oled.show()
utime.sleep_ms(200)
oled.fill(0)
]
buzzer = machine.PWM(machine.Pin(28))
displayi2c = machine.I2C(1,
sda=machine.Pin(2),
scl=machine.Pin(3),
freq=800000)
# The display connects over I2C. The display has a command based language implemented
# on it's display controller chip (SH1106). Thankfully someone already wrote a MicrPython
# driver for it.
# https://github.com/robert-hh/SH1106
displayWidth = micropython.const(128)
displayHeight = micropython.const(64)
display = sh1106.SH1106_I2C(displayWidth, displayHeight, displayi2c, None, 60)
display.init_display()
display.contrast(255)
display.rotate(True)
display.invert(True)
display.poweron()
# Displays 2 rows of text centered on the screen.
def displayScore(label, wut):
# Blank out the old pixels
display.fill(0)
# Each character is 8 pixels wide. Since we want half that (we're centering)
# then we * 4 instead of * 8.
display.text(label, int(displayWidth / 2) - len(label) * 4, 30 - 6, 1)
hSize = 64 # display heigh in pixels
wSize = 128 # display width in pixels
temp = 0 # temperature from BME280
pres = 0 # atmospheric pressure from BME280
humi = 0 # humidity from BME280
temp_out = 0 # outside temperature via mqtt
# init ic2 object
#display_show('I2C Init...')
i2c = machine.I2C(scl=machine.Pin(pinScl), sda=machine.Pin(pinSda))
#display_show('OK')
# init display
display = sh1106.SH1106_I2C(128, 64, i2c, machine.Pin(16), 0x3c)
display_switch = 'ON'
def display_show(message):
display.fill(0)
display.text(str(message), 0, 20, 1)
display.show()
time.sleep_ms(1000)
display_show('HELLO! =)')
# mqtt messaged frequency
msg_frq = 60 # every 1 minute
now_mqtt = time.time()
def __init__(self, orientation=0):
for display in displays:
if display.state == 1:
multiplex.change_channel(display.channel)
display.driver = sh1106.SH1106_I2C(128, 64, i2c, Pin(16), 0x3c)
# This file is executed on every boot (including wake-boot from deepsleep)
#import esp
#esp.osdebug(None)
import uos, machine, sh1106
#uos.dupterm(None, 1) # disable REPL on UART(0)
import gc
#import webrepl
#webrepl.start()
gc.collect()
import network
import json
i2c = machine.I2C(scl=machine.Pin(4), sda=machine.Pin(5))
oled = sh1106.SH1106_I2C(128, 64, i2c, None, 0x3c)
SSID = "<your-ssid>"
PWD = "<your-pwd>"
with open("params.json", "r") as r:
params = json.load(r)
SSID = params["wifi"]["ssid"]
PWD = params["wifi"]["password"]
oled.fill(0)
oled.text("connecting to:", 0, 0)
oled.text(SSID, 0, 10)
oled.rotate(True)
oled.show()
* Author(s): Kevin Neubauer
"""
import board
import busio
import sh1106
import time
import framebuf
WHITE = 1
BLACK = 0
SCRWIDTH = 128
SCRHEIGHT = 64
#initialize screen over I2C
i2c = busio.I2C(board.SCL, board.SDA)
display = sh1106.SH1106_I2C(SCRWIDTH, SCRHEIGHT, i2c, addr=0x3c)
class VirtualPetFramebuf:
def __init__(self, intWidth, intHeight):
self.height = intHeight
self.width = intWidth
bufsize = self.width * self.height // 8
buf = bytearray(bufsize)
for x in range(bufsize):
buf[x] = 0
self.framebuf = framebuf.FrameBuffer(buf, self.width, self.height,
framebuf.MONO_VLSB)
#function that takes 0 and 1 contents from a string and populates a framebuffer object
def setContentsFromString(self, strBits, x_origin=0, y_origin=0):
'D4': 2, # GPIO
'D5': 14, # GPIO, SPI SCK (Serial Clock)
'D6': 12, # GPIO, SPI MISO (Master in, Slave out)
'D7': 13, # GPIO, SPI MOSI (Master out, Slave in)
'D8': 15, # GPIO, SPI SS (Slave select)
'A0': 0, # Analog in, via ADC
'RX': 3, # Receive
'TX': 1 # Transmit
}
# Setup the I2C for the display and initialize
i2c = I2C(-1,
sda=Pin(wemos_d1_pins["D2"]),
scl=Pin(wemos_d1_pins["D5"]),
freq=400000)
display = sh1106.SH1106_I2C(dwidth, dheight, i2c, Pin(16), 0x3c)
# Setup wifi and connect
wlan = network.WLAN(network.STA_IF) # Set wifi to station mode
wlan.active(True) # Mark the interface as active
wlan.scan() # Scan for access points (may not be needed)
wlan.connect(wifissid, wifipsk) # connect to the AP configured above
# TODO: Should probably loop here waiting until wlan.isconnected() is True.
# Maybe display wifi status, maybe attempt to reconnect.
# For loading files and debugging in a browser, otherwise use ampy
#import webrepl
#webrepl.start()
