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

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

מימוש

כדי לממש את יכולות הראייה הממוחשבת של הרובוט השתמשתי במספר אלגוריתמי עיבוד תמונה וראייה ממוחשבת בסיסיים. השתמשתי בספריית OpenCV – ספריית ראייה ממוחשבת בעלת קוד פתוח, שפותחה במקור על ידי אינטל. הספרייה היא Cross Platform (השתמשתי בה גם ב-PC וגם בלוחות מבוססי ARM כדוגמת ה-Beagleboard). ספריית OpenCV נוחה לשימוש לבעלי רקע וקצת נסיון עם עיבוד תמונה.

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

מעקב מבוסס צבע

מעקב מבוסס צבע מומלץ לשמוש כאשר ניתן להפריד צבע אחד משאר צבעי הרקע בתמונה – לדוגמה, כדור בצבע כתום בחדר עם קירות לבנים, אריחי רצפה לבנים וכו'. סינון שאר הצבעים מהתמונה, והשארת הצבע הכתום בלבד הוא תהליך מהיר מאד שמאיץ את אלגוריתמי עיבוד התמונה שיורצו בשלב מאוחר יותר, ולכן הוא מומלץ כפילטר ראשוני. אגב, ניתן לומר ששלט Wii משתמש גם הוא ביהוי מבוסס צבע למציאה מהירה של מיקום השלט (שם "הצבע" שבשימוש הוא גלי אור אינפרא-אדומים).

כדי לפלטר ולהשאיר בתמונה רק את הצבעים הכתומים, העברתי את התמונה למרחב צבע HSV, ולאחר מכן השתמשתי בפילטר cvInRange כדי להותיר רק את טווח הצבעים הכתום. בתמונות למטה ניתן לראות את התמונה לאחר מעבר למרחב הצבע HSV, ולאחר מכן לאחר הרצת פילטר הצבע והמרה לשחור-לבן (כאשר לבן מיצג צבע כתום בתמונה המקורית ושחור את כל שאר הצבעים).

להלן הקוד ב-Python הרלוונטי:

#declare necessary objects

hsv_frame = cvCreateImage(size, IPL_DEPTH_8U, 3)
thresholded = cvCreateImage(size, IPL_DEPTH_8U, 1)
thresholded2 = cvCreateImage(size, IPL_DEPTH_8U, 1)
hsv_min = cvScalar(0, 50, 170, 0)
hsv_max = cvScalar(10, 180, 256, 0)
hsv_min2 = cvScalar(170, 50, 170, 0)
hsv_max2 = cvScalar(256, 180, 256, 0)

# convert to HSV for color matching
# as hue wraps around, we need to match it in 2 parts and OR together
cvCvtColor(frame, hsv_frame, CV_BGR2HSV)
cvInRangeS(hsv_frame, hsv_min, hsv_max, thresholded)
cvInRangeS(hsv_frame, hsv_min2, hsv_max2, thresholded2)
cvOr(thresholded, thresholded2, thresholded)

זיהוי אוביקט מבוסס צורה

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

להלן הקוד, ב-Python.

# pre-smoothing improves Hough detector
cvSmooth(thresholded, thresholded, CV_GAUSSIAN, 9, 9)
circles = cvHoughCircles(thresholded, storage, CV_HOUGH_GRADIENT, 2, thresholded.height/4, 100, 40, 20, 200)

התוצאה

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

www.youtube.com/watch?v=CigGvt3DXIw

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

/*****************************************************************************************
*  Name    : Fast object tracking using the OpenCV library                               *
*  Author  : Lior Chen <chen.lior@gmail.com>                                             *
*  Notice  : Copyright (c) Jun 2010, Lior Chen, All Rights Reserved                      *
*          :                                                                             *
*  Site    : http://www.lirtex.com                                                       *
*  WebPage : http://www.lirtex.com/robotics/fast-object-tracking-robot-computer-vision   *
*          :                                                                             *
*  Version : 1.0                                                                         *
*  Notes   : By default this code will open the first connected camera.                  *
*          : In order to change to another camera, change                                *
*          : CvCapture* capture = cvCaptureFromCAM( 0 ); to 1,2,3, etc.                  *
*          : Also, the code is currently configured to tracking RED objects.             *
*          : This can be changed by changing the hsv_min and hsv_max vectors             *
*          :                                                                             *
*  License : This program is free software: you can redistribute it and/or modify        *
*          : it under the terms of the GNU General Public License as published by        *
*          : the Free Software Foundation, either version 3 of the License, or           *
*          : (at your option) any later version.                                         *
*          :                                                                             *
*          : This program is distributed in the hope that it will be useful,             *
*          : but WITHOUT ANY WARRANTY; without even the implied warranty of              *
*          : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
*          : GNU General Public License for more details.                                *
*          :                                                                             *
*          : You should have received a copy of the GNU General Public License           *
*          : along with this program.  If not, see <http://www.gnu.org/licenses/>        *
******************************************************************************************/
#!/usr/bin/python
# -*- coding: utf-8 -*-

from opencv.cv import *
from opencv.highgui import *
from threading import Thread
#import serial

class RobotVision:
	cvSize size
	cvImage hsv_frame, thresholded, thresholded2
	cvScalar hsv_min, hsv_max, hsv_min2, hsv_max2
	cvCapture capture;

	def InitBallTracking():
		globals size,  hsv_frame, thresholded, thresholded2, hsv_min, hsv_max, hsv_min2, hsv_max2, capture
		print "Initializing ball Tracking"
		size = cvSize(640, 480)
		hsv_frame = cvCreateImage(size, IPL_DEPTH_8U, 3)
		thresholded = cvCreateImage(size, IPL_DEPTH_8U, 1)
		thresholded2 = cvCreateImage(size, IPL_DEPTH_8U, 1)

		hsv_min = cvScalar(0, 50, 170, 0)
		hsv_max = cvScalar(10, 180, 256, 0)
		hsv_min2 = cvScalar(170, 50, 170, 0)
		hsv_max2 = cvScalar(256, 180, 256, 0)

		storage = cvCreateMemStorage(0)

		# start capturing form webcam
		capture = cvCreateCameraCapture(-1)

		if not capture:
			print "Could not open webcam"
			sys.exit(1)

		#CV windows
		cvNamedWindow( "Camera", CV_WINDOW_AUTOSIZE );

	def TrackBall(i):
		t = Thread(target=TrackBallThread, args=(i,))
		t.start()

	def TrackBallThread(num_of_balls):
		globals size,  hsv_frame, thresholded, thresholded2, hsv_min, hsv_max, hsv_min2, hsv_max2, capture
		while 1:
			# get a frame from the webcam
			frame = cvQueryFrame(capture)

			if frame is not None:

				# convert to HSV for color matching
				# as hue wraps around, we need to match it in 2 parts and OR together
				cvCvtColor(frame, hsv_frame, CV_BGR2HSV)
				cvInRangeS(hsv_frame, hsv_min, hsv_max, thresholded)
				cvInRangeS(hsv_frame, hsv_min2, hsv_max2, thresholded2)
				cvOr(thresholded, thresholded2, thresholded)

				# pre-smoothing improves Hough detector
				cvSmooth(thresholded, thresholded, CV_GAUSSIAN, 9, 9)
				circles = cvHoughCircles(thresholded, storage, CV_HOUGH_GRADIENT, 2, thresholded.height/4, 100, 40, 20, 200)

				# find largest circle
				maxRadius = 0
				x = 0
				y = 0
				found = False
				for i in range(circles.total):
					circle = circles[i]
					if circle[2] > maxRadius:
						found = True
						maxRadius = circle[2]
						x = circle[0]
						y = circle[1]

				cvShowImage( "Camera", frame );

				if found:
					print "ball detected at position:",x, ",", y, " with radius:", maxRadius

					if x > 420:
						# need to pan right
						servoPos += 5
						servoPos = min(140, servoPos)
						servo(2, servoPos)
					elif x < 220:
						servoPos -= 5
						servoPos = max(40, servoPos)
						servo(2, servoPos)
					print "servo position:", servoPos
				else:
					print "no ball"

קוד מקור בשפת C++

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

/*****************************************************************************************
*  Name    : Fast object tracking using the OpenCV library                               *
*  Author  : Lior Chen <chen.lior@gmail.com>                                             *
*  Notice  : Copyright (c) Jun 2010, Lior Chen, All Rights Reserved                      *
*          :                                                                             *
*  Site    : http://www.lirtex.com                                                       *
*  WebPage : http://www.lirtex.com/robotics/fast-object-tracking-robot-computer-vision   *
*          :                                                                             *
*  Version : 1.0                                                                         *
*  Notes   : By default this code will open the first connected camera.                  *
*          : In order to change to another camera, change                                *
*          : CvCapture* capture = cvCaptureFromCAM( 0 ); to 1,2,3, etc.                  *
*          : Also, the code is currently configured to tracking RED objects.             *
*          : This can be changed by changing the hsv_min and hsv_max vectors             *
*          :                                                                             *
*  License : This program is free software: you can redistribute it and/or modify        *
*          : it under the terms of the GNU General Public License as published by        *
*          : the Free Software Foundation, either version 3 of the License, or           *
*          : (at your option) any later version.                                         *
*          :                                                                             *
*          : This program is distributed in the hope that it will be useful,             *
*          : but WITHOUT ANY WARRANTY; without even the implied warranty of              *
*          : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
*          : GNU General Public License for more details.                                *
*          :                                                                             *
*          : You should have received a copy of the GNU General Public License           *
*          : along with this program.  If not, see <http://www.gnu.org/licenses/>        *
******************************************************************************************/

#include <opencv/cvaux.h>
#include <opencv/highgui.h>
#include <opencv/cxcore.h>
#include <stdio.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <float.h>
#include <limits.h>
#include <time.h>
#include <ctype.h>

int main(int argc, char* argv[])
{

    // Default capture size - 640x480
    CvSize size = cvSize(640,480);

    // Open capture device. 0 is /dev/video0, 1 is /dev/video1, etc.
    CvCapture* capture = cvCaptureFromCAM( 0 );
    if( !capture )
    {
            fprintf( stderr, "ERROR: capture is NULL \n" );
            getchar();
            return -1;
    }

    // Create a window in which the captured images will be presented
    cvNamedWindow( "Camera", CV_WINDOW_AUTOSIZE );
    cvNamedWindow( "HSV", CV_WINDOW_AUTOSIZE );
    cvNamedWindow( "EdgeDetection", CV_WINDOW_AUTOSIZE );

    // Detect a red ball
    CvScalar hsv_min = cvScalar(150, 84, 130, 0);
    CvScalar hsv_max = cvScalar(358, 256, 255, 0);

    IplImage *  hsv_frame    = cvCreateImage(size, IPL_DEPTH_8U, 3);
    IplImage*  thresholded   = cvCreateImage(size, IPL_DEPTH_8U, 1);

    while( 1 )
    {
        // Get one frame
        IplImage* frame = cvQueryFrame( capture );
        if( !frame )
        {
                fprintf( stderr, "ERROR: frame is null...\n" );
                getchar();
                break;
        }

        // Covert color space to HSV as it is much easier to filter colors in the HSV color-space.
        cvCvtColor(frame, hsv_frame, CV_BGR2HSV);
        // Filter out colors which are out of range.
        cvInRangeS(hsv_frame, hsv_min, hsv_max, thresholded);

        // Memory for hough circles
        CvMemStorage* storage = cvCreateMemStorage(0);
        // hough detector works better with some smoothing of the image
        cvSmooth( thresholded, thresholded, CV_GAUSSIAN, 9, 9 );
        CvSeq* circles = cvHoughCircles(thresholded, storage, CV_HOUGH_GRADIENT, 2,
                                        thresholded->height/4, 100, 50, 10, 400);

        for (int i = 0; i < circles->total; i++)
        {
            float* p = (float*)cvGetSeqElem( circles, i );
            printf("Ball! x=%f y=%f r=%f\n\r",p[0],p[1],p[2] );
            cvCircle( frame, cvPoint(cvRound(p[0]),cvRound(p[1])),
                                    3, CV_RGB(0,255,0), -1, 8, 0 );
            cvCircle( frame, cvPoint(cvRound(p[0]),cvRound(p[1])),
                                    cvRound(p[2]), CV_RGB(255,0,0), 3, 8, 0 );
        }

        cvShowImage( "Camera", frame ); // Original stream with detected ball overlay
        cvShowImage( "HSV", hsv_frame); // Original stream in the HSV color space
        cvShowImage( "After Color Filtering", thresholded ); // The stream after color filtering

        cvReleaseMemStorage(&storage);

        // Do not release the frame!

        //If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),
        //remove higher bits using AND operator
        if( (cvWaitKey(10) & 255) == 27 ) break;
    }

     // Release the capture device housekeeping
     cvReleaseCapture( &capture );
     cvDestroyWindow( "mywindow" );
     return 0;
   }

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

לפלטפורמה (או אם תרצו לרובוט) יש כרגע את היכולות הבאות:

1. ראייה ממוחשבת (חיקוי של ראייה אנושית, היכולת להבין מה הרובוט רואה ולהתנהג בהתאם). לדוגמה, הרובוט מסוגל לעקוב אחרי אובייקטים שונים, לזהות פנים, ולהתנייד בצורה עצמאית בחדר שמכיל מכשולים.
2. סינטזת דיבור (Speech Synthesis) – היכולת לדבר בקול שנשמע אנושי. האמת היא שכאן דווקא בחרתי בקול שנשמע רובוטי, אבל העיקרון עדיין זהה – הרובוט מסוגל לדבר, להרכיז על פעולות שונות שהוא מבצע, דברים שהוא מגלה, ובמקרים מסויימים להשיב על שאלות (עוד על כך – בהמשך)
3. זיהוי דיבור – היכולת להבין ולהגיב לפקודות אנושיות. לדוגמה: "Move Forward!", "Stop!" וכו'.

www.youtube.com/watch?v=okt-2_VxGfc

ראייה ממוחשבת (Computer Vision)

למימוש רוב יכולות הראיה המומחשבת, השתמשתי בספריית הקוד הפתוח OpenCV. הספרייה פועלת בסביבת לינוקס ומתמקדת בעיקר ביכולות עיבוד תמונה מתקדמות בזמן אמת (real time).

אלגורתמי הראיה הממוחשבת שמומשתי בינתיים:

1. מעקב אחרי קו המסומן על הקרקע (Line Following).
2. מעקב אחרי אובייקט (Object Tracking), לדוגמה כדור אדום. מדובר בשני סוגי מעקב – הראשון, יכולת של הרובוט להזיז את המערכת הראייה שלו ולעקוב אחרי מיקום הכדור (ללא תנועה אליו), והשני היכולת של הרובוט להבין היכן נמצא הכדור ולנוע אליו.
3. זיהוי פנים – יכולת ניסויית שכרגע עדיין נמצאת בפיתוח. הרעיון הוא ראשית לזהות קיום של פני אדם במרחב הראייה של הרובוט, ולאחר מכן זיהוי אנושי של הפנים (ובמילים פשוטות – מי האדם). זיהוי האדם מבוצע באמצעות Face API.

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

סינטזת דיבור (Speech Synthesis)

לסינטזת דיבור הרובוט משתמש בספרייה פתוחה נוספת שנקראת eSpeak. בחרתי בה במכוון בגלל הקול הרובוטי שמוסיף לאווירה .

הרובוט משתמש בדיבור כדי להכריז על פעולות שהוא מבצע, כגון: "Moving Forward", "Turning Left" וכו', כדי לומר שלום לאנשים אותם הוא מזהה ("Hi, Lior"), או מסקנות בסיסיות אליהן הוא מגיע ("Obsticle detected in front. Turning left").

זיהוי דיבור (Speech Recognition)

כדי שהרובוט יוכל להגיב לפקודות קוליות, הוספתי לו יכולות של זיהוי דיבור באמצעות שימוש ב-CMU Sphinx (למעשה Pocket Sphinx שרץ על ארכיטקטורת ARM).

הרובוט מבין פקודות בסיסיות כגון "Move Forward", "Stop" ופקודות איתחול אלגוריתמים שונים, לדוגמה: "Follow Ball" שלאחריה הרובוט יתחיל מעקב אחרי כדור, כמו שתואר בחלק הקודם.

תרשים על של הרובוט (TLD)

מפרט טכני

• מימדים:
• משקל:
• הספק:
• מתח:
• מנועים:
• חישנים:
• קישוריות:

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

מהי מערכת 'זמן אמת'?

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

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

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

סוגים שונים של מערכות זמן-אמת

בספרות המקצועית מוגדרים שני סוגים של מערכות זמן אמת: מערכות Hard Real-Time ומערכות Soft Real-Time.

מערכת Hard Real Time

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

דוגמאות למערכות Hard Real-Time:

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

2. מערכת בקרה של מנוע רכב, היות ועיכוב בשליחת סיגנל בקרה למנוע עלול להכשיל את פעולת המנוע או אפילו לפגוע בו.

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

מערכות Soft Real-Time

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

מדוע נדרש פיתוח Real-Time? הצורך בגרסת Real-Time Linux.

כאמור, לפעולות במערכת Real Time יש דרישות ביצועים במגבלות זמן מסוימות. נניח שאנו נדרשים לפתח אפליקציה שתגיב לפעולה מסוימת של המשתמש במגבלת זמן של עד שנייה אחת. נניח שפיתחנו את האפליקציה ושהיא רצה תחת גרסה רגילה של לינוקס (שאינה מ"ה זמן-אמת). בנוסף, בבדיקות הביצועים של האפליקציה נמדד זמן תגובה ממוצע של חצי-שנייה – מהיר ב-50% מהנדרש. האם הדרישות נענו? לצערנו, לא.

הסיבה לכך היא גרסת מערכת ההפעלה, שאינה Real Time. מתזמן התהליכים של לינוקס (Linux Scheduler) מתוכנן לזמן תגובה אופטימלי במקרה הממוצע. הוא מתוכנן בצורה כזו כדי ליצור תחושה של מערכת ריספונסיבית ומהירה, אפילו כשמספר רב של אפליקציות רצות במקביל. אולם הוא אינו מבטיח שהרצת תהליך מסוים תסתיים בזמן מוגדר. הרצת התהליך עלולה להיות מופסקת בכל רגע לטובת הרצת תהליכים אחרים (Context-Switching), או קריאות מערכת אחרות. מנגד, מערכת הפעלה שהינה Real-Time מציעה תזמון תהליכים עם חלוקת זמן מובטחת (Real Time Scheduler).

אלטרנטיבות לשימוש ב-Real Time Linux

רגע לפני שאנחנו קופצים למים העמוקים של RT Linux, חשוב לציין מספר אלטרנטיבות שכדאי לבחון. לפעמים אפשר לעקוף את הצורך בשימוש במערכת הפעלה זמן-אמת על ידי שימוש ברכיבי חומרה ייעודיים לביצוע חלק מפעולות המערכת. לדוגמה, במקום לפתח מערכת בקרה להנעת זרוע רובוטית באמצעות RT Linux, ניתן להשתמש במספר מעגלי בקרה חיצוניים שיקבלו פקודות ממערכת הבקרה הראשית (שלא תהייה מונחת זמן-אמת). בצורה כזו חלק ניכר מעומס המערכת ודרישות הזמן הקפדניות מועברות לרכיבים חיצוניים, ובכך מונעים את הצורך בשימוש במערכת הפעלה זמן-אמת. כמובן שה-tradeoff הוא הוספת חומרה ייעודית והעלאת הסיבוכיות של ארכיטקטורת המערכת הכללית.

מאמרי המשך

גרסאות שונות של Real Time Linux

RTAI Linux

התקנת RTAI Linux על בסיס Debian

הדגמת פיתוח זמן אמת – פיתוח בקר למנועי סרוו.

מאמר זה עוסק בבחירת לוח פיתוח משובץ לינוקס (Embedded Linux). המאמר סוקר שיקולים בבחירת לוח הפיתוח, מחירים, דרישות הספק, יכולות עיבוד ומימשקים (Interfaces), וסוקר מספר לוחות מומלצים בתחום.

לאחרונה התחלתי לעבוד על שני פרויקטים חדשים בתחום ה-Embedded:

1. פלטפורמה רובוטית עצמאית המסוגלת לנווט במרחב ע"י שימוש בסנסורים שונים ואלגוריתמים של עיבוד תמונה. הפלטפורמה מתקשרת עם מחשב בקרה (host) באמצעות WIFI.
2. מחשב לרכב – מערכת Embedded שתותקן ברכב, תהייה בעלת GPS ויכולות WIFI, ותתחבר למערכת השמע והווידאו ברכב. למערכת יהיה ניתן להעביר שירים, סרטים ומסלולי ניווט ישירות מהמחשב הביתי (drag and drop) בזמן שהרכב נמצא בחנייה.

לאחר בחינת הדרישות ומורכבות המימוש החלטתי כי הפלטפורמה האידיאלית למימוש שני הפרויקטים היא לוח משובץ לינוקס (Embedded Linux). הפרויקטים ידרשו קאסטומיזציה של הלוחות ה-Distribution והקרנל (פיתוח דרייברים).

בחירת לוח משובץ לינוקס הוא לא דבר פשוט היות וישנן ואריאציות רבות במחירים שונים, גדלים שונים, יכולות שונות ודרישות הספק שונות.לפרויקטים אלו קבעתי רף מחיר עליון של 150$, גודל לוח בקירוב 10×10 ס"מ, ודרישות ההספק של-1 אמפר במתח של 5v. לגבי היכולות – אפשרויות חיבוריות מגוונות הן היתרון הבולט ביותר עבורי (USB, Ethernet, Wifi, Serial), ויתרונות משמעותיים הם מעבד גרפי ומעבד שמע on-board.

להלן מספר אפשרויות מרכזיות העונות על הדרישות ומומלצות על ידי:

לוח פיתוח משובץ לינוקס – BeagleBoard

לוח הביגל (BeagleBoard) – לוח משובץ לינוקס קומפקטי, עם דרישות הספק נמוכות וללא מאווררים.

מחיר: 150$

תכונות (Features):

• 600 MHz ARM Cortex-A8 CPU
• 128mb LPDDR RAM, 256mb NAND Flash
• MMC+/SD/SDIO interface for memory or wireless connectivity
• OpenGL capable 2D/3D graphics accelerator
• Power consumption of 2W

חיבוריות וממשקים (Interfaces):

• USB 2.0 On The Go
• I2C, SPI
• RS-232
• DVI-D, S-Video out
• Stereo audio in and out
• JTAG (debugging)

מאחורי הביגל-בורד, כמו כמעט כל פרויקט בתחום הלינוקס והקוד הפתוח, עומדת קהיליית משתמשים חזקה המספקת מקור מידע עשיר מבוסס Wiki, פורומים, וערוץ IRC פעיל לאורך כל שעות היממה (גם אני שם, בכינוי lirtex).

מידע נוסף:

• דף הבית: http://beagleboard.org
• וויקי: http://elinux.org/BeagleBoard

לוח פיתוח משובץ לינוקס – Linux Stamp

לוח ה-LinuxStamp הוא לוח מבוסס חומרה פתוחה (open source) המבוסס על מעבד AT91RM9200 של חברת Atmel.

מחיר: 120$.

תכונות (Features)

• Atmel AT91RM9200 processor (Arm9 processor with MMU, 180Mhz operation)
• 32MB SDRAM (Only limited by 1x 54-TSOP SDRAM chip)
• 8MB SPI Dataflash
• 1x SD card slot
• POE capable (48v -> 5v Power supply can be implemented on a motherboard)

חיבוריות וממשקים (Interfaces):

• 1x 10/100 Ethernet
• 1x USB host port (allows wifi adapters, flash drives and other USB devices to be used)
• Serial debug port access through FTDI USB/Serial converter
• JTAG port

מידע נוסף:

• דף הבית: http://www.thelinuxstamp.com
• ווקי: http://opencircuits.com/Linuxstamp

לוח פיתוח משובץ לינוקס – Gumstix Overo

לוח משובץ לינוקס -Gumstix Oveo

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

מחיר: 150$

תכונות (Features):

• 600-MHz ARM Cortex™-A8 Core
• 256 MB low power DDR RAM
• 256 MB NAND Flash
• microSD adapter

חיבוריות וממשקים (Interfaces):

• I2C, PWM lines (6), A/D (6), 1-wire, UART, SPI, Camera in, Extra MMC lines
• audio in, audio out
• USB OTG signals, USB HS Host

החסרון המרכזי של ה-Gumstix לטעמי הוא העובדה שכל יכולות החיבוריות נחשפות בתור סיגנאלים (signals) ואין על הלוח את המחברים עצמם, מה שדורש לוח הרחבה ייעודי.

מסקנות

אחרי ניתוח היכולות השונות של הלוחות והשוואה בניהם, החלטתי לבחור בלוח ה-BeagleBoard. יש לו יותר features, ולטעמי הוא מנצח ביחס העלות\תועלת.

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

אפליקציות ושימושים

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

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

ניתן לראות מספר דוגמאות בסרטונים הבאים:

שימוש בבקר בתוכנה

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

Drivers ודוגמאות קוד

הבקר נתמך במערכות ההפעלה הבאות:

בקרוב אצרף דוגמאות קוד לשימוש בבקר ב- C#\.Net וב-C\C++.

מודל CAD ומעגל מודפס PCB

יתרונות לשימוש בבקר

מנועי סרוו כוללים מעגל שליטה פנימה המקבל אות בתדר מסויים ומסובב את ראש המנוע לזווית הנכונה בהתאם. בהרבה מקרים יצירת התדר המתאים ישירות ממרכז המערכת \ המחשב הינה פעולה לא רצויה, הדורשת משאבים ומפריעה לטיפול ברכיבים אחרים במערכת. במקרים כאלו נעדיף ליצור בקר נפרד שיקבל מספר X (כך ש X בין 0-255) ויניע את ראש המנוע ל X/255*360 מעלות. בקר זה ידאג ליצירת האות המתאים למנוע. רצוי מאד להשתמש בבקר כזה כאשר רוצים לחבר מנועי סרוו למחשב. חשבו למשל על הנעת 3 מנועי סרוו, שדורשים פולס של 1 מילישנייה. כמות הפסיקות (Interrupts) שתיווצר תכביד מאד על פעולת המחשב. מנגד כאשר משתמשים בבקר, מדובר בפסיקה אחת בלבד המוציאה את הזווית הרצויה לכל מנוע.

תכונות ומפרט טכני

קישורים

מאמר העוסק בסקירת ההבדלים בין FPGA ומיקרו בקרים (מיקרו-מעבדים, מיקרו-קונטרולרים). המאמר מציג את הטכנולוגיות השונות, הבדלים בינהן, והיתרונות והחסרונות של כל טכנולוגיה.

FPGA או מיקרו-בקר?

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

מהו FPGA?

FPGA – Field Programmable Gate Array הינו רכיב אלקטרוני מתכנת הבנוי כמעגל משולב (Integrated Circuit) המכיל בתוכו מספר רב מאוד של "בלוקים לוגיים" הניתנים לתכנות. בלוקים לוגיים הם אוסף של שעריים לוגיים (כמו שער NOT ו AND), רכיבים מורכבים יותר כגון בוררים ומפענחים ואף רכיבי זכרון מ flip-lops, בודדים ועד רגיסטרים ובלוקים שלמים של תאי זיכרון.
מעל שכבה זו נמצאת שכבה שבעת צריבת (התוכנית שכתב המשתמש) לרכיב FPGA יוצרת "קשרים" חשמליים בין רכיבים האלה ובין הבלוקים הלוגיים עצמם בהתאם להגדרות שקבע המתכנת ובכך נוצר מעגל חשמלי המתאים לקוד.

מהו מיקרו-בקר?

מיקרו-בקר (microcontroller) הינו מעגל משולב Integrated Circuit בו ממומשת מערכת שלמה SoC הכוללת יחידת עיבוד, ממשקים חיצוניים, זיכרונות ועוד. זהו רכיב שהחומרה בו קבועה ואנו טוענים אליו קוד לזכרון מיוחד שבזמן ריצה מפוענח ומבוצע.

הבדלים

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

שיקולים בבחירה

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

עדיין מבולבלים? לא מצליחים להחליט? לא בטוחים איזה מיקרו מעבד או איזה FPGA מתאים ביותר לאפליקציה שלכם?

התייעצו בפורומים המתאימים.

בעבר מיקרו-בקרים הכילו בעיקר מנגנוני קלט-פלט פשוטים, זיכרון ויחידת עיבוד.עם השנים, לא רק שגודל הזכרון גדל משמעותית ומהירות השעון עלתה, אלא שגם נוספו מרכיבים רבים שפעם היו ממומשים ברכיב נפרד חיצוני למעבד. כמו כן, נוספו טכנולוגיות שונות המסייעות לפעילות הבקר, וממשקי תקשורת שונים. כל אלה ממומשים היום על אותה פיסת סיליקון (system on chip). המאמר בא לסקור חלק גדול מהטכנולוגיות שניתן למצוא מימוש שלהם במיקרו-בקרים כיום.

שעון המערכת

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

שעון RC חיצוני – מחברים לרגל המתאימה של הבקר קבל+נגד בטור היוצרים גל בגלל תהליך הפריקה/טעינה של הקבל באמצעות הנגד. שיטה זו זולה שכן היא מצריכה רק שני רכיבים פשוטים אך הדיוק שלה נמוך (תלוי בדיוק הרכיבים) מומלץ להשתמש בשיטה זו ברכיבים בהם אין שעון פנימי ובאפליקציות הדורשות קצב שעון נמוך יחסית ולא חייבות דיוק רב בזמנים.

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

שעון חיצוני מגביש – crystal oscillator – שעון הפועל ע"י שני קבלים, גביש (לרוב קוורץ) ושער NOT ונגד (שני האחרונים ממומשים כבר בתור הבקר) יתרונו הגדול הוא בדיוק הגבוה ובכך שפעילותו כמעט ולא משתנה כתלות בטמפרטורה. זוהי הדרך המקובלת כיום להפקת אות שעון ורוב המערכות משתמשות בה.

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

שעון פנימי איטי – שעון RC פנימי נוסף המפיק תדר נמוך מאוד. מטרתו היא לשימוש כשהבקר במצב "שינה" SPLEEP. במיקרו-בקר ממומשים רכיבי PLL המחלקים/מכפילים את התדר ומסייעים לייצב אותו. באמצעותם ניתן ליצור לדוגמה תדר-שעון של 48MHZ באמצעות גביש של 12MHZ ע"י הכפלת התדר ב 4.
כל הגדרות השעונים ואופן פעולתם נעשים באמצעות תוכנה ע"י הגדרות מתאימות לרגיסטרים השולטים בפעולת השעון.
ישנם עוד מנגנונים הממומשים בחומרה כדי להבטיח עבודה תקינה עם השעון:

Fail-Safe Clock Monitor הינו מנגנון המזהה בעייה עם האות השעון החיצוני לבקר (למשל גביש) ומשנה אוטומאטית ובצורה חלקה את השעון הפנימי להיות שעון המערכת.

Two Speed Startup לאחר איתחול הבקר לוקח לשעון החיצוני (שנוצר מהגביש) זמן רב במונחי חומרה להתייצב. כדי לחסוך זמן זה יש מנגנון שמפעיל את המעבד באמצעות השעון הפנימי, ומתחיל להריץ את הקוד. לאחר שהשעות החיצוני מתייצב הוא הופך להיות השעון הראשי לבקר.

מוני זמן Timers

מוני זמן שימושיים באפליקציות בהן נדרש לספור זמן בצורה מדוייקת כגון: בקרת מנועים, תקשורת או מדידות שונות. מוני הזמן הם רגיסטרים שכאשר מקפלים פקודה מתאימה הם מתחילים לספור מחזורי שעון ברקע, כלומר ללא התערבות הבקר, והבקר יכול בפקודה מסויימת לבדוק את ערכם. המונים ממומשים בחומרה ורצים באופן עצמאי ולכן אין צורך בפעילות המעבד על מנת לקדם אותם (המעבד ניגש אליהם רק כדי לאתחל אותם, להורות על תחילת הספירה ולבדוק את ערכם. המונה מסוגל לשלוח פסיקה למעבד כאשר הגיע לערך מסויים או שבוצעה גלישה מערכו המקסימאלי. ניתן לבצע חלוקה של תדר השעון, כלומר לקבוע כל כמה מחזורי שעון יקודם המונה ביחידה אחת. לדוגמא מונה של 16 ביט יכול להכיל 64 אלף ערכים. אם נורה למונה זה להתקדם ביחס של 1:256 לשעון המערכת, יוכל המונה לספור עד 16 מליון מחזורי שעון (כשנייה עבור שעון בתדר של 16Mhz) רוב הבקרים ממומש יותר ממונה זמן אחד ע"מ לאפשר פעילות לכמה רכיבים במקביל.

מערכת ניהול הספק

מערכת ניהול הספק אחראית על הקצאת הספק לכל אחת מיחידות הבקר ולניהול נכון של משאב זה כדי לא לבזבז הספק כשאי צורך בכך. מיקרו-בקרים רבים נמצאים בהתקנים אלחוטיים הפועלים על סוללות. רבים מהתקנים אלה נמצאים ב"מצב פעולה" באחוז קטן מאוד מהזמן. לדוגמא, שלט רחוק לטלוויזה נמצא בפעולה רק כאשר אנו לוחצים על אחד הכפתורים. במרבית הזמן הוא סתם יושב על השולחן ואינו פעיל. נגן MP4 למשל, גם בזמן שהוא עובד ומשמיע שיר, אינו זקוק לחיבור ה USB שלו, לכן כל אנרגיה שתדרש ע"י רכיב ה USB שבו בזמן זה היא בזבוז. לפיכך ממומשת מערכת ניהול הספק במיקרו-בקרים. לבקר יש מספר מצבי עבודה, מצב רגיל, מצב המתנה idle ומצב שינה sleep. בכל מצב ניתן להגדיר אילו יחידות יפעלו ואילו לא, ומה יהיה מקור השעון של המערכת. למשל, במצב שינה נרצה מינימום דרישת הספק שכן במצב זה ניתן לומר שההתקן לא בשימוש (למרות שהוא לא מכובה לגמרי) מצב זה "נכסה" את מרבית ההתקני תקשורת, או שנעביר גם אותם למצב שינה (מצב שבו הם ידרשו מינימום הספק, אך יעירו" את המערכת באם תתקבל הודעה בקו התקשורת". כל שמהירות השעון של הבקר גדולה יותר, כך הוא מבזבז יותר הספק, לכן במצב שינה ננתק את השעון החיצוני ונשתמש בשעון RC הפנימי העובד בתדר נמוך ככל האפשר. שנם עוד אופציות רבות שניתן לשלוט על רובן באמצעות תוכנה ובכך להביא למינימום את צריכת ההספק של הבקר בכך להאריך את משך השימוש של המוצר לפני שתיגמר הסוללה.

זיכרון EEPROM

זהו זיכרון ROM הנוסף לזכרון הנתונים הרגיל של המעבד אך יתרונו הוא בכך שאינו נדיף.ֿזיכרון זה נועד לשמור נתונים או טבלאות שאינם חלק מקוד היצרן או שיתתכן שישתנו בעתיד. בזכרון זה לרוב יאוחסנו נתונים על המשתמשים, סיסמאות, ערכים משתנים כמו טבלאות המרה של מטבעות ועוד. עבר השתמשו למטרות אלה בזיכרון EEPROM חיצוני. שילובם של זיכרונות אלה על אותה פיסת סיליקון בתוך המעבד חוסך את השימוש בזיכרונות חיצוניים ולרוב מקצר את זמן הגישה אליהם. זיכרונות אלה לא מיועדים לשמירת מידע כגון תמונות, קבצים. לשמירת נתונים אלה משתמשים היום בזיכרונות FLASH חיצוניים. (יש כיום נסיונות לממש זכרונות FLASH על אותה פיסת סיליקון של הבקר, אך אלה פחות נפוצים ומוצלחים בגלל סיבות טכנולוגיות)

פעולת כפל מבוססת חומרה

פעולת כפל היא פעולה ארתמטית הדורשת זמן חישוב רב בגלל שמימושה באמצעות תוכנה הוא באמצעות חיבור. לדוגמא, ביצוע הפעולה 200*213 תידרוש לחבר 200 פעמים את המספר 213 למשתנה (רגיסטר בעל 8 ביט) כלומר תדרוש לולאה שתחזור 200 פעם על פעולת החיבור הבסיסית. באפליקציות בהן יש פעולות הכפלה לעיתים קרובות, הן יגזלו משאבי מערכת רבים. לכן בבקרים רבים ממומשת פעולת כפל בסיסית בחומרה, כלומר ישנו מנגנון המסוגל לבצע הכפלה של רגיסטר ברגיסטר במספר מצומצם של מחזורי שעון. יכולת זו מקנה למיקרו-בקרים רגילים להריץ אפליקציות שמומשו בעבר רק על רכיבי DSP יעודיים. לחברת MICROCHIP ישנה משפחת מיקרו-בקרים dsPIC הלוקחת את נושא הפעולות מתמטיות הממומשת בחומרה צעד אחד קדימה ומהווה פתרון זול ויעיל לאפליקציות רבות של עיבוד אותות שהיו נחלת רכיבי ה DSP בלבד.

פסיקות

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

CAPTURE/COMPARE/PWM

מנגנון זה שימושי באפליקציות בהן יש חשיבות גבוהה לדיוק בתזמון. זהו מודל האמאפשר לבצע פעילויות שמירה/השוואה/פלט כתלות בערכי מוני הזמן של המערכת. אופן הפעילות מוגדר בעת איתחול המודל ולאחר מכן רץ ברקע ללא תקורה מצד המעבד.
CAPTURE – פעולה זו שומרת לרגיסטר בזיכרון את ערך אחד ממוני הזמן כאשר מתרחשת פעולה מסויימת כגון שינוי ערך בכניסה מסויימת. פעולה זו שימושי לאפליקציות בהם רוצים למדוד במדוייק את משך הזמן בהן אחת הכניסות היא ב 1 לוגי וב 0 לוגי – כלומר בעיקר לניתוח אותות תקשורת שהמידול שלהם נעשה ע"פ הזמן.
COMPARE – פעולה זו משווה בין ערך רגיסטר מסויים לערך של אחד ממוני הזמן ומבצעת פעילות מסויימת כאשר הם שווים (למשל שינוי ערך של אחת היציאות הדיגיטאליות). פעולה זו שימושית אם אנחנו רוצים לגרום ליציאה להיות בערך מסויים לזמן נתון: נקבע את ערך הרגיסטר בהתאם לזמן שאנו רוצים ונאפס את הטיימר. מכאן מובטח לנו שערך היציאה ישתנה כאשר ערך הטיימר יגיע לערך שקבענו.
PWM -Pulse Width Modulation – באמצעות מודל זה ניתן לקבוע תדירות שינוי של ערך אחת היציאות בצורה מדוייקת, כלומר ניתן להגדיר כמה זמן היציאה תהיה גבוהה וכמה נמוכה. זהו מנגנון השימושי מאוד בבקרה על מנועים.

תקשורת טורית סינכרונית

מודל זה מאפשר לבקר לבצע תקשורת טורית פשוטה המיועדת בעיקר לתקשר עם רכיבים נוספים בסביבת הבקר כגון מתאמים שונים (LCD, ETHERNET, EEPROM ) או כל מעגל משולב אחד הנמצא בסביבת הבקר וממומשת בו אחת משני הפרוטוקולים SPI -Serial Peripheral Interface או פרוטוקול I2C . המודל ממש בחומרה את כל הרגיסטרים והבדיקות שיש לבצע בשביל לממש את פרוטוקולים אלה, כך שהמעבד בלב הבקר צריך רק לרשום לרגיסטר שליחה או לקרוא נתונים מרגיסטר הקבלה.

תקשורת טורית סיכרונית/אסיכרונית USART -Universal Synchronous Asynchronous Receiver Transmitter

ממיוש בחומרה של מודל תקשורת כללי, כולל באפרים לכניסות יציאות. באמצעות מודל זה ניתן לממש פרוטקולי תקשורת פשוטים בהם יש קו נפרד לשליחת מידע וקבלת מידע (half duplex) כמו RS-232 ודומיו. במודל ממומשים בחומרה בדיקות זוגיות, stop bit , וקצב קבלת/שליחת הנתונים כך שהמעבד מקבל/שולח את המידע באמצעות השמה פשוטה לרגיסטרי TX/RX. (המודל ממש את השכבות התחתונות במודל OSI)

ממיר אנאלוגי לדיגיטאלי ADC

במרבית הבקרים היום ממומש ממיר אנאלוגי לדיגיטאלי פנימי בחומרה. יכולת זו מאפשר לממש באמצעותו מערכות שבעבר נדרש להשתמש בהן בממיר חיצוני (יקר יותר, תופס יותר שטח). הממיר מסוגל לדגום אות אנאלוגי ממספר רב של כניסות (בבקרים עם מספר רגליים גבוה). הרזולוציה מגיעה כיום ל 10 ועד 16 ביט לכל דגימה. קצב הדגימה נע בין 50kbps בבקרים ישנים ועד 1Mbps בטובים יותר. (בכל פעם כניסה אנאלוגית אחרת מחוברת אל הדוגם לכן אם יש כמה כניסות אנאלוגיות אז הקצב הכללי יורד). קצב זה מתאים לדגימה של אותות מחיישנים שונים ואפילו אותות דיבור. רמות המתחים שבהם מתבצעת הדגימה יכולה להיות שונה מערך המתח שמקבל הבקר. למשל בקר שעובד על 0-5V יכול לדגום אות אנאלוגי הנע בין 0-10V או 3- ל 3 וולט.

Analog Comparator Module

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

USB

ישנם מיקרו-בקרים שממומש בהם בחומרה יחידת USB המתקשרת עם המחשב. ישנם רגיסטרים מיוחדים לשמירת הגדרות האיתחול של ההתקן, ולמימוש מנגנון התקשורת, כמו כן קיים ממיר ל 3.3V לפעולת ה USB . מימוש זה חוסך שימוש ברכיב מיוחד המממש תקשורת USB ומאפשר עבודה בקצבי גבוהים של 480Mbps FULL SPEED USB.

Ethernet

בדומה ל USB, ישנם מיקרו-בקרים שממומש בתוכם ממשק ETHERNET שמממש את שני השכבות התחתונות של התקשורת בחומרה, ומאפשר לליבת המעבד לקבל את ההודעות המתאימות רק לרכיב. (ממומשת שכבת ה MAC)

CAN – Controller Area Network

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

High/Low-Voltage Detect module

מנגנון זה מאפשר לבצע בקרה על מתח הפעולה של המיקרו-בקר. ניתן להגדיר באמצעות התוכנה ערך לרגיסטר מסויים בו קובעים רמת מתח מסויימת (למשל ניתן לקבוע 3.8V) במקרה ומתח ההזנה של הבקר VDD מגיע לערך זה, המנגנון ייצר פסיקה שבאמצעות ניתן להגדיר לבקר מה לבצע במקרה זה. מנגנון זה שימושי למקרים של נפילת מתח פתאומית. במקרה שמקור המתח של הבקר מנותק בצורה פתאומית, הוא יכול להמשיך לפעול עוד כמה מיקרו/מילי שניות (תלוי בקבלים שונים במערכת) בזמן זה הבקר יכול לבצע פעולות חשובות לפני שיפסיק לעבוד כגון שמירה של נתונים חשובים לזיכרון הלא נדיף ֿֿ, או ביצוע נעילה/התראה במערכות אזעקה. לדוגמא, נניח שמתח ההזנה שלנו VDD הוא 5V. ניתן לכוון את המנגנון לערך של 4V. בעת ניתוק המתח לבקר תרד רמת המתח במהירות. כשתגיע ל 4V המנגנון יזהה זאת ויבצע פסיקה. והבקר יעבור לבצע קטע קוד שישמור נתונים שונים. ויהיה לו זמן לבצע זאת עד אשר מתח ההזנה ירד לרמה של כ 2V שבה הבקר כבר לא יכול לתפקד כראוי.אם מתכננים את קיבולי המערכת ואת הקוד נכון, זמן זה אמור להספיק. שימוש נוסף למנגנון הוא לאפליקציות המשתמשות בסוללה. עם השימוש בסוללה, ערך המתח שהיא מסוגלת לספק יורד. מכיוון שאנו לא רוצים שיווצר מצב שערך זה ירד לרמת נמוכה בה הבקר לא יוכל לתפקד כראוי (דבר שיכול לגרום לו להתקע בצורות שונות או לבצע דברים שלא התכוונו שיבצע) אז ניתן להגדיר שמרמת מתח מסויימת ההתקן יכבה את עצמו, או לעליפין יציג למשתמש הודעה על כך שהסוללה מתרוקנת ויש להחליפה.

תהליך ה RESET

כדי לבצע הפעלה תקינה של הבקרים ממומשים בחומרה מספר מנגנוניםשמטרתם ליצור איתחול תקין:
Power on Reset
מנגנון זה אחרי לכן שבעת חיבור הבקר למקור מתח, הוא יעבור למצב RESET. פעולה זו חשובה כדי שהבקר לא יתחיל לעבור עם ערכי רגיסטרים שגויים. כאשר הבקר עובר למצב RESET הוא מתחיל להריץ את הקוד ממקום ידוע ומבצע שורה של פעולות איתחול ולכן חשוב שיתחיל כך.
Power up Timer
זהו מונה זמן הפועל מהרגע שניתן אות RESET למשך זמן קצר של כמה מילי-שניות. תפקידו הוא להשהות את תחילת פעולת הבקר עד אשר מקור המתח יתייצב
oscillator Start-up Timer
זהו מונה זמן המופעל עם סיום ה Power-up Timer ותפקידו לתת לשעון מספיק זמן ע"מ להתייצב ולספק מחזור שעון מדוייק.
Brown-out Reset -BOR מנגנון המבצע פעולת RESET כשמתח ההזנהנמוך מערך מסויים שנקבע בתוכנה, ומשאיר את המעבד במצב זה עד שמתח הספק יעלה שוב.
WatchDog Timer – WDT זהו מנגנון שאמור לבצע פעולת RESETבמידה ויש חשש שהמעבד "נתקע" בגלל סיבה מסויימת כמו באג בתוכנה. המימוש הוא באמצעות מונה זמן שניתן לכוון את ערכו. מונה זה מתחיל לרוץ לאחר אתחול הבקר. באם עבר משך זמן מסויים ומונה זה לא אופס, הוא יגיע לערכו המקסימאלי ואז יבצע RESET למערכת. אם מאפשרים את פעולתו יש לדאוג לאפס אותו בקוד בכל כמה זמן. במקרה והתוכנה מגיעה לקטע קוד בו היא נתקעת (לולאה אינסופית, מצב המתנה לקלט חיצוני שלא מגיע, גלישת זיכרון ועוד) אז מונה ה wathcdog ירוץ עד שיגיע לערכו המקסימלי ואז יאתחל את המערכת ויחזיר אותה למצב יציב.

Code Protection

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

In-Circuit Serial Programming

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

סיכום

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

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

לרובוט קוראים Big Dog, וכשמו הוא רובוט ארבע-רגלי בגודל של כלב גדול, או פרדת מסע קטנה. הרובוט מסוגל ללכת בשטח קשה, לרוץ, לקפוץ ולעלות במעלה מדרונות תלולים וקשי מעבר. הרובוט מונע ע"י מנוע בעירה המספק אנרגיה למערכת הנעה הידראולית. רגליו של Big Dog בנויות לפי מבניהן של רגלי בהמת משא וגם נראה כאילו הן מתנהגות בהתאם. ברובוט משולב מחשב ששולט בתנועה ומנתח מידע החישנים הרבים בהם משתמש הרובוט – חיישני לחץ עבור המפרקים, כוח המופעל במפרקים, מגע עם הקרקע, משקל מטען, גירוסקופ, ומערכת ראיה סטריאוסקופית.

הרובוט מפותח ע"י Boston Dynamics במימון DARPA.

מפרט טכני

מימדי הרובוט: 1 מטר (אורך), 0.75 מטר (גובה) ומשקלו 75 קילוגרם. מהירות ריצה: 6.5 קמ"ש
יכולת טיפוס מדרון בשיפוע של 35 מעלות
יכולת נשיאה של כ-150 ק"ג משא.

סרטון הדגמה (שימו לב במיוחד להליכה בשלג, על קרח, ולטיפוס על פסולת הלבנים)

מאמר זה סוקר את ההבדלם העיקריים בין שתי סדרות של בקרים מתוכנתים של שתים מהחברות המובילות בשוק בקרי ה 8 ביט – ATMEL ו-MicroChip. הסקירה תתמקד בקבוצה זו של במיקרו-בקרים המתאפינים במחיר זול יחסית (1-7$), צריכת הספק נמוכה ושטח קטן, והינם בעלי יכולות מגוונות, המספיקות למערכות רבות שאינן דורשות יכולות עיבוד אותות גבוהות. תחילה אסקור את ההבדלים העיקריים בין הטכנולוגיות של החברות ולאחר מכן אשווה קריטריונים שונים בין שני רכיבים דומים משתי החברות.

ארכיטקטורת מעבד

זיכרון

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

מנגנון פסיקות

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

מבנה הרגיסטרים ואוצר פקודות

ל PIC יש רק גריסטר לשימוש כללי אחד, בעוד של AVR יש 32 רגיסטרים. יתרון זה יכול לקצר חישוב של פעולות מורכבות, שכן ניתן לשמור נתונים זמניים על יותר רגיסטרים ובכך להקטין את מחזורי השעון הנדרשים לפעולה. לרכיבי AVR אוצר פקודות גדול יותר הממומש בחומרה, המתבצעות ב1-2 מחזורי שעון, מה שיכול להאיץ את ביצועי המעבד.

צריכת הספק

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

מחיר

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

צורבים, כלי איתור שגיאות (debug) ופיתוח

MicroChip משתמשת בפרוטוקול עצמאי שלה עבור כלי איתור השגיאות שלה (debugger) הנקרא ICD- In Circuit Debugger, בעוד ש ATMEL עושה שימוש בפרוטוקול JTAG הסטנדרטי.

בנוסף, לרכיבי PIC יש אפשרות לתכנות של עד שלוש נקודות עצירה (BreakPoints) – מה שאומר שניתן לראות את מצב הרגיסטרים במערכת רק ב 3 נקודות שונות בכל הרצה. זוהי מגבלה מהותית שמנסיוני האישי מקשה את פעולת איתור השגיאות. בבקרים של חברת ATMEL אין הגבלה כזו הדוקה, כך שתהליך האיתור השגיאות קל משמעותית.

סביבת פיתוח וקומפיילרים

חברת MicroChip מציעה את סביבת הפיתוח (IDE) שלה הנקראת MPLAB. בסביבה זו ניתן לעבוד עם קומפיילר אסמבלר חינמי ועם סידרה של קומפילרים לשפת C עבור ארכיטקטורות מעבד השונות – C18,C30 הכוללות ספריות נוחות מאוד לשימוש עבור התקנים הפריפריאליים של הבקרים.

ישנם עוד חברות רבות המציעות קומפיילי C עבור מעבדי PIC כגון HighTech ועוד.
מנסיוני האישי, סביבת פיתוח זו אינה נוחה (ונחותה בהרבה מסביבות פיתוח קוד ל PC כגון סביבת הפיתוח VisualStudio של מייקרוסופט)

ATMEL מציעה את סביבת הפיתוח שלה AVR STUDIO שהיא נוחה למדי, אך קצת כבדה ומסורבלת.
יש גם את IAR שהיא סביבה מצויינת. יש לא מעט קומפילרים ל C עבור בקרי AVR ואף קומפיילר gcc.

השוואה בין שני רכיבים ספציפיים משתי החברות

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

הקריטריונים המרכזיים שחיפשתי היו:

1. מחיר בסביבות ה 4$
2. גודל הזיכרון הפנימי: כמות הקוד שניתן לכתוב לבקר.
3. ממשק תקשורת מהר – במידה והחומרה שבליבה הבקר תתממשק למחשב, רצוי שיהיה לה ממשק בעל קצב העברת נתונים גבוה ואמין, לכן בחרתי ברכיבים להם יכולת מובנת לממשק USB.

הרכיבים שבחרתי הם: ATMega32U של Atmel ו PIC18F4550 של Microchip.

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

רואים כי אין הבדלים גדולים בין שני הרכיבים. יתרון קל ל PIC בצריכת הספק במצב שינה, ומספר פיני I/O.
יתרון ל AVR בנפח זכרון, בתכנון יותר נכון של ארכיטקטורת ה ADC והטיימרים.

סיכום

היתרונות הבולטים של רכיבי AVR הם בסביבת פיתוח נוחה יותר, בעיקר בגלל ה debugger המוגבל של MicroChip ובגלל ארכיטקטורת מערכת נכונה יותר.

היתרונות של מעבדי PIC הם סף כניסה נמוך יותר, צריכת זרם נמוכה, וכמות I/O גדולה יותר לאריזה.

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

מהו מנוע סרוו?

מנוע סרוו הוא מנוע זרם ישר (DC Motor) בעל מערכת תמסורת פנימית של גלגלי שיניים ובקרה אלקטרונית על מיקום המנוע. מה שמיחד מנועי סרוו היא העובדה שהם אינם מסתובבים בצורה חופשית כמו מנועי DC, אלא נעים על פי זווית – לרוב בין 0 ל-180 מעלות.

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

שימושים שונים למנועי סרוו ברובוטיקה

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

יתרונות וחסרונות של שימוש במנועי סרוו

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

כיצד עובד מנוע סרוו?

כיצד שולטים במנוע סרוו?

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

לדוגמה, כאשר נספק למנוע גל בו רוחב הפולס הוא 1מילי-שנייה, המנוע ינוע אל זוויתו המינימאלית – 0 מעלות.
כאשר נספק למנוע גל בו רוחב הפולס הוא 1.5 מילי-שנייה, המנוע ינוע אל זוויתו האמצעית – 90 מעלות.
כאשר נספק למנוע גל בו רוחב הפולס הוא 2 מילי-שנייה, המנוע ינוע אל זוויתו הגדולה ביותר – 180 מעלות.

תרשים סכמטי:

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

מתח מנועי סרוו

מנועי סרוו עובדים בטווח שונה של מתחים, ובדרך כלל בין 4.8 ל-6 וולט. הסיבה לשימוש בסטנדרט הזה היא הקרבה לרמת TTL (שהיא 5 וולט) שבה פועלים רוב המקרו-מעבדים שמשמים לשליטה על מנועי הסרוו.

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

זרם מנועי סרוו

חיווט מנועי סרוו

לכל מנועי הסרוו יש שלושה חוטים:

חוט שחור או חום שהוא אדמה (-)

חוט אדום שהוא המתח (+)

חוט צהוב, כתום או לבן שהוא חוט האות לשליטה במנוע.

לדוגמה במנועי הסרוו הנפוצים של Hitec \ Futaba :

בניית בקר למנוע סרוו

כאמור, מנועי סרוו כוללים מעגל שליטה פנימה המקבל אות בתדר מסויים ומסובב את ראש המנוע לזווית הנכונה בהתאם. בהרבה מקרים יצירת התדר המתאים ישירות ממרכז המערכת הינה פעולה לא רצויה, הדורשת משאבים ומפריעה לטיפול ברכיבים אחרים במערכת. במקרים כאלו נעדיף ליצור בקר נפרד שיקבל מספר X (כך ש X בין 0-255) ויניע את ראש המנוע ל X/255*360 מעלות. בקר זה ידאג ליצירת האות המתאים למנוע. רצוי מאד להשתמש בבקר כזה כאשר רוצים לחבר מנועי סרוו למחשב. חשבו למשל על הנעת 3 מנועי סרוו, שדורשים פולס של 1 מילישנייה. כמות הפסיקות (Interrupts) שתיווצר תכביד מאד על פעולת המחשב. מנגד כאשר משתמשים בבקר, מדובר בפסיקה אחת בלבד המוציאה את הזווית הרצויה לכל מנוע.

פרטים נוספים על הבקר ניתן לקרוא בעמוד בקר מנועי סרוו.

]]> http://www.lirtex.com/he/%d7%a8%d7%95%d7%91%d7%95%d7%98%d7%99%d7%a7%d7%94/%d7%9e%d7%a0%d7%95%d7%a2-%d7%a1%d7%a8%d7%95%d7%95-servo-%d7%9e%d7%99%d7%93%d7%a2-%d7%a9%d7%99%d7%9e%d7%95%d7%a9%d7%99%d7%9d-%d7%99%d7%aa%d7%a8%d7%95%d7%a0%d7%95%d7%aa-%d7%95%d7%97%d7%a1%d7%a8/feed/ 5 http://www.lirtex.com/he/%d7%91%d7%9c%d7%95%d7%92/%d7%aa%d7%9b%d7%a0%d7%95%d7%aa-%d7%a8%d7%9b%d7%99%d7%91%d7%99-smt/ http://www.lirtex.com/he/%d7%91%d7%9c%d7%95%d7%92/%d7%aa%d7%9b%d7%a0%d7%95%d7%aa-%d7%a8%d7%9b%d7%99%d7%91%d7%99-smt/#comments Wed, 11 Jun 2008 13:39:21 +0000 ‫ליאור חן‬ http://www.lirtex.com/hex/?p=108

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

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

אז מה עושים בכל זאת?

יש מספר פתרונות. הפתרון הפשוט ביותר, אבל גם היקר ביותר, הוא לקנות מתאמים (adapters) אליהם ניתן להכניס את רכיב ה-SMT והם ממירים אותו לרכיב Through-hole (DIP) רגיל.

ממירים כאלו קיימים עבור תצורות שונות של רכיבים, החל מ-SOIC, QFN וכו'.

טווח המחירים הוא די גדול, החל מדולרים בודדים למתאם פשוט ל-SOIC ועד מאות דולרים עבור מתאמי QFN. לי יש מספר מתאמים עבור מעבדי אלטרה (Altera) בתצורות QFN.

פתרון נוסף הוא יצירת Header על המעגל המודפס שיאפשר תכנות של הרכיב לאחר שכבר הולחם למעגל. החסרון בפתרון זה הוא השטח שתופס ה-header – יוצא שכל השטח שהורווח עקב השימוש ברכיב SMT הופסד עבור ה-Header. היתרון הוא אפשור של עדכון גרסת Firmware ישירות לתוך המעגל.

פתרון אפשרי נוסף, שלא עולה מאות דולרים הוא הלחמת חוט Wire-wrap לרגלי הרכיב, תכנות שלו, הסרת החוטים המולחמים, והלחמת הרכיב למעגל. בדוגמה הזו ניתן לראות רכיב PIC12F629 SOIC שצרבתי בצורה הזו.

קצת סיזיפי אבל לא עולה מאות דולרים ועושה את העבודה.

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

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

מודל מתוכנן באמצעות מחשב (CAD)

דוגמה להגדרות בתוכנת Linux CNC – EMC2

קישורים

• מכונות CNC – מידע על מכונות CNC, מבנה, תיב"ם, G-Code, בניית מכונת CNC ביתית

לוח פיתוח למיקרו-בקרים של חברת MicroChip הכוללת יציאות USB, RS-232, IR, לוח מקשים, תצוגת LCD ועוד.

למה צריך ערכת פיתוח?

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

• אמצעי קלט – לוח מקשים, לחצנים, מתגים, מתגי סיבוב ועוד.
• אמצעי פלט – מסך LCD, תצוגת 7segment, לדים בצבעים שונים, יציאת שמע ועוד.
• אמצעי תקשורת – חיבורים להתממשקות לרכיבי חומרה אחרים או מחשב כגון: USB2, חיבור סיריאלי RS232, חיבור ethernet ועוד.
• חיישנים וכניסות אנלוגיות – כגון מד טמפרטורה, מד נפח, כניסת שמע ועוד.
• ספק מתח – יחידה שתמיר את המתח החיצוני לדרישת ההספק של כל אחד מיחידות האחרות במוצר.

לפיכך דיאגרמה כללית של מוצר תראה כך:

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

יתרונות:

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

יכולות ערכת הפיתוח הבסיסית

מבוססת על מיקרומעבד בעל יכולות גבוהות PIC18F4550.

1. אספקת מתח:
   1. באמצעות מקור מתח DC חיצוני (ספק מתח)
   2. באמצעות סוללה 9V
   3. באמצעות מתח מה USB

   המעבר בין מקורות המתח נעשה בצורה אוטומאטית.

2. תצוגת LCD 2 שורות, 20 תווים בכל שורה, עם תאורה אחורית
3. לוח מקשים 4×4 הכולל מספרים ואותיות (ניתן להכניס מלל בדומה לכתיבה בטלפון נייד)
4. שלושה לדים לבקרה על יציאות שונות
5. נגד משתנה להדמיית כניסה אנלוגית
6. שני לחצנים, ומפסק 2 מצבים.
7. ממשק ל USB 2.0 HIGH SPEED
8. ממשק סיריאלי לחיבור ליציאת COM RS232
9. חיבור לצורב המתאים לצריבת הקוד ללא הוצאת המעבד מהמעגל ICP
10. חיבור נוח לכל הרגליים של המיקרו מעבד על מנת לאפשר הוספות נדרשות על מטריצה וממשק חיבור ללחות עזר מתקדמים (בתכנון)
11. שעון המערכת ממתנד/גבי/או שעון פנימי של המיקרומעבד
12. אפשרות למתאמים שונים, לחיבור רכיבים בעל מספר רגליים שונה מ 6 עד 64 רגליים כולל רכיבי SMD (בנפרד)

תוספות מתוכננות לערכה המתקדמת (בתכנון)

1. ממשק לתצוגות 7segment
2. משדר ומקלט IR
3. צורב מובנה בלוח פיתוח
4. מד מפרטורה
5. בקר למנוע
6. לחצנים ולדים נוספים
7. יחידה לממשק ל ethernet
8. יחידה לחיבור כרטיס זיכרון SD-RAM

אז מה הייחוד של הלוח שלנו?

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