Bobby Leonard
Published © GPL3+

MicroPython / Darksky API Weather Info on Wemos D1 Mini

Use a Micropython Wemos to display time, atmospheric pressure, apparent temperature, and precipitation probability from Darksky API.

IntermediateFull instructions provided1 hour2,740
MicroPython / Darksky API Weather Info on Wemos D1 Mini

Things used in this project

Hardware components

Wemos D1 Mini
Espressif Wemos D1 Mini
×1
I2C 128x32 OLED
×1

Software apps and online services

MicroPython
MicroPython

Story

Read more

Schematics

Wiring

Code

main.py

MicroPython
The main file for the micropython board. Make sure to replace the api key and latitude and longtitude in the url for the request.
import time
import machine, ssd1306
import urequests

# Register for Darksky api
# Change the [key], [latitude] and [longitude] values below

url = 'https://api.darksky.net/forecast/[key]/[latitude],[longitude]?units=si&exclude=minutely,hourly,daily,alerts'

resp = urequests.get(url) # Send the request

def setClock():
	hours = str(time.localtime()[3])
	mins = str(time.localtime()[4])
	secs = str(time.localtime()[5])
	if int(secs) < 10:
		secs = '0' + secs
	if int(mins) < 10:
		mins = '0' + mins
	if int(hours) < 10:
		hours = '0' + hours
	
	
	DSave = int(hours) + 1
	# Change the 1 to 0 if not daylight savings
	
	if DSave > 23:
		DSavehours = '00'
	DSavehours = str(DSave)
	timestr = DSavehours + ':' + mins + ':' + secs
	
	return timestr

	
i2c = machine.I2C(-1, machine.Pin(5), machine.Pin(4))
oled = ssd1306.SSD1306_I2C(128, 32, i2c)


while True:
	timestr = setClock()
	pressurestr = str(resp.json()['currently']['pressure']) + ' hPa'
	tempstr = str(resp.json()['currently']['apparentTemperature']) + ' *C'
	rainstr = 'RainChance:' + str(int(float(resp.json()['currently']['precipProbability']) * 100)) + '%'
	minutes = int(timestr.split(':')[1])
	secs = int(timestr.split(':')[2])
	if (minutes % 2 == 0) and (secs == 0):
		resp = urequests.get(url)
	oled.fill(0)
	oled.show()
	oled.text(timestr, 0, 1)
	oled.text(pressurestr, 0, 9)
	oled.text(tempstr, 0, 17)
	oled.text(rainstr, 0, 25)
	oled.show()
	time.sleep(1)

boot.py

MicroPython
Network Config for micropython board. Change 'WIFI-Network' and 'Password' to your own values.
import esp
import network
import socket
import gc
esp.osdebug(None)
from ntptime import settime
gc.collect()

def do_connect():
        sta_if = network.WLAN(network.STA_IF)
        if not sta_if.isconnected():
                print('connecting to network...')
                sta_if.active(True)
                sta_if.connect('WIFI-Network', 'Password')
                while not sta_if.isconnected():
                        pass

do_connect() # Connect to WIFI
settime()    # Use NTP to set clock

ssd1306.py

MicroPython
Adafruit MicroPython driver for SSD1306 OLED displays.
https://github.com/adafruit/micropython-adafruit-ssd1306
# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
# https://github.com/adafruit/micropython-adafruit-ssd1306

import time
import framebuf


# register definitions
SET_CONTRAST        = const(0x81)
SET_ENTIRE_ON       = const(0xa4)
SET_NORM_INV        = const(0xa6)
SET_DISP            = const(0xae)
SET_MEM_ADDR        = const(0x20)
SET_COL_ADDR        = const(0x21)
SET_PAGE_ADDR       = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP       = const(0xa0)
SET_MUX_RATIO       = const(0xa8)
SET_COM_OUT_DIR     = const(0xc0)
SET_DISP_OFFSET     = const(0xd3)
SET_COM_PIN_CFG     = const(0xda)
SET_DISP_CLK_DIV    = const(0xd5)
SET_PRECHARGE       = const(0xd9)
SET_VCOM_DESEL      = const(0xdb)
SET_CHARGE_PUMP     = const(0x8d)


class SSD1306:
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        # Note the subclass must initialize self.framebuf to a framebuffer.
        # This is necessary because the underlying data buffer is different
        # between I2C and SPI implementations (I2C needs an extra byte).
        self.poweron()
        self.init_display()

    def init_display(self):
        for cmd in (
            SET_DISP | 0x00, # off
            # address setting
            SET_MEM_ADDR, 0x00, # horizontal
            # resolution and layout
            SET_DISP_START_LINE | 0x00,
            SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
            SET_MUX_RATIO, self.height - 1,
            SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
            SET_DISP_OFFSET, 0x00,
            SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
            # timing and driving scheme
            SET_DISP_CLK_DIV, 0x80,
            SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
            SET_VCOM_DESEL, 0x30, # 0.83*Vcc
            # display
            SET_CONTRAST, 0xff, # maximum
            SET_ENTIRE_ON, # output follows RAM contents
            SET_NORM_INV, # not inverted
            # charge pump
            SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
            SET_DISP | 0x01): # on
            self.write_cmd(cmd)
        self.fill(0)
        self.show()

    def poweroff(self):
        self.write_cmd(SET_DISP | 0x00)

    def contrast(self, contrast):
        self.write_cmd(SET_CONTRAST)
        self.write_cmd(contrast)

    def invert(self, invert):
        self.write_cmd(SET_NORM_INV | (invert & 1))

    def show(self):
        x0 = 0
        x1 = self.width - 1
        if self.width == 64:
            # displays with width of 64 pixels are shifted by 32
            x0 += 32
            x1 += 32
        self.write_cmd(SET_COL_ADDR)
        self.write_cmd(x0)
        self.write_cmd(x1)
        self.write_cmd(SET_PAGE_ADDR)
        self.write_cmd(0)
        self.write_cmd(self.pages - 1)
        self.write_framebuf()

    def fill(self, col):
        self.framebuf.fill(col)

    def pixel(self, x, y, col):
        self.framebuf.pixel(x, y, col)

    def scroll(self, dx, dy):
        self.framebuf.scroll(dx, dy)

    def text(self, string, x, y, col=1):
        self.framebuf.text(string, x, y, col)


class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        # Add an extra byte to the data buffer to hold an I2C data/command byte
        # to use hardware-compatible I2C transactions.  A memoryview of the
        # buffer is used to mask this byte from the framebuffer operations
        # (without a major memory hit as memoryview doesn't copy to a separate
        # buffer).
        self.buffer = bytearray(((height // 8) * width) + 1)
        self.buffer[0] = 0x40  # Set first byte of data buffer to Co=0, D/C=1
        self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.temp[0] = 0x80 # Co=1, D/C#=0
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)

    def write_framebuf(self):
        # Blast out the frame buffer using a single I2C transaction to support
        # hardware I2C interfaces.
        self.i2c.writeto(self.addr, self.buffer)

    def poweron(self):
        pass


class SSD1306_SPI(SSD1306):
    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
        self.rate = 10 * 1024 * 1024
        dc.init(dc.OUT, value=0)
        res.init(res.OUT, value=0)
        cs.init(cs.OUT, value=1)
        self.spi = spi
        self.dc = dc
        self.res = res
        self.cs = cs
        self.buffer = bytearray((height // 8) * width)
        self.framebuf = framebuf.FrameBuffer1(self.buffer, width, height)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs.high()
        self.dc.low()
        self.cs.low()
        self.spi.write(bytearray([cmd]))
        self.cs.high()

    def write_framebuf(self):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs.high()
        self.dc.high()
        self.cs.low()
        self.spi.write(self.buffer)
        self.cs.high()

    def poweron(self):
        self.res.high()
        time.sleep_ms(1)
        self.res.low()
        time.sleep_ms(10)
        self.res.high()

Credits

Bobby Leonard

Bobby Leonard

6 projects • 21 followers
Making and breaking computers and electronics. Coding, Networking, Data Sec etc etc. Physics fan also.

Comments