Teensy 3.1 - Comparison

אחת המגבלות ב Arduino היא המעבד שלו, הוא איטי ויחסית פרימטיבי אבל זול ועונה על חלק מהצרכים אבל כאשר רוצים משהו מתוחכם יותר ניתן להשתמש בגרסת Arduino Due המסיבית עם מעבד 84 Mhz או בגרסת  ה YUN עם מעבד 400MHZ ומערכת הפעלה מורכבת שלפעמים זה יותר מידי, בסה"כ רצית שהיה קטן ומהיר יותר מאשר ה 16 MHZ הקלאסי שבגרסת ה Nano.

Teensy 3.1

נחלצת לעזרתנו חברה יחסית אנונימית שלא עושה יותר מידי רעש, לחברה קוראים PJRC ויש לה סדרת לוחות תואמי Arduino, הדגם האחרון בסדרה מבוסס על מעבד Arm Cortex M-4 שיכול להגיע למהירות של 96 MHZ ועם כל מיני תוספות:

• CPU: Cortex M-4 72/(o.c)96 Mhz 
• Flash Memory:256KB
• RAM: 64 kb
• Memory Access Chanel:16
• Digital I/O: 34, 3.3v,5V Tolerant
• Analog Inputs: 21
• Interfaces: USB x 1, SPI x 1, CAN x 1,UART x 3,I2S x 2

https://www.pjrc.com/teensy/teensy31.html

כל העסק קטן יותר מ Arduino Nano, וגם מחיר לא רע של 20 דולר ליחידה שאפשר לרכוש ב SparkFun, בנוסף הוא יכול לחקות התקני HID כמו עכבר ומקלדת, חשוב להוריד את התוסף של הלוח לסביבת Arduino מאתר היצרן.

שימו לב!

• התוסף ירוץ רק על הגרסה 1.0.5 של ה Arduino IDE.
• אין לחבר מתח מעל 5.5v.

הגודל כן קובע

הלוח תומך בספריות הרגילות של Arduino ככה שלא צריך להסתבך יותר מידי, לצורך ההשוואה אני הולך לחבר מסך TFT בדומה למאמר האחרון, ולהדגים את הבדלי הביצועים בניהם, נשתמש בספריית UTFT ונפתח את הדוגמה עבור המסך  UTFT_Demo_320x240_Serial תחת הספרייה Arduino (ARM) + Teensy.

Teeny 3.1 Pinouts

//11-> SDI

//13 ->SCK

//10 -> CS

//8 -> RST

//9 ->DC

UTFT myGLCD(TFT01_22SP,11,13,10,8,9);

Results

Arduino Nano 16 Mhz full animation

2.39 min

Teensy 3.1 96 Mhz full animation

37 sec

סיכום

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

Arduino Killer?

Arduino And TFT Screen

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


שימו לב!

• רוב המסכים דורשים 3.3V, בדקו היטב לפני שאתם מחברים.
• הפינים לממשק ה SPI עלולים להשתנות מלוח ללוח.

דרישות

• (Arduino (any kind will do the job
• TFT Display
• 5 47K Ressistor
• 10K Potentiometer 
• Wires

TFT-LCD (Thin Film Transistor-Liquid Crystal Display)

מסכי TFT לוקחים את התצוגה קדימה, הם חדים וצבעוניים בניגוד למסכי ה LCD הקלאסים שהצגתי בעבר, אבל מורכבים יותר כך שה Arduino עצמו לא יכול לנהל אותם כי אין לו מספיק זיכרון להכיל את המידע עבור כל פיקסל וזה גם לא ממש העבודה שלו, בדר"כ הם מנוהלים בעצמם בעזרת IC ייעודי שמאפשר לגשת אליו בעזרת ממשק SPI,

קטן ומגניב

הכנה מקדימה

דבר ראשון חשוב להוריד ספריה שמתאימה למסך, יש המון סוגים של ספריות שתומכות במסכים שונים, הספריה הפופלרית ביותר נקראת UTFT שמכסה המון סוגים של מסכים, לאחר מכן פותחים את קובץ ה Zip ושופכים אותו לתיקיית Libraries שב Arduino IDE,עורכים את הקובץ memorysaver.h ומורידים את ההערות למעט (במקרה שלי) מהשורה:

 //#define DISABLE_ILI9341_S5P

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

לאט אבל בטוח

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

UTFT myGLCD(TFT01_22SP,11,13,10,9,8);  

מבנה סופי

ואו...

סרט הדגמה

סיכום

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

שנה טובה!

Arduino Yun - CGI and Python

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

• NotePad++ - כתיבת קוד והמרות קבצים בין Windows ל Linux.
• WinScp - העברת קבצים בין ה Yun למחשב האישי.
• Putty - התממשקות ב SSH ל Yun.

הגדרה ראשונית

שימו לב!

• יש לגבות את קבצי המערכת לפני התחלת העבודה!
• יש לגבות את ספריית www.

מערכת ההפעלה OpenWrt מגיעה עם שרת Web שנקרא uhttpd שדרכו ניגשים לממשק של ה Yun, נוכל להעזר בו בשביל האתר שלנו, כל מה שצריך לעשות הוא להוריד את קובץ ההגדרות (uhttpd) שנמצא בתיקייה /etc/config/ בעזרת WinSCP ולהוסיף שורה שמייצגת את ה interpreter של Python כפי שניתן לראות בדוגמה:

# List of extension->interpreter mappings.

# Files with an associated interpreter can

# be called outside of the CGI prefix and do

# not need to be executable.

# list interpreter ".php=/usr/bin/php-cgi"

# list interpreter ".cgi=/usr/bin/perl"

list interpreter   ".py=/usr/bin/python"

קוד

הדוגמה קצת יותר מורכבת מ Hello World פשוט ומכילה 2 דפים, הדף הראשון הוא ה Login שבעזרתו נקבל קלט מהמשתמש ונעביר אותו ב Get לדף השני, במקרה שעשינו טעות בשם המשתמש או הסיסמא השרת יזריק קוד של Javascript שיחזיר את הלקוח ל Login,

על מנת לא לפגוע באתר המקומי של ה Yun נוסיף תיקייה חדשה ב www/cgi-bin בה נאכסן את קבצי ה Python אבל לא נוכל להכניס בה את קבצי ה JS או ה CSS כי השרת יחשוב שהוא צריך להריץ אותם ויחפש את interpreter המתאים, לכן יש לאכסן את שאר הקבצים מחוץ לתייקית cgi-bin.

login.py

#!/usr/bin/env python
import os

#set http header, leave double space
print "Content-type: text/html"
print

#print html content
print """
     <html>
     <head>
     <title>Login</title>
     
     <meta name="viewport" 
     content="width=device-width,initial-scale=1,maximum-scale=1" />
     
     <link href="/../example/css/jquery.mobile-1.4.3.min.css" rel="stylesheet" type="text/css" />
     <script src="/../example/js/jquery-2.1.1.min.js" type="text/javascript"></script>
     <script src="/../example/js/jquery.mobile-1.4.3.min.js" type="text/javascript"></script>
     <script src="/../example/js/jquery.validate.min.js" type="text/javascript"></script>
     </head>
     
     <body>
          <form action="/cgi-bin/example/welcome.py" method="get">
             <div style="margin-top:5%;margin-left:5%;margin-right:5%">
                Name: <input type="text" name="txb_name">  <br />
             </div>
             <div style="margin-top:5%;margin-left:5%;margin-right:5%">
                Password: <input type="password" name="txb_password" />
             </div>

             <div style="margin-top:5%;margin-left:5%;margin-right:5%">
                <input type="submit" value="Submit" />
             </div>
          </form>

     </body>
     </html>
      """

welcome.py

#!/usr/bin/env python
import os
import cgi

form = cgi.FieldStorage()

# get date from post/get
name = form.getvalue('txb_name')
password  = form.getvalue('txb_password')

# set http header, leave double space
print "Content-type: text/html"
print

# write head
print """
    <html>
    <head>
    <title>Welcome</title>

    <meta name="viewport"
        content="width=device-width,initial-scale=1,maximum-scale=1" />
        
    <link href="/../example/css/jquery.mobile-1.4.3.min.css" rel="stylesheet" type="text/css" />
    <script src="/../example/js/jquery-2.1.1.min.js" type="text/javascript"></script>
    <script src="/../example/js/jquery.mobile-1.4.3.min.js" type="text/javascript"></script>
    </head>"""

# change body depend on the request
if password != "12345" and name != "proxytype":
   print """
        <body>
            <script type="text/javascript">
               window.location.href = 'login.py';
            </script>
            Redirecting...
        </body>
        </html>"""
else:
    print """
        </head>
        <body>
        <h1 style="margin-top:5%%;margin-left:5%%">Welcome, %s !</h1>
        </body>
        """ % (name)
# % is symbol for string formatting for return it in string enter double '%%'
# printing close tag
print "</html>"

נקודות נוספות

CGI רגיש מאוד ולפעמים עלולים לקבל שגיאות שלא תמיד ניתן להבין מה בדיוק הבעיה, רכזתי מספר טיפים שיפתרו את רוב התקלות:

• Permissions - יש לוודא שהסקריפטים של ה Python נמצאים בתיקיית cgi-bin ושיש שלהם הרשאות גבוהות ניתן להעזר בפקודה ב chmod a+x, זה יעשה את העבודה.
• (End Of Line (EOL - יש הבדל באיך מערכות ההפעלה מתייחסות לסוף השורה, ב Windows בכל סוף שורה יש את התווים r\n\ ולעומת זאת במערכות Unix רק את התו n\ לכן במקרה שכותבים ב Windows יש לשמור את הקבצים בהגדרת Unix בעזרת Notepad++:

זה הכרחי?!

• (Bytes Order Mark (BOM - תו Unicode שמוכנס לתחילת הקובץ מאפשר להקל על צורת הקידוד במקרה של Unicode, UTF-16 ו UTF-32 במקרה שלנו נשתמש ב UTF-8 ככה שאין לו משמעות וצריכים להוריד אותו בעזרת Notepad++: 

קידוד עולם אכזר!

תוצאה סופית

סיכום

בעזרת Python בשילוב JavaScript ו Css נוכל לבנות ממשקי ניהול מורכבים, וזה בזכות ה Linux שמאפשר לנו לעבוד עם שירותים מתקדמים יותר ונפח זיכרון גדול לקבצים , אומנם הדגמתי על Python אבל אפשר לעבוד גם עם PHP רק שהוא לא מגיע באופן טבעי עם הלוח ויש להוריד אותו בנפרד.

ללא גבולות...

Arduino Yun - Starting Guide

עד עכשיו ראינו 2 סוגים של לוחות פיתוח, הראשון היה Arduino שמבוסס על מעבד פשוט ללא מערכת הפעלה, לעומתו ראינו את BeagleBone ואת Raspberry PI שמבוססים על מעבדים יותר מתוחכמים שמריצים Linux, מפתחי Arduino לא יכלו להיות אדישים והוציאו דגם חדש שמשלב בתוכו את 2 העולמות.

הוא מכיל 2 מעבדים, הראשון והמוכר ATmega 328u4 במהירות 16MHZ ו 32KB של זיכרון ,הוא אחראי על העבודה מול החיבורים הדיגטליים והאנלוגים המקוריים שיש בגרסת ה Uno הותיקה, המעבד השני הוא Atheros AR 9331 שמבוסס על ארכיטקטורת MIPS במהירות 400Mhz עם 64MB של זיכרון, הוא אחראי על שאר ה Peripherals כמו הרשת הקווית ,האלחוטית ,כרטיס הזיכרון וה USB ,הלוח מריץ מערכת OpenWRT שכתבתי עליה בעבר.

דרישות

• Arduino Yun
• Led
• 330ohm Resistor
• Wires

בגודל של Uno

הפעלה ראשונית

הלוח מגיע מוכן, מה שנשאר לעשות הוא לחבר אליו חשמל ולהתחבר ל Access Point שהוא יוצר אוטומטית, נפתח את הדפדפן ונכניס את הכתובת של ה Default Gateway שקיבלנו (במקרה שלי 192.168.201.223), דרכה נגיע לממשק הניהול.

הסיסמא ההתחלתית היא arduino

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

חלק קטן מ OpenWRT

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

טירוף...

Bridge

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

בעזרת פרטוקול Http ושרת Web, נוכל לשלוט על הפינים בעזרת מבנה Url, לדוגמה נניח שנרצה להפוך את Pin 13 ל OutPut נקרא לכתובת במבנה מסויים שברגע שתגיע לשרת הוא יחתוך אותה ויפעל בהתאם כפי שניתן לראות בדוגמאות הבאות:

הגדרת הרגל כ Input / Output:

http://arduino.local/arduino/mode/13/output

כתיבת ערך לרגל דיגיטלית:

http://arduino.local/arduino/digital/13/1

קריאת ערך מרגל דיגיטלית:

http://arduino.local/arduino/digital/13

כתיבה ערך לרגל אנלוגית:

http://arduino.local/arduino/analog/2/128

קריאת ערך מרגל אנלוגית:

http://arduino.local/arduino/analog/2

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

• Putty - נתחבר ל Arduino Yun בעזרת SSH.
• WinSCP - העברת קבצים בין המחשב האישי ל Arduino Yun.

נפתח Notepad ונרשום את הקוד הבא:

#Arduino Yun blink example using Bridge with Python

#proxytype.blogspot.com

#getting Thread function from Thread class

from threading import Thread

#add Libraries

import urllib2

import time

#selected Pins

PIN = 7

#set pins output/input

response = urllib2.urlopen('http://localhost/arduino/mode/' + str(PIN) + '/output')

print response.read()

def main(n):

    #flag

    Status = False

    while True:

if Status == False:

Status = True

response = urllib2.urlopen('http://localhost/arduino/digital/' + str(PIN) + '/1')

print response.read()

else:

Status = False

response = urllib2.urlopen('http://localhost/arduino/digital/' + str(PIN) + '/0')

print response.read()

time.sleep(n)

#start in new thread, send second to sleep

t = Thread(target=main, args=(1,))

t.start()

נשמור את הקובץ ונעביר אותו ל Yun בעזרת WinSCP, ואח"כ נתחבר ל Terminal בעזרת SSH ונריץ את התוכנית:

סרט לדוגמה

סיכום

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

יותר שכל באותו מקום...

GPS with Arduino

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

דרישות

• (Arduino (any kind will do the job
• GPS Module + Antenna
• Breadboard
• Wires

Global Positioning System

מערכת לוויינים שמקיפה את כדור הארץ ושולחת אותות לרחבי העולם, מקלט GPS מקבל מספר אותות מלוויינים שונים ומחשב את מיקומו ביחס אליהם, את המקלט שלי רכשתי ב DX במחיר של 21 דולר, הוא מבוסס על ממשק סיראלי שהופך את העסק להרבה יותר פשוט.

GY-GPS6MV1

קוד

#include <SoftwareSerial.h>
#include <TinyGPS.h>

TinyGPS tGps;
SoftwareSerial gpsSerial(5, 6);

void setup() {
 
  //arduino serial - 115200
  Serial.begin(115200);
  //gps serial - 9600
  gpsSerial.begin(9600);
 
}

void loop() {
 
  while (gpsSerial.available())
  {
    //add char to buffer inside TinyGps
    char c = gpsSerial.read();
    tGps.encode(c);
  }

  float latitude, longitude;
 
  //get results as float
  tGps.f_get_position(&latitude, &longitude, NULL);
 
  Serial.print("Latitude:  ");
  Serial.println(latitude,6);
  Serial.print("Longitude:  ");
  Serial.println(longitude,6);
 
  delay(100);
 
}

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

מבנה סופי

סיכום

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

איפה אני?!

Seven Segment Display Guide

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

דרישות

• (Arduino (any kind will do the job
• 7 Segments 
• Ohm Resistor 330
• Breadboard
• Wires

צורת העבודה מאוד בזבזנית ונאלץ להיפרד מ 8 חיבורים דיגיטליים ב Arduino על מנת שנוכל להשתמש בה כהלכה, כל רגל מייצגת Segment בודד וניתן לשלוט עליו בנפרד, על מנת לצמצם את כמות הרגליים מומלץ להשתמש ב Shift Register.

הרגל ה 8 היא עבור הנקודה שלא חלק מה Segments

קוד

//array of numbers, each number contain
//array of the 7 segment pins status, 
//0 for low , 1 for high
byte numbers[12][8] ={
 {1,0,0,0,0,1,0,0},//0
  {1,0,1,1,1,1,1,0},//1
 {1,1,0,0,1,0,0,0},//2
 {1,0,0,1,1,0,0,0},//3
 {1,0,1,1,0,0,1,0},//4
 {1,0,0,1,0,0,0,1},//5
 {1,0,0,0,0,0,0,1},//6
 {1,0,1,1,1,1,0,0},//7
 {1,0,0,0,0,0,0,0},//8
 {1,0,0,1,0,0,0,0}, //9
 {0,1,1,1,1,1,1,1} ,//.
 {1,1,1,1,1,1,1,1} //clear
 } ;
                                                       
//set pins as outputs
void setup() {              
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);

  Serial.begin(9600);
}

//change the segments by number
void draw(byte num)
{
  //starting pin
  byte pin = 2;
  for(byte seg = 0; seg < 8; ++seg)
  {
    //write the segment status
     digitalWrite(pin,numbers[num][seg]);
     //go to the next pin
     ++pin;
  }
}

void loop() {

  int counter = 0;

    while(counter < 11)
  {
       delay(500);
       draw(counter);
       counter = counter + 1;
  }

  draw(10);
  delay(500);
  draw(11);
  delay(100);
  draw(10);
  delay(500);

  while(counter >= -1)
  {
     delay(500);
     draw(counter);
     counter = counter - 1;
  }

  draw(10);
  delay(500);
  draw(11);
  delay(100);
  draw(10);
  delay(500);

}

קיים מערך שמכיל בתוכו 10 מערכים נוספים שבכל אחד מהם יש ערך עבור כל Segment, לצורך הדוגמה המערך {1,0,0,0,0,0,0,0} מייצג את הספירה 8 כי כל ה Segments דולקים למעט ה Segment הנוסף של הנקודה בצד.  

מבנה סופי

מספר הולך, מספר בא.

סרטון הדגמה

סיכום

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

תצוגה בגרוש.

Arduino And EEPROM

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

דרישות

• Arduino Uno
• 24LC256 EEPROM
• Wires
• Breadboard

EEPROM - Electrically Erasable Programmable Read-Only Memory

אין ספק שהשם מפוצץ אבל בסופו של דבר מדובר ביחידת זיכרון שמאפשרת לשמור על המידע גם כאשר המכשיר כבוי, הרכיב שבחרתי עליו להדגים הוא 24LC256 שמאוד נפוץ במחיר 2 $ בלבד מאפשר לנו להרחיב את הזיכרון בעוד 256K ,הוא אינו נדיף בניגוד ל Ram ובנוסף הכתיבה והקריאה הן ברמת Bit בודד בניגוד לזיכרון Flash שלצורך שינוי ביט אחד יש לקרוא בלוק של מידע ,לטעון אותו לזיכרון ה Ram, לעשות את השינוי ולכתוב בחזרה ל Flash מה שהופך את העסק למסורבל אבל חיוני מאוד למידע בנפחים גדולים.

256K של זיכרון לא נדיף

הרגליים האנלוגיות (A5, A4) ב Arduino Uno מאפשרות לעבוד בתקשורת I2C Inter-Integrated Circuit שדומה מאוד ל SPI שראינו במאמר Arduino and MicroSD ההבדל העיקרי הוא שב SPI עבור כל רכיב נצטרך רגל אחת מה Arduino לעומת I2C שבו כל הרכיבים מתחברים לאותן כניסות בלוח ובקלות ניתן להוסיף עוד רכיבים, מדובר על 2 רגליים שבעזרתן מייצרים Bus הרגל הראשונה היא השעון, והשניה ל Data, לכל רכיב יש כתובת ייחודית שדרכה מתחברים בעזרת הממשק.

המון חיבורים עם 2 רגליים בלבד

קוד

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

#include <Wire.h>

//unique address for the eeprom 24LC256
#define eeprom1 0x50 
#define readblock 100
#define pageblock 16

//size of the message
unsigned char length = 0;
//receive data buffer
unsigned char rdata[readblock];

 
void setup(void)
{
  //example of parsable string
  unsigned char str_data[]={"{message:this is working! using EEPROM}\n"};

  Serial.begin(9600);

  //Active I2C interface
  Wire.begin();

  //writing  data to 24LC256
   writeData(str_data);
}

 void loop(){

    Serial.println("DATA READ");
 
    //reading data to 24LC256 
    readData(rdata,readblock);
    Serial.write(rdata,readblock);

    delay(1000);
}


void writeData( unsigned char * str_data)
{

  unsigned char pages = 0;
  unsigned char offset = 0;
  unsigned char index = 0;
  unsigned char counter = 0;

  //get the length of data
  length = getStrLength(str_data);
  //get the number of page to write
  pages = length / pageblock;

  //make the magic
  for(index = 0; index <= pages;index++)
  {
       //connecting to the device
       Wire.beginTransmission(eeprom1);
 
       //set the position of writing,
       Wire.write((int)((offset) >> 8));   //MSB -  Most significant bit
       Wire.write((int)((offset) & 0xFF)); // LSB - Least significant bit
     
       //total bytes writed to jump the next page address
       unsigned char i= 0;
     
       for(i= 0; i < pageblock;i++)
        {
                //writing the char to the memory unit.
                Wire.write((byte) str_data[counter]);
 
                //if counter equal data length quit!
                if(counter == length)
                      break;
                   
                 //increment the total counter of length
                 counter++;                
        }
   
       //end I2C transmission
        Wire.endTransmission();
     
        //move offset to the next page  
        offset += i;
     
        //give it some time...
        delay(10);
     
  }

}

 void readData(unsigned char* data, unsigned int length)
 {
 
   unsigned char offset = 0;
   unsigned char counter = 0;
 
   //start reading pages until new line break
  while(true)
  {
     //total bytes writed to jump the next page address 
     unsigned char i=0;
      Wire.beginTransmission(eeprom1);
   
      //set position of reading
      Wire.write((int)(offset >> 8));   //MSB -  Most significant bit
      Wire.write((int)(offset & 0xFF)); //LSB - Least significant bit
   
     //end I2C transmission
      Wire.endTransmission();

       //request data from device
      Wire.requestFrom(eeprom1,length);

      while(Wire.available())
      {
          //write char to position data
          data[counter] = Wire.read();
       
          //end of message!
          if(data[counter] == '\n')
          {
              return;
          }
       
         i++;
         counter++;
     }
   
     offset+=i;
     delay(10);
  }
}

 //get the length from chars array
 unsigned char getStrLength(unsigned char * data)
 {
   unsigned char str_len=0;
    do{ str_len++; } while(data[str_len]);
    return str_len;
 }

מבנה סופי

סיכום

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

שנה חמישית, ואו!

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 כיכב בבלוג, במהלך השנה באה ניקח אותו לקצה ונבנה פרויקטים מורכבים יותר.

בהצלחה...

Arduino LCD Guide

האמת שיש נושא שעדיין לא סגור כמו שצריך, במאמר Arduino And .Net השתמשתי במסך שמגיע כחלק מ Shield, אבל עדיין לא הסברתי כיצד לחבר מסך LCD ישירות ל Arduino והגיע הזמן לעשות זאת, יש שפע של מסכים מסוגים שונים בשוק את שלי מצאתי כמו תמיד ב DX במחיר של 4 דולר.


דרישות:

• Arduino Uno
• (LCD Screen (16X2
• Potentiometer
• BreadBoard
• Wires

Liquid-Crystal Display

רוב מסכי ה LCD מגיעים עם 16 פינים אבל לא צריך להשתמש בכולם, על מנת לחבר את המסך ל Arduino נצטרך רק 9 פינים את חלקם נעביר לספרייה LiquidCrystal שמגיעה עם הסביבה של Arduino ונחבר פוטנציומטר על מנת שנשלוט בחוזק התאורה האחורית (K, A).

6 כניסות דיגיטליות, GND ו 5V

מבנה סופי

הטקסט תקין למרות שבתמונה נראה שלא...

קוד

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

#include <LiquidCrystal.h>

LiquidCrystal lcd(7,6,5,4,3,2);

char screen[16];

char message1[] = {' ',' ',' ',' ',' ',' ',' ',' ',' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ','P','r','o','x','y','T','y','p','e',' ','B','l','o','g'};

char message2[] = {' ',' ',' ',' ',' ',' ',' ',' ',' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ','P','r','o','x','y','T','y','p','e','.','b','l','o','g','s','p','o','t','.','c','o','m'};

void setup()

{

      //set the screen chars and rows

     lcd.begin(16,2 );

}

void loop()

{

    //send the first message to buffer

    sendMsg1();

    delay(100);

    

    cleanArray();

    

    //send the second message to buffer

    sendMsg2();

   delay(100);

    cleanArray();

}

void sendMsg1()

{

   int msgsize = sizeof(message1) / sizeof(char);

  for(int i = msgsize; i > 0;i--)

  {

      pushArray(message1[i],0);

       delay(200);

  }  

}

void sendMsg2()

{

   int msgsize = sizeof(message2) / sizeof(char);

  for(int i = msgsize; i >0;i--)

  {

      pushArray(message2[i],1);

       delay(200);

  }  

}

void pushArray(char c, int line)

{

  lcd.clear();

  lcd.setCursor(0,line);

  char tmp = screen[0];

  screen[0] = c;

  

  for (int i = 1; i < 16; i++)

     {

                char locker;

                    locker = screen[i];

                screen[i] = tmp;

                if (i == 16)

                    break;

                tmp = locker; 

       }

       

         lcd.print(screen);

}

void cleanArray()

{

    //clear screen buffer

    for(int i=0; i < 17; i++)

    {

      screen[i] = '\0';

    }

}

סרט הדגמה

סיכום 

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

בהצלחה...

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 בהחלט עושה את העבודה ונותן לנו אפשרויות שלא היו לפני כמו לעבוד עם קבצי הגדרות, לכתוב ולקרוא מידע ולשמור עליו לפעמים הבאות.

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