Slide 1

Slide 1 text

1 / 74 Sensors & Actuators Selected I/Os Eueung Mulyana https://eueung.github.io/012017/inout CodeLabs | Attribution-ShareAlike CC BY-SA

Slide 2

Slide 2 text

Outline Preparation Light/Laser Sensor PIR Sensor LM35 & DHT11 Processing & Local Visualization Ultrasonic Sensor 2 / 74

Slide 3

Slide 3 text

Preparation 3 / 74

Slide 4

Slide 4 text

Preparation Notes We reuse the previous nRF24L01+ example (Simple Remote Control) with some changes i.e.: for simplicity both nodes are now Nano-based, an LCD is attached to Node-2 for a better communication and debugging experience. In the next examples, the switch will be replaced with laser and PIR sensors. 4 / 74

Slide 5

Slide 5 text

5 / 74 I2C LCD1602 An LCD display that can display a max of 16x2 characters. As the pin resources of ucontroller is limited, your project may be not able to use normal LCD shield after connected with a certain quantity of sensors/actuators i.e. if you are doing more than a simple project, you may be out of pins using a normal LCD shield. With this I2C interface LCD module, you only need 2 lines (I2C) to display information. Interface: connect the I2C LCD1602 to the I2C port of Arduino (SDA - A4 and SCL - A5) and power this module with 5V. Ref: arduino-info, elecrow

Slide 6

Slide 6 text

Node-1 & Node-2 (Both with nRF24L01+) 6 / 74

Slide 7

Slide 7 text

Node-1 (Remote Switch / Sensor Node) 7 / 74

Slide 8

Slide 8 text

Node-2 (Display Node) 8 / 74

Slide 9

Slide 9 text

Node-1 9 / 74

Slide 10

Slide 10 text

Node-2 10 / 74

Slide 11

Slide 11 text

Install I2C LiquidCrystal Library 11 / 74

Slide 12

Slide 12 text

#include #include "nRF24L01.h" #include "RF24.h" RF24 myRadio (7, 8); const int SW1 = 5; const int SW2 = 6; byte addresses[][6] = {"1Node"}; int dataTransmitted; int button1; int button2; void setup() { pinMode(SW1, INPUT); pinMode(SW2, INPUT); button1 = 0; button2 = 1; dataTransmitted = 10; Serial.begin(115200); delay(1000); myRadio.begin(); myRadio.setRetries(0,15); myRadio.setChannel(108); myRadio.setPALevel(RF24_PA_MAX); myRadio.openWritingPipe( addresses[0]); delay(1000); } void loop() { int newButton = digitalRead(SW1); if (newButton != button1) { button1 = newButton; if (button1 == HIGH){ dataTransmitted = 20; } 12 / 74 Node-1

Slide 13

Slide 13 text

#include #include "nRF24L01.h" #include "RF24.h" RF24 myRadio (7, 8); byte addresses[][6] = {"1Node"}; int dataReceived; const int LED = 2; #include #include LiquidCrystal_PCF8574 lcd(0x27); int lcdexist; unsigned long started_waiting_at = 0; bool bklight = false; void setup() { pinMode(LED, OUTPUT); Serial.begin(115200); delay(1000); myRadio.begin(); myRadio.setAutoAck(1); myRadio.setChannel(108); myRadio.setPALevel(RF24_PA_MAX); myRadio.openReadingPipe(1, addresses[0]); myRadio.startListening(); Wire.begin(); Wire.beginTransmission(0x27); lcdexist = Wire.endTransmission(); lcd.begin(16, 2); } void loop() { 13 / 74 Node-2

Slide 14

Slide 14 text

Switch ON 14 / 74

Slide 15

Slide 15 text

Switch OFF 15 / 74

Slide 16

Slide 16 text

Light/Laser Sensor 16 / 74

Slide 17

Slide 17 text

Laser Mini Transmitter & Receiver Module 17 / 74

Slide 18

Slide 18 text

Light/Laser Receiver Module Utilizing LDR and Voltage Comparator for Digital Output 18 / 74

Slide 19

Slide 19 text

19 / 74 LDR LDR or Light Dependent Resistor (sometimes called a photoresistor or photocell) is a two-terminal, resistive component that increases or decreases its resistance depending on the light it senses. An LDR initially has a very high resistance. But, as light falls on it, the resistance will drop, allowing more current through. Ref: Earthshine Design

Slide 20

Slide 20 text

20 / 74 LDR Sensor Module LDR sensor module is used to detect the intensity of light. It might have both analog output pin and digital output pin labelled as AO and DO respectively on the board. When there is light, the resistance of LDR will become low according to the intensity of light. The greater the intensity of light, the lower the resistance of LDR. The sensor has a potentiometer knob that can be adjusted to change the sensitivity of LDR towards light. Ref: LDR Sensor Module

Slide 21

Slide 21 text

Switch Replacement with a Laser Receiver 21 / 74

Slide 22

Slide 22 text

Switch Replacement with a Laser Receiver 22 / 74

Slide 23

Slide 23 text

PIR Sensor 23 / 74

Slide 24

Slide 24 text

24 / 74 PIR Sensor A PIR (Passive Infra-Red) sensor is an electronic sensor that measures infrared light radiating from objects in its eld of view. Normally this type of sensor would be used as a motion or proximity sensor. Quite often they are referred to as: PIR, Motion, Proximity, or Pyroelectric sensor. The sensor in the PIR detects or "reads" infrared radiation "emitted" from objects all around us. Each object with a temperature above absolute zero will radiate infrared, even us humans, and even though we mere humans cannot see this. Note that the PIR just uses a relatively simple sensor - it is most de nitely not an IR camera! Ref: Testing and Playing with PIR sensors @Tweaking4All

Slide 25

Slide 25 text

Switch Replacement with a PIR Sensor 25 / 74

Slide 26

Slide 26 text

LM35 & DHT11 26 / 74

Slide 27

Slide 27 text

LM35 & DHT11 27 / 74

Slide 28

Slide 28 text

28 / 74 LM35 LM35 is a linear temperature sensor with the output voltage calibrated in centigrade celsius. 1 degree celsius makes an output voltage of 10mV. So when you have room temperature at 22C the LM35 gives you a voltage of 220mV = 0.22V. The sensor has only 3 pins: VCC which can be between +4V and +20V, GND and Vout. Vout has to be connected to one of the analog inputs and that's all - in most cases. Ref: connecting an arduino with a LM35 temperature sensor @heliosoph

Slide 29

Slide 29 text

29 / 74 DHT11 DHT11 is a temperature and humidity sensor with a calibrated digital signal output. The DHT11 sensor has four pins. Connect the rst pin on left of sensor ('VCC') to 5V of your board, the second pin ('Data') to a digital pin and the fourth pin ('GND') to ground. When the connecting cable is shorter than 20m, a 5K pull-up resistor between the second Pin of sensor and 5V is recommended. Ref: DHT11 Temperature and Humidity Sensor Example @arduino.org

Slide 30

Slide 30 text

Install Library for DHTxx Sensors 30 / 74

Slide 31

Slide 31 text

float tlm35; void setup() { Serial.begin(9600); //analogReference(INTERNAL); } void loop() { tlm35 = 0.0; for(int j = 0; j < 10; j++) { tlm35 += analogRead(A0); delay(20); } tlm35 = tlm35 * 5.0 * 10.0 / 1023.0; //tlm35 = tlm35 * 1.1 * 10.0 / 1023.0; Serial.println(tlm35); } 31 / 74 LM35

Slide 32

Slide 32 text

#include "DHT.h" #define DHTPIN 3 #define DHTTYPE DHT11 DHT dht(DHTPIN, DHTTYPE); void setup() { Serial.begin(9600); dht.begin(); } void loop() { delay(2000); // Reading temperature or humidity takes about 250 milliseconds! // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor) float h = dht.readHumidity(); float t = dht.readTemperature(); if (isnan(h) || isnan(t)) { Serial.println("Failed to read from DHT sensor!"); return; } Serial.println(t); } 32 / 74 DHT11

Slide 33

Slide 33 text

Local Visualization & UI Processing 33 / 74

Slide 34

Slide 34 text

34 / 74 Processing Processing is a exible software sketchbook and a language for learning how to code within the context of the visual arts. Since 2001, Processing has promoted software literacy within the visual arts and visual literacy within technology. There are tens of thousands of students, artists, designers, researchers, and hobbyists who use Processing for learning and prototyping. Ref: Processing.org

Slide 35

Slide 35 text

35 / 74 Processing is an open source language/ development tool for writing programs in other computers. Useful when you want those other computers to talk with an Arduino, for instance to display or save some data collected by the Arduino. How to Work with Processing? Write Arduino sketch as usual, except for input/output intended to be retrieved from or sent to Processing Write Processing program that receives/sends data from/to Arduino If you just want to control an Arduino board from a Processing program, you may want to use the Arduino Library for Processing. Ref: Arduino Playground - Processing

Slide 36

Slide 36 text

Switch Example Ref: Electronics @Processing.org 36 / 74

Slide 37

Slide 37 text

int switchPin = 5; void setup() { pinMode(switchPin, INPUT); Serial.begin(9600); delay(1000); } void loop() { if (digitalRead(switchPin) == HIGH) { //Serial.println(1); Serial.write(1); } else { //Serial.println(0); Serial.write(0); } delay(100); } 37 / 74 Arduino

Slide 38

Slide 38 text

import processing.serial.*; Serial port; int val; String stext; void setup() { size(200, 200); frameRate(10); port = new Serial(this, "/dev/ttyUSB0", 9600); } void draw() { if (0 < port.available()) { val = port.read(); } background(255); if (val == 0) { fill(0); stext = "OFF"; } else { fill(255,0,0); stext = "ON"; } rect(50, 50, 100, 100); textAlign(CENTER); textSize(30); fill(255); text(stext, 100, 112); } 38 / 74 Processing

Slide 39

Slide 39 text

Using Arduino IDE Serial Plotter 39 / 74

Slide 40

Slide 40 text

Using Arduino IDE Serial Plotter 40 / 74

Slide 41

Slide 41 text

Controlling a Servo Ref: Electronics @Processing.org 41 / 74

Slide 42

Slide 42 text

Micro Servo Tower Pro SG90 42 / 74

Slide 43

Slide 43 text

#include Servo myservo; int servoPin = 4; int val = 0; void setup() { myservo.attach(servoPin); Serial.begin(9600); } void loop() { if (Serial.available()) { val = Serial.read(); } myservo.write(val); delay(15); } 43 / 74 Arduino

Slide 44

Slide 44 text

import processing.serial.*; Serial port; float mx = 0.0; void setup() { size(200, 200); noStroke(); frameRate(10); port = new Serial(this, "/dev/ttyUSB0", 9600); } void draw() { background(0); fill(204); rect(40, height/2-15, 120, 25); float dif = mouseX - mx; if (abs(dif) > 1.0) { mx += dif/4.0; } mx = constrain(mx, 50, 149); noStroke(); fill(255); rect(50, (height/2)-5, 100, 5); fill(204, 102, 0); rect(mx-2, height/2-5, 4, 5); int angle = int(map(mx, 50, 149, 0, 180)); port.write(angle); } 44 / 74 Processing

Slide 45

Slide 45 text

Arduino Built-In Example - Graph 45 / 74

Slide 46

Slide 46 text

void setup() { Serial.begin(9600); } void loop() { Serial.println(analogRead(A0)); // wait a bit for the analog-to-digital converter // to stabilize after the last reading: delay(2); } 46 / 74 Arduino

Slide 47

Slide 47 text

import processing.serial.*; Serial myPort; // The serial port int xPos = 1; // horizontal position of the graph float inByte = 0; void setup () { size(400, 300); myPort = new Serial(this, "/dev/ttyUSB0", 9600); myPort.bufferUntil('\n'); background(0); } void draw () { stroke(127, 34, 255); line(xPos, height, xPos, height - inByte); if (xPos >= width) { xPos = 0; background(0); } else { xPos++; } } void serialEvent (Serial myPort) { String inString = myPort.readStringUntil('\n'); if (inString != null) { inString = trim(inString); inByte = float(inString); println(inByte); inByte = map(inByte, 0, 1023, 0, height); //inByte = map(inByte, 0, 100, 0, height); } } 47 / 74 Processing

Slide 48

Slide 48 text

Circuit & Processing Plot 48 / 74

Slide 49

Slide 49 text

HC-SR04 Ultrasonic Sensor 49 / 74

Slide 50

Slide 50 text

50 / 74 Ultrasonic Sensor HC-SR04 ultrasonic ranging sensor provides 2cm to 400cm of non-contact measurement functionality with a ranging accuracy that can reach up to 3mm. It is a very a ordable proximity/distance sensor that has been used mainly for object avoidance in various robotics projects. Each HC-SR04 module includes an ultrasonic transmitter, a receiver and a control circuit. It has 4 pins: VCC, GND, Trigger and Echo pin.

Slide 51

Slide 51 text

Install Arduino NewPing Library 51 / 74

Slide 52

Slide 52 text

Install Processing gra ca Library 52 / 74

Slide 53

Slide 53 text

NewPing Example 53 / 74

Slide 54

Slide 54 text

#include #define TRIGGER_PIN 3 #define ECHO_PIN 4 #define MAX_DISTANCE 300 NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); void setup() { Serial.begin(9600); } void loop() { delay(500); Serial.println(sonar.ping_cm()); } 54 / 74 Arduino

Slide 55

Slide 55 text

import grafica.*; import processing.serial.*; GPlot plot; int i = 0; int points = 100; public float[] values; Serial myPort; float inByte = 0; void setup(){ size (900,450); myPort = new Serial(this, "/dev/ttyUSB0", 9600); GPointsArray points1 = new GPointsArray(points); values = new float[points]; for (i = 0; i < points; i++) { points1.add(i,0); values[i]=0; } plot = new GPlot(this); plot.setPos(25, 20); plot.setDim(750, 310); plot.setXLim(0, points); plot.setYLim(0, 310); plot.setTitleText("Distance"); plot.getXAxis().setAxisLabelText("Sample Time"); plot.getYAxis().setAxisLabelText("cm"); plot.setPoints(points1); } void draw() { background(150); GPointsArray points1 = new GPointsArray(points); for (i = 0; i < values.length; i++) { 55 / 74 Processing

Slide 56

Slide 56 text

Processing Plot with gra ca Library 56 / 74

Slide 57

Slide 57 text

#include #include #define TRIGGER_PIN 3 #define ECHO_PIN 4 #define MAX_DISTANCE 300 Servo myservo; int servoPin = 5; int val = 0; NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); void setup() { myservo.attach(servoPin); Serial.begin(9600); } void loop() { val = analogRead(A0); val = map(val, 0, 1023, 0, 180); myservo.write(val); //delay(15); delay(500); Serial.println(sonar.ping_cm()); } Rotating SR04 with a Servo - Manually via a Potentiometer 57 / 74 Arduino

Slide 58

Slide 58 text

#include #include #define TRIGGER_PIN 3 #define ECHO_PIN 4 #define MAX_DISTANCE 300 Servo myservo; int servoPin = 5; int val = 0; int lastval = 0; unsigned long timer; NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); void setup() { myservo.attach(servoPin); Serial.begin(9600); timer = millis(); } void loop() { val = analogRead(A0); val = map(val, 0, 1023, 0, 180); int dif = val - lastval; if(abs(dif)>1) { val = lastval + dif/4; } myservo.write(val); lastval = val; delay(15); if((millis()-timer)>500) { Serial.println(sonar.ping_cm()); timer = millis(); } } Rotating SR04 with a Servo - Try this too! 58 / 74 Arduino

Slide 59

Slide 59 text

HC-SR04 + SG90 59 / 74

Slide 60

Slide 60 text

SR04 Sonar Our previous case can be rearranged to make a simple DIY Sonar (SOund Navigation And Ranging) system. The following example was modi ed from Dejan Nedelkovski's code. 60 / 74

Slide 61

Slide 61 text

61 / 74

Slide 62

Slide 62 text

#include #include #define TRIGGER_PIN 3 #define ECHO_PIN 4 #define MAX_DISTANCE 300 Servo myservo; int servoPin = 5; const int angle_start = 5; const int angle_end = 175; const int delaytime = 20; NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); void setup() { myservo.attach(servoPin); Serial.begin(9600); } void loop() { for(int i=angle_start;i<=angle_end;i++){ myservo.write(i); delay(delaytime); Serial.print(i); Serial.print(","); Serial.print(sonar.ping_cm()); Serial.print("."); } for(int i=angle_end;i>angle_start;i--){ myservo.write(i); delay(delaytime); Serial.print(i); Serial.print(","); Serial.print(sonar.ping_cm()); Serial.print("."); } } 62 / 74 Arduino

Slide 63

Slide 63 text

String distance=""; String data=""; String noObject; float pixsDistance; int iAngle, iDistance; int index1=0; int index2=0; final float MAX_DIST = 300; //------------------------------------------------- void setup() { size(1200, 700); smooth(); myPort = new Serial(this, "/dev/ttyUSB0", 9600); myPort.bufferUntil('.'); orcFont = loadFont("OCRAExtended-30.vlw"); } //------------------------------------------------- void draw() { float covered_height = height*0.935; noStroke(); fill(0,4); rect(0, 0, width, covered_height); fill(98,245,31); textFont(orcFont); drawRadar(); drawLine(); drawObject(); drawText(); } //------------------------------------------------- void serialEvent (Serial myPort) { data = myPort.readStringUntil('.'); data = data.substring(0,data.length()-1); index1 = data.indexOf(","); angle= data.substring(0, index1); distance= data.substring(index1+1, data.length()); 63 / 74 Processing

Slide 64

Slide 64 text

Tools | Create Font 64 / 74

Slide 65

Slide 65 text

Tools | Create Font 65 / 74

Slide 66

Slide 66 text

66 / 74 drawRadar()

Slide 67

Slide 67 text

67 / 74 drawText()

Slide 68

Slide 68 text

68 / 74 drawRadar() drawText()

Slide 69

Slide 69 text

69 / 74 drawLine()

Slide 70

Slide 70 text

70 / 74 drawObject()

Slide 71

Slide 71 text

71 / 74

Slide 72

Slide 72 text

Refs/Resources 72 / 74

Slide 73

Slide 73 text

Refs/Resources 1. LDR Sensor Module Interface With Arduino 2. Using a Photocell @Adafruit 3. Photoresistor @ElectroSchematics 4. Testing and Playing with PIR sensors @Tweaking4All 5. Arduino Playground - Processing 6. Processing Foundation 7. Electronics - Processing.org 8. Typography, Strings and Drawing Text 9. Arduino library for DHT11DHT22, etc Temp & Humidity Sensors 10. A simple and con gurable plotting library for Processing 11. Clipart - Strain Gauge 73 / 74

Slide 74

Slide 74 text

74 / 74 END Eueung Mulyana https://eueung.github.io/012017/inout CodeLabs | Attribution-ShareAlike CC BY-SA