Micropython/Micropython on NodeMCU - Physical Computing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter - Micropython on ESP8266 (NodeMCU)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining Port and Baud Rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mConnecting to --port=/dev/tty.SLAB_USBtoUART --baud=115200 \u001b[0m\n",
      "\u001b[34mReady.\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "%serialconnect to --port=/dev/tty.SLAB_USBtoUART --baud=115200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing Connection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello esp8266\r\n"
     ]
    }
   ],
   "source": [
    "print ('hello esp8266')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Blinking a LED"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Connected LED:\n",
    "- LED cathode at D3 (GPIO 0)\n",
    "- LED anode at GND"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import library to deal with pins:\n",
    "from machine import Pin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define pin 0 as output\n",
    "led = Pin(0, Pin.OUT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define value of \"led\" as \"1\" or \"True\" to turn on the LED\n",
    "led.value(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define value of \"led\" as \"0\" or \"False\" to turn off the LED\n",
    "led.value(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# also you can use .on() or .off methods to control the pin: \n",
    "led.on()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "led.off()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Blinking the Led: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import sleep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    led.on()\n",
    "    sleep(0.5)\n",
    "    led.off()\n",
    "    sleep(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading Digital Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Connect a push-button:\n",
    "- leg1 at Pin 13 (D7)\n",
    "- leg2 at GND\n",
    "\n",
    "Note that when pressed, pin 13 will be connected to GND (\"0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define pin 13 as an input and activate an internal Pull-up resistor:\n",
    "button = Pin(13, Pin.IN, Pin.PULL_UP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\r\n"
     ]
    }
   ],
   "source": [
    "# Read button state:\n",
    "print(button.value())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\r\n"
     ]
    }
   ],
   "source": [
    "print (button.value())\n",
    "if button.value() == 0:\n",
    "    led.on()\n",
    "else:\n",
    "    led.off()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PWM (pulse width modulation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from machine import Pin, PWM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create PWM object from a pin\n",
    "pwm0 = PWM(Pin(0))      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set frequency\n",
    "pwm0.freq(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set duty cycle\n",
    "pwm0.duty(200)          "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diming the LED"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "."
     ]
    }
   ],
   "source": [
    "for i in range (0,1023,20):\n",
    "    pwm0.duty(i)\n",
    "    sleep(0.1)\n",
    "pwm0.duty(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# turn off PWM on the pin\n",
    "pwm0.deinit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controling a Servo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# servos usually works with frequency of 50Hz and then a duty between about 40 and 115, \n",
    "# with 77 being the centre value.\n",
    "servo = PWM(Pin(14), freq=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Minimum position (angle 0)\n",
    "servo.duty(40) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maximun position (angle 180)\n",
    "servo.duty(115)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Medium position (angle 90)\n",
    "servo.duty(77)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".."
     ]
    }
   ],
   "source": [
    "# swipping servo\n",
    "step = 2\n",
    "for i in range (40, 115, step):\n",
    "    servo.duty(i)\n",
    "    sleep (0.1)\n",
    "step = -1*step\n",
    "for i in range (115, 40, step):\n",
    "    servo.duty(i)\n",
    "    sleep (0.1)\n",
    "servo.duty(77)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analog Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reading light from a LDR connected on analog pin 0 (A0) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import library\n",
    "from machine import ADC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define object\n",
    "adc = ADC(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "768\r\n"
     ]
    }
   ],
   "source": [
    "# read Analog pin:\n",
    "print (adc.read()) # w/o light < 40 | with light > 850"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controlling 1-wire devices\n",
    "Reading Temperature with DS18B20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import libraries \n",
    "import onewire, ds18x20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define which pin the 1-wire device will be connected ==> pin 2 (D4)\n",
    "dat = Pin(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the onewire object\n",
    "ds = ds18x20.DS18X20(onewire.OneWire(dat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found devices: [bytearray(b'(\\xff\\xd3\\xe6a\\x16\\x041')]\r\n"
     ]
    }
   ],
   "source": [
    "# scan for devices on the bus\n",
    "sensors = ds.scan()\n",
    "print('found devices:', sensors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.8125\r\n"
     ]
    }
   ],
   "source": [
    "ds.convert_temp()\n",
    "time.sleep_ms(750)\n",
    "print(ds.read_temp(sensors[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading Temperature and Humidity, using DHT sensor\n",
    "DHT22 sensor connected to pin 12 (D6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dht import DHT22"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = DHT22(Pin(12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temp: 19.1oC\n",
      "Hum:  34.9%\n"
     ]
    }
   ],
   "source": [
    "data.measure()\n",
    "temp = data.temperature()\n",
    "hum = data.humidity()\n",
    "print('Temp: {}oC'.format(temp))\n",
    "print('Hum:  {}%'.format(hum))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### I2C – a two-wire serial protocol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from machine import I2C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "i2c = I2C(scl=Pin(5), sda=Pin(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scanI2c():\n",
    "    print('Scan i2c bus...')\n",
    "    devices = i2c.scan()\n",
    "\n",
    "    if len(devices) == 0:\n",
    "        print(\"No i2c device !\")\n",
    "    else:\n",
    "        print('i2c devices found:',len(devices))\n",
    "\n",
    "    for device in devices:  \n",
    "        print(\"Decimal address: \",device,\" | Hexa address: \",hex(device))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scan i2c bus...\n",
      "i2c devices found: 1\n",
      "Decimal address:  60  | Hexa address:  0x3c\n"
     ]
    }
   ],
   "source": [
    "scanI2c()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OLED\n",
    "Install a SSD1366 (128 x 64) I2C Oled display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ssd1306\n",
    "i2c = I2C(scl=Pin(5), sda=Pin(4))\n",
    "oled = ssd1306.SSD1306_I2C(128, 64, i2c, 0x3c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "oled.fill(0)\n",
    "oled.text(\"Hello esp8266\", 0, 0)\n",
    "oled.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Displaying sensor data: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.measure()\n",
    "temp = data.temperature()\n",
    "hum = data.humidity()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "oled.fill(0)\n",
    "oled.text(\"Temp:  \" + str(temp) + \"oC\", 0, 0)\n",
    "oled.text(\"Hum:   \" + str(hum) + \"%\",0, 16)\n",
    "oled.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MicroPython - USB",
   "language": "micropython",
   "name": "micropython"
  },
  "language_info": {
   "codemirror_mode": "python",
   "file_extension": ".py",
   "mimetype": "text/python",
   "name": "micropython"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}