Merge branch 'dev'

Author: francois-berder

README.md

@@ -1,86 +1,59 @@
-# PyLetMeCreate
+![logo](https://static.creatordev.io/logo-md-s.svg)
 
-This is the python binding of the LetMeCreate library. It requires Python 3. See [LetMeCreate](https://github.com/francois-berder/LetMeCreate) for the complete list of interface and click board supported.
 
-## Integration in Openwrt
+# PyLetMeCreate
 
-Before reading any further, make sure that you installed the LetMeCreate library as shown on its github page.
+This is the python binding of the LetMeCreate library. It requires Python 3. See [LetMeCreate](https://github.com/francois-berder/LetMeCreate) for the complete list of interface and click board supported.
+PyLetMeCreate relies on LetMeCreate, hence it is important that both versions match. 
 
+Examples are installed in /usr/bin/pyletmecreate_examples.
 
-### Installation steps
+## Integration in Openwrt
 
-Clone the library and openwrt somewhere on you computer:
+PyLetMeCreate is already part of Imagination Technologies' OpenWrt.
+To compile the library (only possible once you built Openwrt once):
 
 ```sh
-$ mkdir ci-40
-$ cd ci-40
-$ git clone https://github.com/CreatorDev/openwrt.git
-$ mkdir -p custom/pyletmecreate
-$ cd custom/pyletmecreate
+$ make package/pyletmecreate/{clean,compile} -j1 V=s
 ```
-#### Stable release
 
-If you are only interested in getting the latest release of LetMeCreate library, then download a copy of Makefile.stable located in miscellaneous folder. Copy this file inside the pyletmecreate folder you have just created and rename it to Makefile.
-
-#### Development configuration
+### Installation steps
 
-If you are interested in modifying the library, getting the latest changes, then clone it in custom/pyletmecreate folder you just created:
+You can install PyLetMeCreate package on OpenWRT executing:
 
 ```sh
-$ git clone https://github.com/francois-berder/PyLetMeCreate.git
+$ opkg install pyletmecreate
 ```
 
-Copy the Makefile to the right location:
-```sh
-$ cp PyLetMeCreate/miscellaneous/Makefile.devel Makefile
-```
+Each release has the ipk as an attachment. You can download the ipk, copy it to your Ci40 and install with opkg:
 
-This project uses two branches. The dev branch contains all the latest changes and should not be considered stable. The dev branch is sometimes merged to master once new features are considered stable.
-
-#### Register PyLetMeCreate in Openwrt
-
-To register the feed in openwrt, go back in openwrt folder and open feeds.conf.default.
-Add this line:
-```
-src-link custom /change/this/path/to/the/location/of/ci-40/custom/directory/
-```
-
-Update and install all feeds:
 ```sh
-$ ./scripts/feeds update -a
-$ ./scripts/feeds install -a
+$ opkg install path-to-the-ipk
 ```
-Select python3-letmecreate in make menuconfig. It will automatically select python3 and letmecreate. Then, compile Openwrt:
 
-```sh
-$ make -j1 V=s
-```
-To create an ipk, run this command (only possible once you built Openwrt once):
-
-```sh
-$ make package/pyletmecreate/{clean,compile} -j1 V=s
-```
+### Usage example
 
-### Installation of PyLetMeCreate on Ci40
 
-#### Install PyLetMeCreate using ipk
+```python
+#!/usr/bin/env python3
+"""This example shows how to read the temperature using a Thermo3 Click
+on Mikrobus 1.
+"""
 
-In openwrt folder, the ipk is located in bin/pistachio/packages/custom. Transfer it to your Ci40 using scp:
-```sh
-$ scp bin/pistachio/packages/custom/python3-letmecreate_1.0.1_pistachio.ipk root@<ip-of-your-ci40>:/tmp
-```
+from letmecreate.core import i2c
+from letmecreate.core.common import MIKROBUS_1
+from letmecreate.click import thermo3
 
-On you Ci40:
-```sh
-$ opkg install /tmp/python3-letmecreate_1.0.1_pistachio.ipk
-```
 
-#### Install PyLetMeCreate by copying letmecreate folder
+# Initialise I2C on Mikrobus 1
+i2c.init()
+i2c.select_bus(MIKROBUS_1)
 
+# Read temperature
+thermo3.enable(0)
+print('{} degrees celsius'.format(thermo3.get_temperature()))
+thermo3.disable()
 
-In your PyLetMeCreate folder, transfer the files to:
-```sh
-$ scp letmecreate root@<ip-of-your-Ci40>:/usr/lib/python3.5/site-packages
+# Release I2C
+i2c.release()
 ```
-
-This will only work if python3.5 is already installed on your Ci40. You might need to change the directory path if you have a different version of Python installed.

examples/accel_example.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""This example shows how to use the Accel Click wrapper of the LetMeCreate to
+obtain 3-axis accelerometer data.
+
+It continuously displays latest accelerometer measurements with at a rate
+of 10Hz. The user has to interrupt the program to exit it by pressing Ctrl+C.
+
+The Accel Click must be inserted in Mikrobus 1 before running this program.
+"""
+
+from letmecreate.core import spi
+from letmecreate.core.common import MIKROBUS_1
+from letmecreate.click import accel
+from time import sleep
+
+spi.init()
+spi.select_bus(MIKROBUS_1)
+accel.use_spi()
+accel.enable()
+
+while True:
+	measure = accel.get_measure()
+	print('{0:9.3f} {1:9.3f} {2:9.3f}'.format(measure[0], measure[1], measure[2]))
+	sleep(0.1)
+
+accel.disable()
+spi.release()

examples/adc_example.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+"""This example shows how to use the ADC Click wrapper of the LetMeCreate
+library.
+
+It reads ADC values from the four channels. Each value should be in range
+0..4095. If no wires are connected to the channels of the ADC Click, then
+the values should be random.
+
+The ADC Click must be inserted in Mikrobus 1 before running the program.
+"""
+from letmecreate.core import spi
+from letmecreate.click import adc
+
+
+spi.init()
+
+for i in range(adc.ADC_CLICK_CHANNEL_COUNT):
+    print('channel {} value: {}'.format(i, adc.get_raw_value(i)))
+
+spi.release()

examples/alphanum_example.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""This example shows how to use the Alphanum Click wrapper of the LetMeCreate
+to display characters.
+
+It displays "Ci" using both displays by enabling them one after the other at
+100Hz to give the illusion that both characters are displayed at the same
+time. The user has to interrupt the program to exit it by pressing Ctrl+C.
+ *
+The Alphanum Click must be inserted in Mikrobus 1 before running this
+program.
+"""
+
+from letmecreate.core.common import MIKROBUS_1
+from letmecreate.core import spi
+from letmecreate.click import alphanum
+import time
+
+
+spi.init()
+alphanum.init(MIKROBUS_1)
+alphanum.write('C', 'i')
+
+while True:
+    alphanum.select_left_display()
+    time.sleep(0.01)
+    alphanum.select_right_display()
+    time.sleep(0.01)

examples/bargraph_example.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""This example shows how to use the BarGraph Click wrapper of the LetMeCreate
+library.
+
+It turns on gradually all the LED's from left to right in 2 seconds.
+
+The BarGraph Click must be inserted in Mikrobus 1 before running this program.
+"""
+
+from letmecreate.core.common import MIKROBUS_1
+from letmecreate.core import spi
+from letmecreate.click import bargraph
+from time import sleep
+
+
+spi.init()
+bargraph.set_intensity(MIKROBUS_1, 100.0)
+
+value = 1
+for i in range(10):
+	bargraph.set_value(value)
+	value <<= 1
+	value |= 1
+	sleep(0.2)
+
+spi.release()

examples/color2_example.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+"""This example shows how to use the Color2 Click wrapper of the LetMeCreate
+library.
+
+The Color2 Click must be plugged in Mikrobus 1 of Ci40.
+"""
+
+from letmecreate.core import i2c
+from letmecreate.click import color2
+
+
+i2c.init()
+color2.enable()
+
+measure = color2.get_color()
+color2.disable()
+i2c.release()
+
+print('red  : {}'.format(measure[0]))
+print('green: {}'.format(measure[1]))
+print('blue : {}'.format(measure[2]))

examples/color_example.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+"""This example shows how to use the Color Click wrapper of the LetMeCreate.
+
+It takes a measurement from the sensor, prints it in the terminal and exits.
+
+The Color Click must be inserted in Mikrobus 1 before running this program.
+"""
+
+from letmecreate.core import i2c
+from letmecreate.click import color
+
+i2c.init()
+color.enable()
+measure = color.get_color()
+color.disable()
+i2c.release()
+
+print('clear: {}'.format(measure[0]))
+print('red  : {}'.format(measure[1]))
+print('green: {}'.format(measure[2]))
+print('blue : {}'.format(measure[3]))

examples/data/image.jpg

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""This example shows some basic features of the EVE Click wrapper of the
+LetMeCreate library.
+
+It displays a green screen for three seconds, then displays some text for
+another three seconds.
+
+Before running this program:
+  - the EVE Click must be inserted in Mikrobus 1
+  - a WQVGA screen must be connected to the EVE Click.
+"""
+
+from letmecreate.core import spi
+from letmecreate.core.common import MIKROBUS_1
+from letmecreate.click import eve
+from time import sleep
+
+spi.init();
+spi.set_mode(MIKROBUS_1, 0)
+
+eve.enable(MIKROBUS_1)
+
+# Display a green screen for 3 seconds
+eve.clear(0, 255, 0)
+eve.display()
+
+sleep(3)
+
+# Display some text
+eve.clear(0, 0, 0)
+eve.draw(eve.FT800_TEXT,
+         [240,                              # x
+          136,                               # y
+          31,                                # font (31 is the largest font)
+          eve.FT800_OPT_CENTER,              # options
+          "Hello World !".encode('utf-8')])  # All strings must be encoded
+eve.display()
+
+sleep(3)
+
+eve.disable(MIKROBUS_1)
+spi.release()

examples/eve_example_1.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""This example shows features related to the touch screen of the EVE Click
+wrapper of the LetMeCreate library.
+
+It first performs calibration of the touch screen, then it prints the
+coordinates of the touch event. Press Ctrl+C to exit program.
+
+Before running this program:
+  - the EVE Click must be inserted in Mikrobus 1
+  - a WQVGA screen must be connected to the EVE Click.
+"""
+
+from letmecreate.core import spi
+from letmecreate.core.common import MIKROBUS_1
+from letmecreate.click import eve
+
+touch_screen_event = False
+last_event_x = 0
+last_event_y = 0
+
+def callback(x, y):
+    global touch_screen_event
+    global last_event_x, last_event_y
+    last_event_x = x
+    last_event_y = y
+    touch_screen_event = True
+
+
+spi.init()
+spi.set_mode(MIKROBUS_1, 0)
+
+eve.enable(MIKROBUS_1);
+
+# Perform calibration of touch screen
+eve.calibrate()
+
+# Add your own callback after calibration, otherwise you might get
+# incorrect coordinates.
+eve.attach_touch_callback(callback)
+
+eve.clear(0, 0, 0)
+eve.draw(eve.FT800_TEXT,
+       [240,
+       136,
+       31,
+       eve.FT800_OPT_CENTER,
+       "Tap on the screen".encode('utf-8')])
+eve.display()
+
+while True:
+
+    # Wait until the user touches the screen or that it exits
+    while not touch_screen_event:
+        pass
+
+    eve.clear(0, 0, 0)
+    eve.draw(eve.FT800_TEXT,
+             [240,
+              136,
+              25,
+              eve.FT800_OPT_CENTER,
+              "Touch event detected at:".encode('utf-8')])
+    eve.draw(eve.FT800_TEXT,
+            [240,
+            180,
+            25,
+            eve.FT800_OPT_CENTER,
+            "x: {}, y: {}".format(last_event_x, last_event_y).encode('utf-8')])
+    eve.display()
+
+eve.disable(MIKROBUS_1)
+spi_release()