יום שבת, 20 בדצמבר 2014

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?

יום שבת, 1 בנובמבר 2014

Deep Packet Inspection With C



מערכות FireWall בדר"כ בוחנות את החבילות שעוברות דרכן רק על ידי אימות של כתובות ופורטים מול רשימת חוקים, אבל עם הזמן הבינו שזה לא מספיק טוב ויש לנתח את המידע עצמו שעובר בחבילה על מנת לזהות התקפות שמשפיעות על השירות עצמו, נדרשה חשיבה חדשה ועם הזמן צצו מערכות IDS \ IPS שבעזרתם ניתן לבצע בדיקות שמבוססות על תבניות ולחפש קוד זדוני בתוך החבילה, פרוייקט מאוד מפורסם ונמצא בשימוש רחב במערכות כאלו נקרא Snort שמכיל המון תבניות להתקפות מוכרות.

שימו לב!
  • המאמר נכתב על Fedora 13.
  • הקוד נערך ב Eclipse.
כל חבילה שמגיעה למכונה עוברת בדיקה מול החוקים שהוגדרו ב iptables שעובד מול ה NetFilter שיושב ב Kernel, אם החוקים מאפשרים להעביר את החבילה ליעד ה Netfilter יאשר את החבילה (NF_ACCEPT) אבל במקרה שהחוקים חוסמים אותה הוא יפיל את החבילה (NF_DROP), אלה 2 הפעולות הבסיסיות שנמצאות בכל Firewall אבל זה לא מספיק וצריך לחפור יותר פנימה, ניתן לרשום חוק שמפנה את המידע (NF_QUEUE) למחסנית שמאפשרת גישה לתוכניות מעולם ה UserSpace לנתח את החבילות ולחרוץ את גורלם.

התוכנית קובעת את גורל החבילה

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

#: iptables -A INPUT  -j NFQUEUE --queue-num 0 --queue-balance

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

#: iptables -A INPUT  -j NFQUEUE --queue-balance 0:3
#: iptables -A OUTPUT  -j NFQUEUE --queue-balance 4:8


Libnetfilter_queue Library

ספריה רשמית שמאפשרת לנהל את החבילות שנמצאות במחסניות בעזרת עבודה מול Netlink דרך Unix Domain Socket, היא מחליפה ספרייה ישנה יותר שנקראת ip_queue והיא נמצאת כמעט בכל Distribution של Linux, אבל בשביל לעבוד איתה יש להוריד את ה Headers ולהכין את ה Eclipse:

#: yum install libnetfilter_queue
#: yum install libnetfilter_queue-devel


נשלב את הספריות המתאימות ב Linker:





קוד

פונקצית Main מייצרת מערך של Threads שכל אחד מהם מתחבר ל Queue אחר, כאשר תגיע חבילה לאחת מהמחסניות, פונקציית packetHandler תרוץ ודרכה ננתח את המידע, לצורך הדוגמה כאשר נזהה את המילה facebook בתוכן החבילה נפיל אותה ונחסום את הגישה.

filterQueue.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <netinet/in.h>
#include <linux/types.h>
#include <string.h>

/* for ethernet header */
#include<net/ethernet.h>

/* for UDP header */
#include<linux/udp.h>

/* for TCP header */
#include<linux/tcp.h>

/* for IP header */
#include<linux/ip.h>

/*  -20 (maximum priority) */
#include <sys/time.h>
#include <sys/resource.h>

/* for NF_ACCEPT */
#include <linux/netfilter.h>

/* for Threads */
#include <pthread.h>

/* for Queue */
#include <libnetfilter_queue/libnetfilter_queue.h>

#define NUM_THREADS     15

pthread_t threads[NUM_THREADS];

void printTCP(unsigned char *buffer) {

unsigned short iphdrlen;

struct iphdr *iph = (struct iphdr *) (buffer + sizeof(struct ethhdr));
iphdrlen = iph->ihl * 4;

struct tcphdr *tcph = (struct tcphdr *) (buffer + iphdrlen
+ sizeof(struct ethhdr));

int header_size = sizeof(struct ethhdr) + iphdrlen + tcph->doff * 4;

printf("| Packet Type: TCP \n");
printf("|-Source Port      : %u\n", ntohs(tcph->source));
printf("|-Destination Port : %u\n", ntohs(tcph->dest));
printf("|-Sequence Number    : %u\n", ntohl(tcph->seq));
printf("|-Acknowledge Number : %u\n", ntohl(tcph->ack_seq));
printf("|-Header Length      : %d DWORDS or %d BYTES\n",
(unsigned int) tcph->doff, (unsigned int) tcph->doff * 4);
printf("|-CWR Flag : %d\n", (unsigned int) tcph->cwr);
printf("|-ECN Flag : %d\n", (unsigned int) tcph->ece);
printf("|-Urgent Flag          : %d\n", (unsigned int) tcph->urg);
printf("|-Acknowledgement Flag : %d\n", (unsigned int) tcph->ack);
printf("|-Push Flag            : %d\n", (unsigned int) tcph->psh);
printf("|-Reset Flag           : %d\n", (unsigned int) tcph->rst);
printf("|-Synchronise Flag     : %d\n", (unsigned int) tcph->syn);
printf("|-Finish Flag          : %d\n", (unsigned int) tcph->fin);
printf("|-Window         : %d\n", ntohs(tcph->window));
printf("|-Checksum       : %d\n", ntohs(tcph->check));
printf("|-Urgent Pointer : %d\n", tcph->urg_ptr);
}

void printUDP(unsigned char *buffer) {
unsigned short iphdrlen;

struct iphdr *iph = (struct iphdr *) (buffer + sizeof(struct ethhdr));
iphdrlen = iph->ihl * 4;

struct udphdr *udph = (struct udphdr*) (buffer + iphdrlen
+ sizeof(struct ethhdr));

int header_size = sizeof(struct ethhdr) + iphdrlen + sizeof udph;

printf("| Packet Type: UDP \n");
printf("|-Source Port      : %u\n", ntohs(udph->source));
printf("|-Destination Port : %u\n", ntohs(udph->dest));
printf("|-UDP Length : %u\n", ntohs(udph->len));
printf("|-UDP Checksum : %u\n", ntohs(udph->check));

}

char * getText(unsigned char * data, char Size) {

char * text = malloc(Size);
int i = 0;

for (i = 0; i < Size; i++) {
if (data[i] >= 32 && data[i] <= 128)
text[i] = (unsigned char) data[i];
else
text[i] = '.';
}
return text;

}

u_int32_t analyzePacket(struct nfq_data *tb, int *blockFlag) {

//packet id in the queue
int id = 0;

//the queue header
struct nfqnl_msg_packet_hdr *ph;

//the packet
char *data;

//packet size
int ret;

//extracting the queue header
ph = nfq_get_msg_packet_hdr(tb);

//getting the id of the packet in the queue
if (ph)
id = ntohl(ph->packet_id);

//getting the length and the payload of the packet
ret = nfq_get_payload(tb, &data);
if (ret >= 0) {

printf("Packet Received: %d \n", ret);

/* extracting the ipheader from packet */
struct sockaddr_in source, dest;
unsigned short iphdrlen;

struct iphdr *iph = ((struct iphdr *) data);
iphdrlen = iph->ihl * 4;

memset(&source, 0, sizeof(source));
source.sin_addr.s_addr = iph->saddr;

memset(&dest, 0, sizeof(dest));
dest.sin_addr.s_addr = iph->daddr;

printf("|-Source IP: %s\n", inet_ntoa(source.sin_addr));
printf("|-Destination IP: %s\n", inet_ntoa(dest.sin_addr));
printf("|-Checking for Protocol: \n");

if (iph->protocol == 6) {
printTCP(data);
} else if (iph->protocol == 17) {
printUDP(data);
}

printf("|-Extracting Payload: \n");

char * text = getText(data, ret);

//filtering requests for facebook
if (text && text[0] != '\0') {
printf("\n %s \n", text);
ret = strstr(text, "facebook");
if (ret == 0)
//not found in string
*blockFlag = 0;
else
//found in string
*blockFlag = 1;
}

//release the packet
free(text);


}
//return the queue id
return id;

}

int packetHandler(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg, struct nfq_data *nfa,
void *data) {

printf("entering callback \n");

//when to drop
int blockFlag = 0;

//analyze the packet and return the packet id in the queue
u_int32_t id = analyzePacket(nfa, &blockFlag);

//this is the point where we decide the destiny of the packet
if (blockFlag == 0)
return nfq_set_verdict(qh, id, NF_ACCEPT, 0, NULL);
else
return nfq_set_verdict(qh, id, NF_DROP, 0, NULL);



}

void *QueueThread(void *threadid) {

//thread id
long tid;
tid = (long) threadid;


struct nfq_handle *h;
struct nfq_q_handle *qh;
char buf[128000] __attribute__ ((aligned));

//pointers and descriptors
int fd;
int rv;
int ql;


printf("open handle to the netfilter_queue - > Thread: %d \n", tid);
h = nfq_open();
if (!h) {
fprintf(stderr, "cannot open nfq_open()\n");
return NULL;
}

//unbinding previous procfs
if (nfq_unbind_pf(h, AF_INET) < 0) {
fprintf(stderr, "error during nfq_unbind_pf()\n");
return NULL;
}

//binding the netlink procfs
if (nfq_bind_pf(h, AF_INET) < 0) {
fprintf(stderr, "error during nfq_bind_pf()\n");
return NULL;
}

//connet the thread for specific socket
printf("binding this socket to queue '%d'\n", tid);
qh = nfq_create_queue(h, tid, &packetHandler, NULL);
if (!qh) {
fprintf(stderr, "error during nfq_create_queue()\n");
return NULL;
}

//set queue length before start dropping packages
ql = nfq_set_queue_maxlen(qh, 100000);

//set the queue for copy mode
if (nfq_set_mode(qh, NFQNL_COPY_PACKET, 0xffff) < 0) {
fprintf(stderr, "can't set packet_copy mode\n");
return NULL;
}

//getting the file descriptor
fd = nfq_fd(h);

while ((rv = recv(fd, buf, sizeof(buf), 0)) && rv >= 0) {
printf("pkt received in Thread: %d \n", tid);
nfq_handle_packet(h, buf, rv);
}

printf("unbinding from queue Thread: %d  \n", tid);
nfq_destroy_queue(qh);

printf("closing library handle\n");
nfq_close(h);

return NULL;

}

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

//set process priority
setpriority(PRIO_PROCESS, 0, -20);

int rc;
long balancerSocket;
for (balancerSocket = 0; balancerSocket < NUM_THREADS; balancerSocket++) {
printf("In main: creating thread %ld\n", balancerSocket);

//send the balancer socket for the queue
rc = pthread_create(&threads[balancerSocket], NULL, QueueThread,
(void *) balancerSocket);

if (rc) {
printf("ERROR; return code from pthread_create() is %d\n", rc);
exit(-1);
}
}

while (1) {
sleep(10);
}

//destroy all threads
pthread_exit(NULL);
}

טיפ קטן

אם רוצים לעקוב אחרי העומסים במחסניות ניתן לקרוא את הקובץ nfnetlink_queue:

/proc/net/netfilter


סיכום

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

הורדת התוכנית


מקורות



יום שלישי, 23 בספטמבר 2014

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 פשוט, יחד עם צבעים וחדות מעולה.

שנה טובה!

יום שבת, 6 בספטמבר 2014

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

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

יום שבת, 23 באוגוסט 2014

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.

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


יום שבת, 16 באוגוסט 2014

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

יש פטל?







יום שני, 14 ביולי 2014

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 על מנת להציג את הקואורדינטות על המפה.

איפה אני?!

יום שישי, 4 ביולי 2014

3D Printing



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

יצרנים:

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

גאווה ישראלית
  • Objet - השחקנית הותיקה בתחום, אפשר להגיד החלוצה בעולם הדפסת התלת מימד, זו חברה ישראלית שממוקמת ברחובות ולא מזמן חתמה הסכם עם חברה אמריקאית במליוני דולרים.
         איכות: הטובה ביותר שיש בשוק 25 מיקרון.
         מחיר: יקרה מאוד, רק למביני עניין.
         חומרים: פולימר רגיש לאור,קיימים סוגים שונים של חומרים לכל מטרה.
         תחזוקה: מתוחזקת ע"י אנשי מקצוע.
         אתר היצרןstratasys.com


כל הסוגים וכל החומרים במקום אחד
  • 3DSYSTEM - חברה אמריקאית שמחזיקה מספר סוגים של מדפסות, היא רכשה את חברת Zcrop שהחזיקה בסדרה האיכותית של מדפסות שנקראו Zprinter שמאפשרות להזריק צבע רגיל של מדפסת ביתית לאובייקט תוך כדי ההדפסה.
         איכות: איכותית מאוד, 80 מיקרון.
         מחיר: יקרה מאוד, רק למביני עניין.
         חומרים: פולימר אבקתי בשילוב דבק עם צבע.
         תחזוקה: מתוחזקת ע"י אנשי מקצוע.
         אתר היצרן3dsystems.com


הפכו למוצר מסחרי
  • Makerbot - בין החברות הראשונות שלקחו את רעיון ה OpenSource של מדפסת ה Reprap והפכו אותו למסחרי, היא מייצרת סדרת מדפסות בגדלים שונים המובססות על טכנולוגיה FDM, על אחת המדפסות ארחיב בהמשך.
         איכות: איכות מקסימלית עד 100 מיקרון.
         מחיר: מעל 1000 דולר.
         חומרים: ABS, PLA בצבעים שונים.
         תחזוקה: באופן עצמאי.
         אתר היצרןmakerbot.com



איכות כמו של הגדולים
  • FormLabs - פרויקט שיצא מ KickStarter , מדובר על מדפסת ביתית ב High Definition שמבוססת על הטכנולוגיה SLA, איכות הדפסה כמו של Objet אבל ניתן להשתמש בחומר אחד.
        איכות: הטובה ביותר שיש בשוק כרגע, 25 מיקרון.
        מחיר: מעל 3000 דולר.
        חומרים: Resin.
        תחזוקה: באופן עצמאי.
        אתר היצרןformlabs.com


נכנסת לכל בית

  • Printrbot - בן אדם אחד קם בבוקר והחליט לקחת את העסק בידיים ולבנות בעצמו סדרה של מדפסות שגם מבוססות על Reprap במחיר שווה לכל נפש.
         איכות: איכות מקסימלית עד 100 מיקרון.
         מחיר: מ 300 דולר ומעלה.
         חומריםABSPLA בצבעים שונים.
         תחזוקה: באופן עצמאי.
         אתר היצרןprintrbot.com


המדפסת

המדפסת שברשותי היא Makerbot Replicator 2x, יש לה 2 ראשי חימום נפרדים שניתן להזין בכל אחד חומר שונה, פלטת חימום גדולה (24.6X15.2X15.15) שגורמת לאובייקט להדבק למשטח, איכות הדפסה מירבית עד 100 מיקרון.



הכנת אובייקט להדפסה

לפני שנקפוץ להדפסה קודם כל צריך למצוא או לבנות אובייקט שרוצים להדפיס, קיימת קהילה ענקית של אנשים שמשתפים אובייקטים תלת מימדים שכל אחד יכול להדפיס במדפסת שלו, היא נקראת thingiverse שם מצאתי את המודל של ה Drone מהסרט Oblivion (למי שלא זוכר...) שנעשה ע"י BrandonW6 והחלטתי להדפיס אותו בעצמי ולשתף אותכם בתהליך.

מושגי בסיס

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


חומרים

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


מלא צבעים!



תוכנות
  • Makerware - תוכנה שדרכה מנהלים את המדפסת ומגדירים את מיקום האובייקט על המשטח ואת ראשי החימום.
http://www.makerbot.com/makerware

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

http://www.netfabb.com/



תהליך ההדפסה

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

זמן ההדפסה הארוך ביותר 4 שעות לכל צד

כל שאר החלקים בין שעה לשעתיים הדפסה

תוספת למודל שנוצרה על ידי משהו אחר
http://www.thingiverse.com/thing:169622

כל החלקים ממתינים להדבקה

גימורים
  • נייר זכוכית עדין - החלקת האובייקט.
  • אציטון - האדים אוכלים את הפלסטיק וגורמים לו להיות מבריק.
  • Dremel - להורדת סימני הדפסה ו Support.


הדבקה

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

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

צריכים לתת לזה זמן להתייבש.

מתחיל לקבל צורה...


מבנה סופי





סיכום

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

אב טיפוסי!