AccessingTheSensorsAndActuators < AFNOG

Tags: view all tags

%SLIDESHOWSTART%
---+ Accessing sensors and actuators
<h2 align="center">Session 2 of the AFNOG tutorial<br />on !IoT sensors<br /><br />Uli Raich</h2>

---+++ 
---+ The sensors and actuators

For our experiment we need 3 different devices:<br /><br />
   * an rgb LED
   * a color sensor
   * a distance sensor
The rgb LED is not needed for the final project but very useful on the way to it

---+++ 
---+ Choosing the rgb LED

rgb LEDs consist of 3 individual LEDS in red,green and blue

Different rgb LEDs are available on the market:
| <img alt="ws2812.png" height="189" src="%ATTACHURL%/ws2812.png" title="ws2812.png" width="227" /> | <img alt="smdRgbLed.png" height="157" src="%ATTACHURL%/smdRgbLed.png" title="smdRgbLed.png" width="219" /> | <img alt="lilyPad.png" height="188" src="%ATTACHURL%/lilyPad.png" title="lilyPad.png" width="206" /> | <img alt="standardLed.png" height="179" src="%ATTACHURL%/standardLed.png" title="standardLed.png" width="215" /> |
| WS2812 | SMD rgb LED | !LilyPad LED | Standard LED |
---+++ 
---+ WS2812

The WS2812 is an LED with a controller chip on board. It is used in LED chains where

each LED is individually addressed.

A precisely timed digital communication protocol is used to accessed the LED.

Too complex for our tutorial

<img alt="ws2812.png" src="%ATTACHURL%/ws2812.png" title="ws2812.png" />

---+++ 
---+ The SMD rgb LED

This is a surface mount LED on a small PCB. It has 4 pins:<br /><br />
   * r,g,b
   * Gnd
<img alt="smdRgbLed.png" height="346" src="%ATTACHURL%/smdRgbLed.png" title="smdRgbLed.png" width="481" /><br /><br /><br />Unfortunately there are no current limiting resistors on this PCB which must

be provided externally (which values if we want max. 10mA in one LED?)

---+++ 
---+ The KY-016 rgb LED

The standard rgb LED on an BY-016 board has the current limiting resistors already on board.

The board uses a common cathode circuit, which means that it has a common ground

and the rgb signals must be on Vcc to light the LED

| <img alt="standardLed.png" height="380" src="%ATTACHURL%/standardLed.png" title="standardLed.png" width="454" /> | <img alt="commonCathode.png" src="%ATTACHURL%/commonCathode.png" title="commonCathode.png" /> |
---+++ 
---+ The LilyPad LED

The LilyPad LED also has the resistors already on board but uses a common anode LED.

This means that the common pin is on Vcc and the rgb pins

must be brought to ground to light the LED
| <img alt="lilyPad.png" height="363" src="%ATTACHURL%/lilyPad.png" title="lilyPad.png" width="397" /> | <img alt="commonAnode.png" height="413" src="%ATTACHURL%/commonAnode.png" title="commonAnode.png" width="329" /> |
---+++ 
---+ Connection to the Raspberry Pi

The photo shows the connections of an LED to the Raspberry Pi by

means of the cobbler (blue PCB) and a flat cable.

Like this we get access to interface pins on the Broadcom BCM2837 processor chip.

| <img alt="cobblerBreadboard.png" src="%ATTACHURL%/cobblerBreadboard.png" title="cobblerBreadboard.png" /> | <img alt="cobblerPinout.png" src="%ATTACHURL%/cobblerPinout.png" title="cobblerPinout.png" /> |

---+++ 
---+ GPIO

GPIO or %BLUE%<b>G</b>%ENDCOLOR%eneral %BLUE%<b>P</b>%ENDCOLOR%urpose%BLUE%<b> I</b>%ENDCOLOR%/<b>%BLUE%O%ENDCOLOR%</b> pins are pins for a single signal that

can be programmed to be input or output.

In addition internal pullup resistors can be enabled if desired.

In order to light our LED we therefore need 3 GPIO pins, one for each color.

These pins must be programmed to be output and the corresponding signal level

must be set (active high in case of common cathode, active low in case of common anode).

The intensity can be changed using pulse width modulation (pwm)

where a high frequency signal is sent to the LED.

The intensity is changed by changing the duty cycle of the signal

---+++ 
---+ Accessing GPIOs

Of course it is possible to access the GPIOs through

register access on the processor chip.

This however is clumsy and needs detailed knowledge of the chip.

A library is available giving the programmer easy access to GPIOs,

including intensity variation through pwm.

The library we will be using is pigpio which has a Python interface.

The library uses a daemon (pigpiod), which is usually started at system startup.

It is also possible to start it manually as super user.

The Python module connects to the daemon and sends commands to it.

The daemon is responsible for the hardware access.

Please have a look at the [[http://abyz.me.uk/rpi/pigpio/python.html][pigpio docs]].

---+++ 
---+ The PIGPIO documentation

<img alt="pigpioDoc.png" src="%ATTACHURL%/pigpioDoc.png" title="pigpioDoc.png" />

---+++ 
---+ Accessing the LED

Before trying to access the LED by program we simply connect <br /><br />
   * Vcc to the red, green or blue pin and GN to ‘-’ in case of the common cathode PCB
   * Vcc to ‘+’ and GND to red, green or blue in case of the common anode PCB
This will light the corresponding color or the LED.

Then we connect the LED to the Raspberry Pi as follows:<br /><br />
   * red to pin 18
   * green to pin 17
   * blue to pin 22
   * ‘-’ to GND in case of the common cathode version or<br />‘+’ to Vcc in case of the common anode version
---+++ 
---+ Lighting the LED by program

Strategy:<br /><br />
   * First we import the pigpio library:<br /><br /><span class="WYSIWYG_TT">import pigpio # imports the library</span>
   * Create a pi object from the pigpio class<br /><br />This will connect our program to the pigpiod daemon<br /><br /><span class="WYSIWYG_TT">pi = pigpio.pi()# connects to the daemon</span>
   * We program the gpio pins to be output:<br /><br /><span class="WYSIWYG_TT">pi.set_mode(_RED,pigpio.OUTPUT) # _RED must be set to 18</span>
   * And finally we write 0 or 1 to the pin:<br /><br /><span class="WYSIWYG_TT">pi.write(_RED,pigpio.HIGH) # or pigpio.LOW</span>
   * In order to change the intensity of the color component we use pwm:<br /><br /><span class="WYSIWYG_TT">pi.set_PWM_dutycycle(_RED, intensity) # intensity: 0..255 </span>
---+++ 
---+ 8 Colors

if we switch each of the LEDs then, because of 3 pins, we have 8 different colors.

All pins off is black, all pins on is white.
| <img alt="eightColors-1.png" height="356" src="%ATTACHURL%/eightColors-1.png" title="eightColors-1.png" width="391" /> | <img alt="eightColors-2.png" src="%ATTACHURL%/eightColors-2.png" title="eightColors-2.png" /> |
---+++ 
---+ Remotely connect to pigpiod

The call to pigpio can have up to 3 parameters:

=pi = pigpio.pi(host,port,show_errors)=

After this the program is identical to what we have seen. So…

What is the difference?

In the first case both, pigpiod and the Python program run on the Raspberry Pi

and only the keyboard, mouse and screen are used to interact via the ssh interface.

In the second case the Python program runs of the PC

and only the I/O to the sensors or LEDs happen through the daemon.

---+++ 
---+ Shades of Colors

To see 255 different shades of red, this is what we need to do:

Of course you can do the same thing for green and blue shades

or for any combination of the colors

<img alt="shadesOfColor.png" height="499" src="%ATTACHURL%/shadesOfColor.png" title="shadesOfColor.png" width="372" />

---+++ 
---+ Intermediate Colors, PWM

How can we get a finer definition of colors is each of the LEDs

can only be driven by binary signals?

The answer is pwm: pulse width modulation.

The signal to the LEDs is sent a a high frequency where the switching is invisible to the human eye.

The duty-cycle determines the current flowing through the LED and thus the color.

It can easily be seen that with respect to a permanent “1”

a pwm signal with 50% duty-cycle produces on average only ½ of the current

<img alt="pwm.png" height="446" src="%ATTACHURL%/pwm.png" title="pwm.png" width="650" />

---+++ 
---+ Color and Distance Sensor

Reading the HC-SR04 ultra-sonic distance sensor and the TCS3200 color sensor

is much more complex than driving the LEDs

However, we are lucky:

There are Python classes supporting these devices written for us by experienced Python programmers.

These classes come with example code showing how to use the class methods.

Of course we can just use the code. It is however much better to try and understand the code before using it.

Reading code written by expert programmers can help us to substantially improve our own programming skills.

---+++ 
---+ The Ultra-Sonic Distance Sensor

We can consider the sensor as a loudspeaker and microphone. These are the two cylinders.

On a trigger the sensor sends an 8 cycle burst of ultra-sound (40 kHz)

It then reads the echo and generates a pulse whose length is proportional to the signal travel time.<br /><img alt="distanceSensor.png" src="%ATTACHURL%/distanceSensor.png" title="distanceSensor.png" />

---+++ 
---+ The HC-04 distance sensor

<img alt="hc-sr04Timing.png" height="325" src="%ATTACHURL%/hc-sr04Timing.png" title="hc-sr04Timing.png" width="764" />

---+++ 
---+ HC-SR04 Signal Connections
| Vcc | 5V |
| Trig | GPIO 5 |
| Echo | GPIO 6 via level converter |
| GND | GND |
We create a 10 &mu;s pulse on the Trig pin, setting gpio pin 5 to HIGH,

wait for 10 &mu;s and setting it low again.

Then we read the time at which the Echo signal becomes high and when it becomes low again.

The time difference corresponds to the sound travel time.

Since we know that the

*speed of sound in air is ~ 343 m/s*

the distance the sound wave has traveled is distance = 34300/2 * signalLength [cm]

(the factor 2 comes from the fact that the wave travels from the loudspeaker

to the paper and back to the microphone, which is twice the distance)

---+++ 
---+ Level converter

The HC-SR04 and the TCS3200 work on 5V with 5 V logic levels while

the Raspberry Pi works with 3.3V logic levels.

This is ok for Raspberry Pi output signals. The correct logic level is seen by the sensors.

However, the input signals to the Raspberry Pi must be converter to 3.3V,

which can be done with a resistor voltage divider or with a level shifter:

On the B side we provide 5V signals which are converted to 3.3V on the A side

Both sides need Vcc (side B: 5V, side A: 3.3V) and GND

<img alt="levelConverter.png" height="440" src="%ATTACHURL%/levelConverter.png" title="levelConverter.png" width="498" />

---+++ 
---+ The HC-SR04 code, init

<img alt="hc-sr04Init.png" height="285" src="%ATTACHURL%/hc-sr04Init.png" title="hc-sr04Init.png" width="663" />

---+++ 
---+ The HC-SR04 code, loop

<img alt="hc-sr04Loop.png" height="329" src="%ATTACHURL%/hc-sr04Loop.png" title="hc-sr04Loop.png" width="455" />

---+++ 
---+ Timeout

There is a problem with the code:<br /><br /><img alt="timeout.png" height="77" src="%ATTACHURL%/timeout.png" title="timeout.png" width="384" /><br /><br />Raspbian is a multi-tasking system, treating a large number of interrupts.

What can happen when an interrupt is treated while our program is waiting for a transition?

We may wait forever! The program gets blocked!

There are 2 ways to treat this:

   * use timeouts: make sure that the time since we started waiting<br /><br />for the transition does not exceed a predefined max. value
   * use callbacks
---+++ 
---+ Callbacks

We can define a Python function (the callback function) and tell pigpio to call this function

when a transition appears on a gpio pin.

<img alt="callbacks.png" height="355" src="%ATTACHURL%/callbacks.png" title="callbacks.png" width="667" />

---+++ 
---+ The TCS3200 color sensor

The TCS3200 color sensor module is mounted on a GY-31 PCB.

<img alt="tcs3200.png" height="347" src="%ATTACHURL%/tcs3200.png" title="tcs3200.png" width="385" />

The color sensor is based on color-light to frequency converters

where the light intensity is proportional to the frequency.

It contains an array of 8*8 photo-diodes:

16 photo-diodes have red, 16 others have green,

another 16 have blue filters and 16 have no filter.

Here is the [[http://www.mouser.com/catalog/specsheets/TCS3200-E11.pdf][TC3200 data sheet ]]

---+++ 
---+ TCS3200 functional diagram

<img alt="tcs3200Diagram.png" height="257" src="%ATTACHURL%/tcs3200Diagram.png" title="tcs3200Diagram.png" width="846" />

---+++ 
---+ Pin-out of the GY-31 board

<img alt="tcs3200PinOut.png" height="143" src="%ATTACHURL%/tcs3200PinOut.png" title="tcs3200PinOut.png" width="383" />

Vcc and GND are the power connections

LED allows to switch the while LEDs on and off (active low)

S0 & S1 are frequency scaling controls

S2 & S3 select the color component:<br /><br />
   * 0: red
   * 1: blue
   * 2: clear
   * 3: green

The output frequency is typically 4.5 V and must be connected to the

Raspberry Pi through a level converter transforming the signal to 3.3V

---+++ 
---+ TCS3200 connections

This is how we connect the TCS3200 to the Raspberry Pi.

We need female to male breadboard cables to accomplish this.

<img alt="tcs3200ToRPI.png" height="198" src="%ATTACHURL%/tcs3200ToRPI.png" title="tcs3200ToRPI.png" width="438" />

---+++ 
---+ The TCS3100 class, Initialization

<img alt="tcs3200CreateInstance.png" height="457" src="%ATTACHURL%/tcs3200CreateInstance.png" title="tcs3200CreateInstance.png" width="711" />

---+++ 
---+ Defining the GPIO pins

<img alt="tcs3200Gpio.png" height="379" src="%ATTACHURL%/tcs3200Gpio.png" title="tcs3200Gpio.png" width="516" />

---+++ 
---+ Setting up the Callbacks

The callback routine is executed when
there is a rising edge on the OUT pin (frequency corresponding to the color intensity)
there is a change in signal level on S2 or S3 selecting the color filters

---+++ 
---+ The Callback Function
| <img alt="tcs3200CallbackFunction.png" height="392" src="%ATTACHURL%/tcs3200CallbackFunction.png" title="tcs3200CallbackFunction.png" width="526" /> | <img alt="tcs3200FilterCodes.png" height="131" src="%ATTACHURL%/tcs3200FilterCodes.png" title="tcs3200FilterCodes.png" width="353" /> |

---+++ 
---+ Switching the LEDs on and off

Normally the 4 white LEDs on the board should be on to reflect their light on the colored paper

and measure the color components on the sensor.

Nevertheless it may be interesting to to able to switch off the LEDs once the color sensor

is not used any more.

<img alt="ledsOnOff.png" height="122" src="%ATTACHURL%/ledsOnOff.png" title="ledsOnOff.png" width="315" />

---+++ 
---+ Strategy to read the rgb Values

To read the rgb values we must set the color filters and then read

the out frequency for the corresponding color component. This is done for <br /><br />
   * the red component (S2,S3 = 0,0)
   * the blue component (S2,S3 = 0,1)
   * and the green component (S2,S3 = 1,1)
   * finally the clear component (S2,S3 = 1,0)
As you can see only a single GPIO line changes when switching filters in this sequence

---+++ 
---+ Switching the filters

<img alt="switchFilters.png" height="358" src="%ATTACHURL%/switchFilters.png" title="switchFilters.png" width="615" />

%SLIDESHOWEND%

-- %USERSIG{UliRaich - 2018-04-25}%

---++ Comments

%COMMENT%

Attachments

Topic attachments
I	Attachment	History	Action	Size	Date	Who
png	callbacks.png	r1	manage	41.5 K	2018-04-25 - 15:23	UliRaich
png	cobbler.png	r1	manage	23.8 K	2018-04-25 - 13:20	UliRaich
png	cobblerBreadboard.png	r1	manage	220.2 K	2018-04-25 - 13:24	UliRaich
png	cobblerPinout.png	r1	manage	281.5 K	2018-04-25 - 13:20	UliRaich
png	commonAnode.png	r1	manage	23.8 K	2018-04-25 - 13:07	UliRaich
png	commonCathode.png	r1	manage	23.6 K	2018-04-25 - 13:07	UliRaich
png	distanceSensor.png	r1	manage	180.7 K	2018-04-25 - 13:55	UliRaich
png	eightColors-1.png	r1	manage	19.5 K	2018-04-25 - 13:41	UliRaich
png	eightColors-2.png	r1	manage	35.5 K	2018-04-25 - 13:41	UliRaich
png	hc-sr04Init.png	r1	manage	41.9 K	2018-04-25 - 14:06	UliRaich
png	hc-sr04Loop.png	r1	manage	32.7 K	2018-04-25 - 14:06	UliRaich
png	hc-sr04Timing.png	r1	manage	92.0 K	2018-04-25 - 13:57	UliRaich
png	ledsOnOff.png	r1	manage	8.9 K	2018-04-25 - 15:52	UliRaich
png	levelConverter.png	r1	manage	162.1 K	2018-04-25 - 14:06	UliRaich
png	lilyPad.png	r1	manage	155.3 K	2018-04-25 - 13:05	UliRaich
png	pigpioDoc.png	r1	manage	293.0 K	2018-04-25 - 13:32	UliRaich
png	pwm.png	r1	manage	65.6 K	2018-04-25 - 13:51	UliRaich
png	shadesOfColor.png	r1	manage	35.6 K	2018-04-25 - 13:45	UliRaich
png	smdRgbLed.png	r1	manage	152.4 K	2018-04-25 - 13:05	UliRaich
png	standardLed.png	r1	manage	151.6 K	2018-04-25 - 13:06	UliRaich
png	switchFilters.png	r1	manage	49.2 K	2018-04-25 - 15:52	UliRaich
png	tcs3200.png	r1	manage	157.0 K	2018-04-25 - 15:27	UliRaich
png	tcs3200CallbackFunc.png	r1	manage	32.3 K	2018-04-25 - 15:52	UliRaich
png	tcs3200CallbackFunction.png	r1	manage	32.3 K	2018-04-25 - 15:39	UliRaich
png	tcs3200CreateInstance.png	r1	manage	54.3 K	2018-04-25 - 15:39	UliRaich
png	tcs3200Diagram.png	r1	manage	41.2 K	2018-04-25 - 15:29	UliRaich
png	tcs3200FilterCodes.png	r1	manage	9.4 K	2018-04-25 - 15:57	UliRaich
png	tcs3200Gpio.png	r1	manage	31.2 K	2018-04-25 - 15:39	UliRaich
png	tcs3200PinOut.png	r1	manage	6.1 K	2018-04-25 - 15:33	UliRaich
png	tcs3200ToRPI.png	r1	manage	12.5 K	2018-04-25 - 15:39	UliRaich
png	timeout.png	r1	manage	10.1 K	2018-04-25 - 14:11	UliRaich
png	ws2812.png	r1	manage	157.8 K	2018-04-25 - 13:06	UliRaich

Topic revision: r2 - 2018-04-25 - UliRaich