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.

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

Raspberry Pi - Starting Guide

אם חשבתם ש Raspberry PI יעבור לידי ואני לא אתייחס אליו אז טעיתם, הלוח הזה שינה את כללי המשחק בכל הקשור למערכות Embedded ו SOC, הוא זול ,פשוט ומגיע עם מגוון רחב של חיבורים, אין משהו שלא עשו איתו ממערכות פשוטות למחשבי על, הוא תוכנן ע"י ארגון צדקה בשם Raspberry Pi Foundation שמטרתו ללמד מדעי המחשב באופן חופשי בעולם.

הסדרה מכילה 3 דגמים עם את אותו מעבד ARM 700MHZ (בנתיים) וההבדלים העיקריים הם בציוד היקפי (Peripherals) שמשתנים מדגם לדגם ומשפיעים על המחיר.

www.sparkfun.com

דרישות

• Raspberry PI Model B
• SDCard 8 GB
• TFT Monitor
• Keyboard + Mouse
• LED
• 330ohm Resistor
• Breadboard
• Wires

שימו לב!

• יש לחבר לספק 5V בלבד!
• חשוב לזכור שהפינים של ה 5V מוגבלים עד 300ma וה 3.3V עד 50ma.

התקנה

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

http://www.raspberrypi.org/downloads/

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

https://www.sdcard.org/downloads/formatter_4/

לאחר סיום הפורמט נפתח את קובץ ה Zip ונעתיק את התוכן שלו ל SDcard, נחבר מקלדת ומסך ואפשר לומר שסיימנו, הלוח מגיע עם כניסת HDMI שניתן לחבר לכל טלויזיה או מסך וחיבור S-Video סטנדרטי למסכים קצת יותר פרימיטביים לצורך הדוגמה אני משתמש במסך בגודל 5 אינץ שמתאים בעיקר לרכב שרכשתי מ DX תמורת 40$ היתרון שלו על פני שאר המסכים שניתן גם לחבר VGA, בדר"כ המסכים האלה מגיעים ללא ספק כוח ודורשים 12V אבל הצלחתי להפעיל אותו ב 9V ואני מאמין שאפשר גם בפחות.

סיני זול שעושה את עבודה.

במהלך ה Boot של הלוח ניתן ללחוץ Shift 3 על מנת להעביר את התצוגה ל S-Video ב PAL ומשם להמשיך בהתקנה, קובץ ההתקנה מכיל מספר distributions של Linux מותאמות ל Raspberry Pi, אבל מומלץ להשתמש ב Raspbian שהיא הפופלרית ביותר.

שתו קפה יש זמן...

בסיום ההתקנה הלוח יעשה Boot ויעלה מסך הגדרות הם מספר אפשרויות, קודם כל מומלץ להחליף את סיסמאת ה Default שהיא raspberry עבור משתמש PI, ניתן להגדיר Overclock ועוד כל מיני דברים, תמיד אפשר לחזור למסך הזה ע"י הפקודה raspi-config עם Sudo.

Overclock - נחמד!

בסיום יעלה לנו הטרמינל הרגיל של Linux, בעזרת הפקודה startx נעבור לממשק חלונאי:

ואוו...

קוד

המערכת מוכנה ואפשר להתחיל לכתוב את הקוד הראשון, בעבר הדגמתי כיצד לתכנת פינים ב BeagleBone וזה לא כלכך שונה מה PI, כי נחזור על אותה קלישאה ישנה שהכל ב Linux זה קובץ וכל מה שנשאר זה לפתוח אותו ולכתוב בו ערך באיזה שפה שנרצה, במקרה של ה PI שפת ה Python מגיעה כחלק מהמערכת אבל לפני הקוד חשוב להכיר את הפינים עצמם.

26 פינים שחלקם עם שימוש נוסף

26 פינים שבחלקם ניתן לעשות יותר משימוש אחד, ניתן לעבוד עם מספר ממשקים שונים (UART,SPI,I2C), במערכת מגיעה סביבת פיתוח פשוטה של Python שנקרא IDLE שבעזרתו נכתוב את הקוד, אם לא בא לכם לעבוד ישירות על הלוח ניתן להתחבר אליו בעזרת SSH.

#add Libraries

import RPi.GPIO as GPIO

#use board pins

GPIO.setmode(GPIO.BOARD)

#selected pin

pin = 7

#set GPIO as output

GPIO.setup(pin, GPIO.OUT)

#set flag false

status = False

while True:

if status == False:

GPIO.output(pin,GPIO.LOW)

status = True

else:

GPIO.output(pin,GPIO.HIGH)

status = False

x = raw_input('Press Key!')

מבנה סופי

סרט הדגמה

סיכום

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

יש פטל?

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 הנוסף של הנקודה בצד.  

מבנה סופי

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

סרטון הדגמה

סיכום

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

תצוגה בגרוש.

Merge Power Supplies

במקרה שרוצים לבנות מחשב מעבר לשימוש הסטנדרטי לדוגמא מחשב של גיימרים עם מספר כרטיסי מסך צריכים למצוא ספק מספיק חזק שיספק זרם עבור כל הכרטיסים וכאן המחיר מטפס (גם חשבון החשמל),ניתן לחבר מספר ספקים ביחד ולפצל אותם בין הרכיבים השונים כפי שנראה בהמשך,יש פה עניין חשוב של כסף, ספק 1000 W עולה מעל 1000 ש"ח בעוד שספק 600 W עולה בין 250 ל 450 ש"ח תלוי ביצרן.

ATX Power Supply Pinouts

שימו לב!

אזהרת התחשמלות - העבודה עם ספק כוח מסוכנת ועלולה לגרום להתחשמלות אני לא אחראי על כל נזק לרכוש או לנפש ראו הוזהרתם!

אז אחרי ההזהרות אפשר להתחיל, קודם חשוב להכיר את הספק כוח יש המון סוגים אבל הם מגיעים בסטנדרט אחד שנקרא (ATX (Advanced Technology eXtended שהומצא בשנת 1995 ע"י אינטל אבל גם זה כנראה הולך לעבור שינוי בקרוב, בספק יש מספר יציאות חשמל בעוצמות זרם שונות שהן חלק מהתקן ונקראות Molex, היציאה הראשונה היא ATX Connector שמתחברת ללוח אם וגורמת לעסק לעבוד, אפשר להשוות אותה בחשיבותה לאבי העורקים שבגופנו, החיבור עצמו מורכב מ 24 פינים כפי שניתן לראות בתמונה:

כאשר נחבר בין החיבור PS_ON לאחד ה (COM (GND נוצר קצר שמפעיל את הספק כוח, נוכל לדמות את זה בעזרת כבל נוסף או Relay.

זה מסוכן, אמרתי כבר?!

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

• אדום - 5V
• סגול - 5V STAND BY
• צהוב - 12V
• שחור - GND
• ירוק - PS ON
• כתום - 3.3V
• אפור - POWER GOOD
• כחול - 12V-
• חום - 3.3V Sensing

Molex 4 pin connector הוא חיבור נפוץ ביותר הוא מורכב מ 4 חוטים:

• אדום - 5V
• צהוב - 12V
• שחור - GND

זכר

הדרך הפשוטה ביותר להפעיל ספק כוח בעזרת ספק אחר היא לחתוך את הכבל הירוק וכבל שחור מה Atx Connector ולחבר חיבור Molex עם 4 פינים שמחברים לספק אחר.

Relay

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

2 $ ליחידה

מחברים את הספק כוח הראשון לרגליים של ה 5 V ו ה GND ב Relay ומחברים DIODE בניהם, בספק השני מחברים את הרגל PS_ON לרגל NO ורגל GND ל GND, ברגע שנפעיל את הספק הראשון אוטומטי הספק השני ידלק.

במקרה שיש לכם לוח ישן שאין בו שימוש אפשר למחזר את ה Atx Connector:

למחזר זה חשוב!

סיכום

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

טובים השניים מהאחד...

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

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