Shields

There is a number of ready to use “shields” – add-on boards – for the WeMos D1 Mini, containing useful components together with all the necessary connections and possible additional components. All you have to do is plug such a “shield” on top or bottom of the WeMos D1 Mini board, and load the right code to use the components on it.

Button

This is a very basic shield that contains a single pushbutton. The button is connected to pin gpio0 and to gnd, so you can read its state with this code:

from machine import Pin
button = Pin(0)
if button.value():
    print("The button is not pressed.")
else:
    print("The button is pressed.")

Of course everything we learned about buttons and debouncing applies here as well.

DHT and DHT Pro

Those two shield have temperature and humidity sensors on them. The first one, DHT, has DHT11 sensor, the second one, DHT Pro, has DHT22, which is more accurate and has better precision.

In both cases the sensors are available on the pin gpio2, and you can access them with code like this:

from machine import Pin
import dht
sensor = dht.DHT11(Pin(2))
sensor.measure()
print(sensor.temperature())
print(sensor.humidity())

(Use DHT22 class for the DHT Pro shield.)

It is recommended to use this shield with the “dual base”, so that the temperature sensor is not right above or below the ESP8266 module, which tends to become warm during work and can affect temperature measurements.

Neopixel

That shield has a single addressable RGB LED on it, connected to pin gpio4. Unfortunately, that means that this shield conflicts with any other shield that uses the I²C protocol, such as the OLED shield or the motor shield. You can use it with code lik this:

form machine import Pin
import neopixel
pixels = neopixel.NeoPixel(Pin(4, Pin.OUT), 1)
pixels[0] = (0xff, 0x00, 0x22)
pixels.write()

Relay

This shield contains a relay switch, together with a transistor and a couple of other components required to reliably connect it to the board. It uses pin gpio5, which unfortunately makes it incompatible with any other shields using the I²C protocol, such as the OLED shield or the motor shield. You can control the relay with the following code:

from machine import Pin
relay = Pin(5, Pin.OUT)
relay.low() # Switch off
relay.high() # Switch on

OLED

A small, 64×48 monochrome display. It uses pins gpio4 and gpio5 to talk with the board with the I²C protocol. It will conflict with any other shield that uses those pins, but doesn’t use I²C, like the neopixel shield or the relay shield. It can coexist with other shields that use I²C, like the motor shield.

Up to two such displays can be connected at the same time, provided they have different addresses set using the jumper on the back.

You can control the display using the ssd1306 library:

import ssd1306
from machine import I2C, Pin
i2c = I2C(-1, Pin(5), Pin(4))
display = ssd1306.SSD1306_I2C(64, 48, i2c)
display.fill(0)
display.text("Hello", 0, 0)
display.text("world!", 0, 8)
display.pixel(20, 20, 1)
display.show()

Motor

The motor shield contains a H-bridge) and a PWM chip, and it’s able to drive up to two small DC motors. You can control it using I²C on pins gpio4 and gpio5. It will conflict with any shields that use those pins but don’t use I²C, such as the relay shield and the neopixel shield. It will work well together with other shields using I²C.

Up to four such shields can be connected at the same time, provided they have different addresses selected using the jumpers at their backs.

In order to use this shield, use the d1motor library:

import d1motor
from machine import I2C, Pin
i2c = I2C(-1, Pin(5), Pin(4), freq=10000)
m0 = d1motor.Motor(0, i2c)
m1 = d1motor.Motor(1, i2c)
m0.speed(5000)

Micro SD

This shield lets you connect a micro SD card to your board. It connects to pins gpio12, gpio13, gpio14 and gpio15 and uses SPI protocol. It can be used together with other devices using the SPI protocol, as long as they don’t use pin gpio15 as CS.

You can mount an SD card in place of the internal filesystem using the following code:

import os
from machine import SPI, Pin
import sdcard
sd = sdcard.SDCard(SPI(1), Pin(15))
os.umount()
os.VfsFat(sd, "")

Afterwards you can use os.listdir(), open() and all other normal file functions to manipulate the files on the SD card. In order to mount the internal filesystem back, use the following code:

import flashbdev
os.umount()
os.VfsFat(flashbdev.bdev, "")

Battery

This shield lets you power your board from a single-cell LiPo battery. It connects to the 5V pin, and doesn’t require any communication from your board to work. You can simply plug it in and use it.

Servo (Custom)

There is an experimental 18-channel servo shield. It uses the I²C protocol on pins gpio4 and gpio5 and is compatible with other I²C shields.

In order to power the servos, you need to either provide external power to the pin marked with + next to the 5V pin, or connect it with the 5V pin to make the servos share power with the board.

You can set the servo positions using the following code:

from servo import Servos
from machine import I2C, Pin
i2c = I2C(-1, Pin(5), Pin(4))
servos = Servos(i2c)
servos.position(0, degrees=45)

TFT Screen (Custom)

There is an experimental breakout board for the ST7735 TFT screen. It uses the SPI interface on pins gpio12, gpio13, gpio14, and gpio15.

You can use it with the following example code:

from machine import Pin, SPI
import st7735

display = st7735.ST7735(SPI(1), dc=Pin(12), cs=None, rst=Pin(15))
display.fill(0x7521)
display.pixel(64, 64, 0)

If you have a display with a red tab, you need to use a different initialization:

display = st7735.ST7735R(SPI(1, baudrate=40000000), dc=Pin(12), cs=None, rst=Pin(15))