Arduino Photoresistor Guide

חיישן נוסף שחשוב להכיר הוא ה Photoresistor שמאפשר למדוד את עוצמת האור, את שלי קניתי בחנות האלקטרוניקה שקרובה לביתי אבל ניתן למצוא אותו ב DX במחיר מצחיק של מספר שקלים בודדים, על הדרך לקחתי גם Speaker ישן שמגיע עם כל לוח אם והחלטתי לחבר בניהם, כאשר עוצמת האור יורדת מערך מסויים ה Speaker מתחיל לצפצף, בדומה לתאורת חצר שנדלקת כאשר יורד הלילה.

דרישות

• Arduino UNO
• Photoresistor
• 10k Resistor
• PC Speaker
• BreadBorad
• Wires

Photoresistor

בגדול זה נגד שמשנה את התנגדות שלו לפי האור, הוא מאוד זול וחסכוני אבל לא כל כך מדויק, בסה"כ יש לו 2 רגלים, רגל אחת מחברים ל 5 V ואת הרגל השניה מפצלים לרגל אחת שמתחברת ל Analog Input והשניה מתחברת ל 10K Resistor שמתחבר ל GND.

קוד

#define speakerPin 2

#define lightPin 1

int photocellReading = 0;

void playTone(int tone, int duration) {

  for (long i = 0; i < duration * 1000L; i += tone * 2) {

    digitalWrite(speakerPin, HIGH);

    delayMicroseconds(tone);

    digitalWrite(speakerPin, LOW);

    delayMicroseconds(tone);

  }

}

void setup() {

  Serial.begin(9600);

  pinMode(speakerPin, OUTPUT);

}

void loop() {

    getLight();

    //if light level lower play sound

    if(photocellReading < 100)

          //send different number to change tone

          playTone(1915,300);

    delay(300); 

}

void getLight()

{

  //reading the light level from analog input

  photocellReading = analogRead(lightPin);  

  Serial.print(photocellReading);

  Serial.print("\n");

}

מבנה סופי

מצפצף כאשר עוצמת האור יורדת

סרט הדגמה

סיכום

השנה קרובה לסופה , זאת היתה שנה עמוסה במאמרים בתחומים שונים וגם השנה Arduino כיכב בבלוג, במהלך השנה באה ניקח אותו לקצה ונבנה פרויקטים מורכבים יותר.

בהצלחה...

Android OpenGL And Gyroscope

אחרי שהכרנו כיצד לבנות ולצבוע אובייקטים השלב הבא הוא תנועה במרחב של המנוע אבל לפני שניכנס לכפתורים ולממשק המשתמש נתחיל דווקא עם החיישנים שנמצאים בכל מכשיר מתקדם, אבל חשוב לזכור שהם משתנים ממכשיר למכשיר ולא זמינים בכולם.

שימו לב! - המאמר מתבסס על Samsung Galaxy S3 שבו יש Gyroscope מובנה.

Gyroscope

http://en.wikipedia.org/wiki/Gyroscope

מכשיר מדידה שמאפשר לחשב את זווית הסטייה כאשר הגוף לא במצב אופקי, כלומר כל הטיה של המכשיר תשנה את המיקום על 3 הצירים התלת מימדיים (X,Y,Z),  על מנת להפעיל אותו ב Android עלינו להשתמש במספר מחלקות שיעשנו לנו את העבודה עבור כל החיישנים שנראה במאמרים הבאים:

private SensorManager mSensorManager;
private Sensor mSensor;

אובייקטים שמייצגים את החיישנים.

mSensorManager = (SensorManager)con.getSystemService(Context.SENSOR_SERVICE);

mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

מבקשים  את השירות של החיישנים במערכת, מתחברים לחיישן ספציפי שבמקרה שלנו הוא ה Gyroscope אבל ניתן לקבל חיישנים נוספים כמו: Accelerometer, Ambient Temperature,Gravity ועוד (לרשימה המלאה).

לאחר מכן מתחברים ל Event של החיישן בעזרת SensorEventListener ודוגמים אותו, השתמשתי בהגדרה קיימת במערכת שמתאימה למשחקים ודוגמת את החיישן כל 20 ms.

mSensorManager.registerListener(new SensorEventListener() {

@Override

public void onSensorChanged(SensorEvent event) {

// TODO Auto-generated method stub

}

@Override

public void onAccuracyChanged(Sensor sensor, int accuracy) {

// TODO Auto-generated method stub

}

}, mSensor, SensorManager.SENSOR_DELAY_GAME);

OpenGL

אחד השינויים הוא בפונקציה Draw של האובייקט שמוכרת מהמאמרים האחרונים בנושא, נוספו 3 פרמטרים עבור X,Y,Z שאותם נשלח ל OpenGL בעזרת הפונקציה glTranslatef.

public void draw(float x,float y,float z)

{

//set gl focus to cube

gl.glLoadIdentity();

gl.glTranslatef(x, y, z);

   //...

}

קוד

דגימת החיישן מתבצעת ה GLSurfaceView.Renderer בעזרת EventListener שממתין לאירוע מהחיישן ומעדכן פרמטרים גלובלים במחלקה שנשלחים אח"כ לפונקציה Draw של האובייקט.

package com.example.openglgyroscope;

import java.text.DecimalFormat;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.hardware.Sensor;

import android.hardware.SensorEvent;

import android.hardware.SensorEventListener;

import android.hardware.SensorManager;

import android.opengl.GLSurfaceView;

import android.opengl.GLU;

public class OpenGLSensorRender implements GLSurfaceView.Renderer  {

private CubeNaked mCube;

//remember the last values of the Axis

private float mLastX = 0, mLastY = 0, mLastZ = 0;

Context con;

private SensorManager mSensorManager;

private Sensor mSensor;

public OpenGLSensorRender(Context _con)

{

con = _con;

mSensorManager = (SensorManager)con.getSystemService(Context.SENSOR_SERVICE);

mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

mSensorManager.registerListener(new SensorEventListener() {

@Override

public void onSensorChanged(SensorEvent event) {

//taking sample from the sensor

DecimalFormat _fp = new DecimalFormat("#.#");

float x = Float.valueOf( _fp.format(event.values[0]));

float y = Float.valueOf( _fp.format(event.values[1]));

float z = Float.valueOf( _fp.format(event.values[2]));

mLastX = mLastX + x;

mLastY = mLastY+ y;

   //not in use for now

//mLastZ = z;

}

@Override

public void onAccuracyChanged(Sensor sensor, int accuracy) {}

}, mSensor, SensorManager.SENSOR_DELAY_GAME);

}

@Override

public void onDrawFrame(GL10 gl) {

gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

//draw the cube ,sending the new axis

mCube.draw(mLastX,mLastY,mLastZ);

}

@Override

public void onSurfaceChanged(GL10 gl, int width, int height) {

// TODO Auto-generated method stub

//enter to Perspective Projection Mode Settings

gl.glViewport(0, 0, width, height);

gl.glMatrixMode(GL10.GL_PROJECTION);

gl.glLoadIdentity();

GLU.gluPerspective(gl, 45.0f, (float) width / (float) height, 0.1f,

100.0f);

gl.glViewport(0, 0, width, height);

//enter to ModelView Projection Mode Settings

gl.glMatrixMode(GL10.GL_MODELVIEW);

gl.glLoadIdentity();

}

@Override

public void onSurfaceCreated(GL10 gl, EGLConfig arg1) {

// TODO Auto-generated method stub

//clear the suraface color to black

gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);

gl.glClearDepthf(1.0f);

gl.glEnable(GL10.GL_DEPTH_TEST);

gl.glDepthFunc(GL10.GL_LEQUAL);

gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);

mCube = new CubeNaked(gl);

}

}

סרט הדגמה

קבצי מקור

https://sourceforge.net/projects/openglcomplexobject/files/openGLgyroscope.rar/download

סיכום:

עבודה עם חיישנים נפוצה מאוד במיוחד במשחקים, הם מאפשרים לנו לשלוט על האובייקטים במשחק מבלי שנצטרך לגעת במסך שגם ככה יחסית קטן וחוסכים לנו ממשק משתמש שמתלבש על המסך שעלול להסתיר חלקים מהמשחק, אבל צריך להתרגל לצורת המשחק החדשה ולא תמיד זה נוח למי שרגיל לכפתורים הסטנדרטים.

שחק איתו!

Arduino MicroSD

עד עכשיו דגמנו חיישנים והעברנו את המידע דרך החיבור הסיראלי בחזרה למשתמש אבל זה לא מספיק, נניח שיש לנו חיישן שאנחנו רוצים לנטר אותו לאורך טווח ולאסוף עליו סטטיסטיקות ,אין מספיק שטח אחסון על ה Arduino שישמור לנו את המידע ולכן צריכים שטח אחסון חיצוני, אחת הדרכים הנפוצות היא לעבוד עם MicroSD Card Module , את שלי מצאתי ב DX במחיר של 4 דולר ולצורך הדוגמה אני אשתמש בו בשביל לשמור נתונים שמגיעים מחיישן טמפרטורה.


דרישות:

• Arduino Uno
• MicroSD Module
• (MicroSD 4GB (FAT32 Limit
• TMP36
• Breadboard
• Wires

Serial Peripheral Interface

ממשק ותיק להעברת נתונים בין רכיבים בניגוד לממשק ה Uart שמורכב סה"כ מ 2 חיבורים (RX,TX) , ב SPI נדרשים 4 חיבורים לפחות על מנת להשלים את ההתחברות וניתן לחבר עוד רכיבים על אותו ממשק, לכל רכיב שתומך ב  SPI יש 4 פינים שאותם מחברים ל (Master (Arduino ובעזרתו מנתבים את המידע בין הרכיבים השונים.

• SCK - פעימת שעון מה Master.
• MISO- Master In Slave Out - מידע שעובר מה Master ל Slave.
• MOSI - Master Out Slave In - מידע שעובר מה Slave ל Master.
• CS - Chip Select - בחירת הרכיב שאיתו מדבר ה Master, כמות החיבורים משתנה ב Master לפי כמות הרכיבים.

במקרה שנרצה לשלוח מידע לרכיב ספציפי נוריד את ה Chip Select של אותו רכיב ל LOW ובשאר הרכיבים ל HIGH על מנת שהתעלמו מהמידע, ניתן לשלוח את אותו מידע גם בצורה פרללית לכל הרכיבים  כשנוריד את ה Chip Select לכולם או להפך בשביל שהתעלמו. 

Serial Peripheral Interface

ב Arduino יש מספר פינים קבועים שדרכם מבצעים את ההממשקות ל SPI אבל הם עלולים להשתנות בין הדגמים ניתן לדעת אותם במדוייק באתר הרשמי של Arduino.

קוד

התוכנית עצמה מאוד פשוטה , דוגמים את החיישן בכל שנייה, אוספים את הנתונים ורושמים אותם לכרטיס ה SDcard, משתמשים בספריה מוכנה (SD.h) שבאה עם הסביבה של ה Arduino שמנהלת את שטח אחסון ומאפשרת לעבוד עם Filesystem מסוג FAT עד לנפח 4 GB.

#include <SD.h>

int tempPin = 0;

int csPin = 10;

void setup(){

  Serial.begin(9600);

  initSD();

}

void loop(){

  //get the milivolts

  float temp  = getVoltage(tempPin);

  float Celsius = 0;

  float Fahrenheit = 0;

  //convert the milivolts to Fahrenheint

  Fahrenheit = (((temp -.5)*100)*1.8)+32;

  

  //convert Fahrenheint to Celsius

  Celsius = ((Fahrenheit - 32) * 5 ) /9;

  

  //write values to SD card

  writeSD(Celsius,Fahrenheit);

  

  delay(1000);

}

//check if the chip select available

void initSD(){

   pinMode(csPin, OUTPUT);

    if (!SD.begin(csPin)) {

    Serial.println("Load SD failed!");

  }

  Serial.println("Load SD complete.");

}

//reading the analogpin and getting 

//the milivoltages.

float getVoltage(int pin)

{

  return (analogRead(pin) * .004882814);

}

void writeSD(int Celsius, int Fahrenheit){

  

  String str = "Celsius: " + String(Celsius) + " Fahrenheit: " + String(Fahrenheit);

  

  //try to write file

  File dataFile = SD.open("log.txt", FILE_WRITE);

  if (dataFile) {

    dataFile.println(str);

    dataFile.close();

    Serial.println(str);

  }  

  else {

    Serial.println("error opening file");

  } 

  

}

מבנה סופי

סיכום

אין גבול למה שאפשר לעשות עם Arduino וראינו את זה לאורך כל המאמרים בנושא, שטח אחסון הוא דבר קריטי במקרה שנרצה לאסוף מידע לאורך זמן והפתרון עם MicroSD בהחלט עושה את העבודה ונותן לנו אפשרויות שלא היו לפני כמו לעבוד עם קבצי הגדרות, לכתוב ולקרוא מידע ולשמור עליו לפעמים הבאות.

איזה שכלול... 

Arduino Laser Pointer Guide

אז אחרי הפסקה קצרה נחזור ל Arduino ונעבוד עם משהו חדש, הפעם מדובר על סמן לייזר , כן הדבר הזה שיורה נקודה אדומה למרחקים , שמסנוור , מעצבן וכל אמא אומרת "אל תכוון לעיניים", ניתן למצוא אותם בפשטות ברחבי האינטרנט, את שלי הזמנתי דרך DX שעלה לי רק דולר אחד בודד (אני חושב...).

דרישות:

• Arduino Uno
• Arduino Prototype Shield
• Laser Pointer
• Wires

Laser Pointer:

החיבור עצמו מאוד פשוט וסה"כ מדובר ב 2 חוטים ,הראשון נכנס ל Pin שב Arduino והשני נכנס ל GND , קיימים המון סוגים של Laser Pointer, וניתן למצוא אותם בצבעים ובסמנים שונים ,העוצמה היא החלק המסוכן ביותר ועלולה לגרום לעיוורון וכוויות (כבר אמרו פה "לא לכוון לעיניים"?).

מבנה סופי:

שלא תתבלבלו חלק מהחוטים נועדו להחזיק את החוטים של ה Laser Pointer במקום.

קוד:

//set the laser pin
int laserpin =2;

 void setup()
 {
   //set the pin mode as OUTPUT
   pinMode(laserpin,OUTPUT);

 }

 void loop()
 {
  digitalWrite(laserpin,HIGH);
  delay(500);
  digitalWrite(laserpin,LOW);
  delay(500);
 }

סיכום:

ניתן לממש עם סמני לייזר המון דברים בתחומים שונים כמו האבטחה, תאורה וכו' , אין ספק שסמני לייזר מעצבנים אבל עכשיו הם מעצבנים אוטומטית עם ה Arduino.

לא לכוון לעיניים!

Arduino Temperature Sensor

אז כמו שהבטחתי חיישנים, החיישן הבא איתו נתעסק הוא ה Temperature Sensor , אני אשתמש בחיישן TMP36 שמבוסס על חיישני Voltage Output Temperature והגדרת היצרן היא 10 Milivolts עבור מעלה אחת, בעצם אנחנו דוגמים Milivolts וממירים אותם למעלות כמו שנראה בהמשך.

דרישות

• Arduino Uno
• Arduino Prototype Shield
• TMP36
• Wires

TMP36


אז כמו שאמרתי, הדגימות של החיישן מבוססות על Milivolts כאשר 500ms הם טמפרטורת 0 ו 750ms הם 25 מעלות , נשתמש ב 2 נוסחאות הראשונה היא המרת ה Milivolts ל Fahrenheint  ואח"כ מ Fahrenheint  ל Celsius.

המרת Milivolts ל Fahrenheint:

  Fahrenheit = (((mili -.5)*100)*1.8)+32

המרת Fahrenheint ל Celsius:

  Celsius = ((Fahrenheit - 32) * 5 ) /9

וסתם בשביל הקטע המרה בין Celsius ל Fahrenheint:

  Fahrenheit  = (Celsius  * 9) /  5  + 32

מבנה סופי:

קוד: 

//set the tempertaure analog pin 
int tempin = 0;

void setup()
{
  //set serial to output
  Serial.begin(9600);

}

void loop()
{
  //get the milivolts
  float temp  = getVoltage(tempin);

  float Celsius = 0;
  float Fahrenheit = 0;

  //convert the milivolts to Fahrenheint
  Fahrenheit = (((temp -.5)*100)*1.8)+32;

  //convert Fahrenheint to Celsius;
  Celsius = ((Fahrenheit - 32) * 5 ) /9;

 //sending to print
 printme(Fahrenheit,Celsius);

  delay(5000);
}

//just printing to the serial
void printme(int Fahrenheit, int Celsius)
{
  Serial.print("Fahrenheit:");
  Serial.print(Fahrenheit);
  Serial.print(" Celsius :");
  Serial.print(Celsius);
  Serial.print("\n");
}

//reading the analogpin and getting 
//the milivoltages.
float getVoltage(int pin)
{
  return (analogRead(pin) * .004882814);
}

פלט:

סיכום:
בסדרת המאמרים האחרונה למדנו להכיר את Arduino ואת היכולות שלו, עבדנו עם 2 חיישנים , Leds וכפתורים, בשלב זה  אני אקח פסק זמן בכל הקשור ל Arduino כי יש לי עוד הרבה מה לספר לכם בנושאים אחרים ,כמובן שנחזור אליו בהמשך.

איזה חום?

Arduino UltraSonic Sensor

אחרי הסקירה הקצרה שלי על Arduino הגיע הזמן שנגע בנושא הכי מעניין מסביב Arduino והוא החיישנים,
יש המון חיישנים שניתן לחבר ל Arduino ולממש בעזרתם המון מוצרים , החלטתי לעשות את המאמר הראשון על  Ultrasonic דרך פשוטה למדוד מרחקים ולשליטה במרחב התנועה של המוצר שלנו.

דרישות:

• Arduino Uno
• Arduino Prototype Shiled
• Wires
• Ultasonic Sensor Based SDM-IO Module

Ultrasonic

אני לא מומחה גדול בעיבוד אותות אבל אנסה בכול מקרה, מדובר על גלי קול בתדר גבוה שבני אדם לא מסוגלים לשמוע, הרכיב המרכזי במערכות Sonar, החיישן שולח גל קול ומחכה לגל החוזר במקרה ולא חוזר גל הדרך פנויה או שאינה בטווח החיישן, וכאשר יש גל חוזר ניתן לחשב את המרחק שלקח לגל קול לחזור לחיישן, אחד השימושים עבור Ultrasonic הוא "עיניים" , בדיוק כמו שזה נשמע נניח שנרצה לבנות שואב אבק ביתי שהסתובב לנו בבית באופן רנדומלי ,נוכל לבצע זאת בעזרת Ultrasonic שיבדוק אם הדרך עבור השואב שלנו פנויה ובמקרה שלא שהסתובב עד שהחיישן יחזיר שהדרך חופשית.

קיימים סוגים שונים של חיישנים חלקם מגיעים עם 3 ו 4 פינים, החיישן שלי מבוסס על SDM-IO Moudle עם 4 פינים,Vcc,Trig,Echo,Gnd.

נקודות החיבור עם ה Arduino

Arduino Protoype Shield
אחד התוספות החשובות בעבודה עם Arduino מאפשר לנו לפתח אב טיפוס ע"ג ה Arduino לפני יצירת ה Sheild שלכם, ניתן למצוא אותו ברשת במחיר ממוצע של 10 דולר.

מבנה סופי:

קוד:

 //time out  waiting for signal
 #define SDM_IO_TIMEOUT 1000

 //TrigPin in Arduino
 int TrigPin = 12;

 //EchoPin in Arduino
 int EchoPin = 13;

 unsigned long ultrasoundDuration;
 int timeout;
 unsigned long tStartPing = 0;
 int sensorValue = 0;
       
           void setup() {  
                                       //init the serial
                                       Serial.begin(9600);
                                      
                                       //pins setup 
                                       pinMode(TrigPin, OUTPUT);
                                       pinMode(EchoPin, INPUT);
                                    }


             void loop()  {  
              
                                   sensorValue = read_sdm_io_range();  
                                       if(sensorValue != 999)
                                       {
                                         //printing distanse value
                                         Serial.print(sensorValue); 
                                         Serial.println(" cm"); 
                                         //delay before new sample
                                         delay(300);     
                                       }
                               
                                   }
                                  
                                  
          //SDM-IO Ultrasonic Range Sensor distance function 
          float read_sdm_io_range() {  
                                                                   
                                       unsigned char pin = 0;
                                       unsigned int time_flag = 0;
                                                                  
                                        //send HIGH signal
                                        digitalWrite(TrigPin, HIGH);
                                                                   
                                        //wait 2 microsecond
                                        delayMicroseconds(2);
                                                                   
                                        //send LOW signal
                                       digitalWrite(TrigPin, LOW);
                                                                    
                                        //wait 10 microsecond
                                        delayMicroseconds(10);
                                                                   
                                        //send HIGH signal
                                        digitalWrite(TrigPin, HIGH);
                                                                   
                                       //getting system clock
                                       tStartPing = micros();
                                       timeout = 0;
                                       pin = digitalRead(EchoPin);
                                                   
                                       while(pin)  
                                       {   
                                          //waiting for response from EchoPin
                                           //break out when timeout
                                           pin = digitalRead(EchoPin);
                                            time_flag++;
                                                                        
                                            //break when time_flag equal to
                                            //timeout limit
                                             if(time_flag > SDM_IO_TIMEOUT)   
                                            {         timeout = 1;         break;       } 
                                         }
                                                                
                                         //calculate the response time  
                                         ultrasoundDuration = micros() - tStartPing;   
                                                                  
                                         //if timeout equal 1
                                            if (timeout)    
                                                 return 999; 
                                            else    
                                                 return ultrasoundDuration * 0.017;
                                                // result in cm
 }

פלט:

סיכום:

החיישנים הם החלק הבולט והמעניין ביותר בעבודה עם Arduino ומאפשר לנו ללכת צעד קדימה בעיצוב ובתכנון של מוצרי Embedded בהמשך אני אסקור עוד חיישנים רבים עבור מגוון רחב של שימושים.

זה חי...