מייקינג

יום רביעי, 31 באוקטובר 2018

Anet A8 - הרכבה חלק א'

חשבתי שיום בחירות יספיק כדי לבנות את ה Anet A8 שיושבת אצלי כבר חודש וחצי ומתחננת להרכבה. אז חשבתי... מצרף לכם תיעוד של חלק מהעבודה עם התובנות שלי... תהנו!

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

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

לחץ כאן כדי להמשיך לקרוא..

יום רביעי, 17 באוקטובר 2018

תחילת עבודה ב Octave ופרויקט לדוגמא - עיבוד תמונה

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

בחיפושי התחלתי לבדוק את Matlab שעושה רושם שמיועדת בדיוק לדברים האלו אולם הסתבר שמחיר של רשיון לצרכן הפרטי הוא בסביבות 2500$ לרשיון בודד... :-(למוסדות לימוד יש הנחה...). התחלתי לבחון חלופות ומצאתי את Octave. Octave אמורה להיות כמעט כפילה של Matlab. אני משוכנע של Matlab תהיינה המון הסתייגויות מההשוואה אבל לצורך העניין - לקחתי פרויקט Matlab והרצתי אותו על Octave והוא רץ עם שינויים קטנטנים (פרטים בהמשך). המטרה היתה להתחיל להכיר את Octave ולראות איך עושים בו שימוש למטרות של עיבוד מסד נתונים גדול כמו גלי מוח.

בפרויקט הזה תוכלו לראות את היכולות של ה Matlab / Octave. מקווה שבהמשך הידע שלי יבשיל לכדי התמודדות על פרויקט עיבוד גלי מוח וחיבור של זה לארדואינו...

נתחיל?...

בשלב הראשון יש להוריד את ה Octave מכאן. אני בחרתי באפשרות Windows - בחרו במערכת ההפעלה שמתאימה לכם. ההתקנה של ה Octave די פשוטה (ביחס להתקנה של ה Matlab בה אתם נדרשים לחתום ולהצהיר על כל מיני דברים - על מנת להתקין גרסת נסיון ל 30 יום...) ולאחר ההתקנה תראו שתי תוכנות: Octave CLI ו Octave GUI. הכנסו בבקשה ל Octave GUI.

בחלון שיפתח לכם תוכלו לראות את הממשק של Octave הכולל את שורת הפקודה - Command window ואת חלונית הקוד - Editor. בלשוניות שבתחתית העמוד תוכלו להחליף ביניהם.

נסו לשחק מעט בחלונית הפקודה:

כתבו "1" והקישו Enter
נסו "1+1" ולחצו על Enter
נסו להגדיר משתנים שונים ולחשב איתם. הגדרה תסתיים ב ; לפני ההקשה על ה Enter.

ראו כמה דוגמאות קטנטנות בסרטון:

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

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

1. אל תחלצו את הספריה - העבירו אותה אל שולחן העבודה (סתם בשביל הנוחות).

2. חפשו את הספריה על שולחן העבודה דרך החלון שבצד שמאל של ה Octave.

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

pkg install 'image-2.8.0.tar.gz'

אצלכם זה עשוי להראות קצת שונה בהתאם לגירסה של ה image שהורדתם.

לאחר ההורדה - חכו מעט, זה עשוי לקחת דקה או קצת יותר. לאחר שה command window ישחרר לכם את הבמה כדי לכתוב משהו חדש - כתבו pkg load image.

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

בשביל הדוגמא, לקחתי תמונה מהאתר הזה וחתכתי אותה באמצעות "צייר". התמונה שהתקבלה היא:

האם ה Octave יצליח להוציא את המידע הרלוונטי מהתמונה?...

העליתי את הקוד של ה Octave לחלונית העורך - ה Editor:

clc; % Clear command window.
clear all; % Delete all variables.
close all; % Close all figure windows except those created by imtool.
%%imtool close all; % Close all figure windows created by imtool.
%%workspace; % Make sure the workspace panel is showing.
% Read Image
I = imread ('CAR2.jpg');
figure(1);
imshow(I);
% Extract Y component (Convert an Image to Gray)
Igray = rgb2gray(I);
[rows cols] = size(Igray);
%% Dilate and Erode Image in order to remove noise
Idilate = Igray;
for i = 1:rows
for j = 2:cols-1
temp = max(Igray(i,j-1), Igray(i,j));
Idilate(i,j) = max(temp, Igray(i,j+1));
end
end
I = Idilate;
figure(2);
imshow(Igray);
figure(3);
title('Dilated Image')
imshow(Idilate);
figure(4);
imshow(I);
difference = 0;
sum = 0;
total_sum = 0;
difference = uint32(difference);
%% PROCESS EDGES IN HORIZONTAL DIRECTION
disp('Processing Edges Horizontally...');
max_horz = 0;
maximum = 0;
for i = 2:cols
sum = 0;
for j = 2:rows
if(I(j, i) > I(j-1, i))
difference = uint32(I(j, i) - I(j-1, i));
else
difference = uint32(I(j-1, i) - I(j, i));
end
if(difference > 20)
sum = sum + difference;
end
end
horz1(i) = sum;
% Find Peak Value
if(sum > maximum)
max_horz = i;
maximum = sum;
end
total_sum = total_sum + sum;
end
average = total_sum / cols;
figure(5);
% Plot the Histogram for analysis
subplot(3,1,1);
plot (horz1);
title('Horizontal Edge Processing Histogram');
xlabel('Column Number ->');
ylabel('Difference ->');
%% Smoothen the Horizontal Histogram by applying Low Pass Filter
sum = 0;
horz = horz1;
for i = 21:(cols-21)
sum = 0;
for j = (i-20):(i+20)
sum = sum + horz1(j);
end
horz(i) = sum / 41;
end
subplot(3,1,2);
plot (horz);
title('Histogram after passing through Low Pass Filter');
xlabel('Column Number ->');
ylabel('Difference ->');
%% Filter out Horizontal Histogram Values by applying Dynamic Threshold
disp('Filter out Horizontal Histogram...');
for i = 1:cols
if(horz(i) < average)
horz(i) = 0;
for j = 1:rows
I(j, i) = 0;
end
end
end
subplot(3,1,3);
plot (horz);
title('Histogram after Filtering');
xlabel('Column Number ->');
ylabel('Difference ->');
%% PROCESS EDGES IN VERTICAL DIRECTION
difference = 0;
total_sum = 0;
difference = uint32(difference);
disp('Processing Edges Vertically...');
maximum = 0;
max_vert = 0;
for i = 2:rows
sum = 0;
for j = 2:cols %cols
if(I(i, j) > I(i, j-1))
difference = uint32(I(i, j) - I(i, j-1));
end
if(I(i, j) <= I(i, j-1))
difference = uint32(I(i, j-1) - I(i, j));
end
if(difference > 20)
sum = sum + difference;
end
end
vert1(i) = sum;
%% Find Peak in Vertical Histogram
if(sum > maximum)
max_vert = i;
maximum = sum;
end
total_sum = total_sum + sum;
end
average = total_sum / rows;
figure(6)
subplot(3,1,1);
plot (vert1);
title('Vertical Edge Processing Histogram');
xlabel('Row Number ->');
ylabel('Difference ->');
%% Smoothen the Vertical Histogram by applying Low Pass Filter
disp('Passing Vertical Histogram through Low Pass Filter...');
sum = 0;
vert = vert1;
for i = 21:(rows-21)
sum = 0;
for j = (i-20):(i+20)
sum = sum + vert1(j);
end
vert(i) = sum / 41;
end
subplot(3,1,2);
plot (vert);
title('Histogram after passing through Low Pass Filter');
xlabel('Row Number ->');
ylabel('Difference ->');
%% Filter out Vertical Histogram Values by applying Dynamic Threshold
disp('Filter out Vertical Histogram...');
for i = 1:rows
if(vert(i) < average)
vert(i) = 0;
for j = 1:cols
I(i, j) = 0;
end
end
end
subplot(3,1,3);
plot (vert);
title('Histogram after Filtering');
xlabel('Row Number ->');
ylabel('Difference ->');
figure(7), imshow(I);
%% Find Probable candidates for Number Plate
j = 1;
for i = 2:cols-2
if(horz(i) ~= 0 && horz(i-1) == 0 && horz(i+1) == 0)
column(j) = i;
column(j+1) = i;
j = j + 2;
elseif((horz(i) ~= 0 && horz(i-1) == 0) || (horz(i) ~= 0 && horz(i+1) == 0))
column(j) = i;
j = j+1;
end
end
j = 1;
for i = 2:rows-2
if(vert(i) ~= 0 && vert(i-1) == 0 && vert(i+1) == 0)
row(j) = i;
row(j+1) = i;
j = j + 2;
elseif((vert(i) ~= 0 && vert(i-1) == 0) || (vert(i) ~= 0 && vert(i+1) == 0))
row(j) = i;
j = j+1;
end
end
[temp column_size] = size (column);
if(mod(column_size, 2))
column(column_size+1) = cols;
end
[temp row_size] = size (row);
if(mod(row_size, 2))
row(row_size+1) = rows;
end
%% Region of Interest Extraction
%Check each probable candidate
for i = 1:2:row_size
for j = 1:2:column_size
% If it is not the most probable region remove it from image
if(~((max_horz >= column(j) && max_horz <= column(j+1)) && (max_vert >=row(i) && max_vert <= row(i+1))))
%This loop is only for displaying proper output to User
for m = row(i):row(i+1)
for n = column(j):column(j+1)
I(m, n) = 0;
end
end
end
end
end
figure(8), imshow(I);
imshow(I);

את הקוד לקחתי מהאתר הזה (תודה!!) אבל התברר ששתי שורות - השורה הרביעית והשורה החמישית - אינן נתמכות ב Octave אלא רק ב Matlab. לשמחתי, הן לא היו קריטיות. הן שורות שנועדו למחוק נתונים קודמים על מנת שהתכנה תרוץ חלק ללא תקלות מיותרות. בפועל, סימנתי את שתי השורות ב %%, כלומר, "אני לא מעוניין להשתמש בכן" והתכנה רצה מצוין.

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

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

בשלבים הבאים, התכנה מעבדת ומנתחת עוד ועוד את התמונה עד לתוצאה הבאה:

זהו להיום...

זו התנסות ראשונית ב Octave ויש עוד המון מה ללמוד אבל זו ההתחלה...

בהצלחה!

יום שני, 1 באוקטובר 2018

שימוש ב RTC עם ארדואינו

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

החיבור של ה RTC לארדואינו הוא קל ופשוט ודורש בסך הכל כמה חוטים...

השתמשתי ברכיב שנקרא Tiny RTC וכולל סוללה מסוג CR2032:

את ה 5V ברכיב ה RTC - נחבר ל 5V בלוח הארדואינו
את ה GND ברכיב ה RTC - נחבר ל GND בלוח הארדואינו
את ה SDA ברכיב ה RTC - נחבר לכניסה A4 בלוח הארדואינו
את ה SCL ברכיב ה RTC - נחבר לכניסה A5 בלוח הארדואינו.

אחרי שחיברנו הכל והכנסנו את הסוללה לרכיב ה RTC, נוריד את הספרייה מכאן.

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

שימו לב רק לכמה דברים:

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

בהצלחה!!

(קרדיט: נעזרתי המון באתר הזה. תודה!)

יום שבת, 22 בספטמבר 2018

נר LED

רוצים לדעת איך יוצרים נר LED בשביל האווירה? זה ממש פשוט...

רכיבים:

לוח ארדואינו
נורת לד
נייר לבן פשוט לעטוף את הנורה

בדוגמא הזאת השתמשתי בנורות LED משורשרות שנמכרות לפני סוכות. במקור, הנורות היו מחוברות לשתי סוללות AA, כלומר, סה"כ 3V. הארדואינו כמובן יכול להחליף את הסוללות ללא שום בעיה וכמובן לספק חשמל משתנה על פי תכנית במקום החשמל הקבוע שאמורות לקבל הנורות מהסוללות.

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

אחרי שהעליתם את הקוד - חברו את הרגל החיובית של הלד אל יציאה מס' 10 ואת הרגל השלילית אל ה GND:

אגב, אם תרצו תוכלו להשתמש ביציאות אחרות של הארדואינו אבל בהסתייגות: תוכלו להשתמש רק ביציאות שתומכות בכתיבה "אנלוגית" או ליתר דיוק כתיבה דיגיטלית שמדמה כתיבה אנלוגית. בעזרת השיטה הזאת ניתן לשלוט על עוצמת המתח החשמלי ולא רק לספק 0/1 כמו ביציאות דיגיטליות. השיטה נקראת PWM ותומכות בה יציאות 3,5,6,9,10,11 בלבד (ומסומנות בסימן ~). לכן, תוכלו להשתמש ביציאה אחרת (וכמובן לעשות את השינוי בקוד) אולם השתמשו רק ביציאות התומכות ב PWM.

התוצאה הסופית אמורה להראות בערך כך:

ושרשרת הנורות לסוכה מוכנה!

בהצלחה!!

יום שבת, 15 בספטמבר 2018

מדפי PLA

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

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

הפיתרון? ארונית ייחודית: הרעיון הוא פשוט - ליצור ארונית עם שיפוע עדין כלפי הקיר כך שגלילי ה PLA לא יברחו מהארונית ללא רשות מחד ומאידך יהיה קל מאד לשלוף אותם ולראות בדיוק מה לוקחים.

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

(בתמונה: המדפים מנוסרים וגלילי PLA בצבע לא ידוע מסתתרים בתוך קופסאות במגדלים אין סופיים...)

השלב הבא היה כמובן להרכיב את המדפים וליצור את ארונית ה PLA:

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

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

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

יום ראשון, 5 באוגוסט 2018

חדר בריחה - אקזיטרום/ אתגר בריחה בשער בנימין

אחרי כמה שבועות שלא הייתי זמין - אני יכול לספר לכם את הסיבה: הייתי ב Mode של בריחה..

הרשמה לאתגר הבריחה >>>

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

המבנה יהיה מוכן בעוד כ 3 חודשים ובינתיים - כדי להכיר את המיזם ולחשוף אותו לציבור - הוקם חדר האקזיטרום.

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

זה נראה בערך ככה:

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

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

תוכלו לראות שכל החוטים שהם Input של הארדואינו "המרכזי", כלומר, מעבירים אליו מידע לגבי קצב ההתקדמות בחדר הבריחה, מוארקים דרך נגד 10KΩ ל GND אחרת הקריאה מהארדואינו "המקומי" עלולה להיות כמעט אין סופית (ממש מאותה הסיבה שהשתמשנו כאן בנגד). גם בארדואינו "המקומי", החוט שהוא Input עבורו (והוא Output עבור הארדואינו "המרכזי") מוארק ל GND דרך נגד מאותה הסיבה, על מנת שהקריאה תהיה מדויקת: רק הפקודה שהארדואינו מעביר לארדואינו תקלט ולא יקלטו שאריות אלקטרונים שישבשו את המערכת...

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

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

אז למה אתם מחכים?!

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

יום שישי, 13 ביולי 2018

טיל בריחה

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

איך בונים את הטיל?

רכיבים:

ארדואינו אונו
מקלדת לארדואינו Keypad
רמקול קטן
פס לדים - LED strip RGB מסוג adressable
חוטים...

נסביר קצת על פס הלדים: פס לדים יכול להיות פס של צבע אחד ופס של RGB כמו למשל הפס שהשתמשנו בו כאן. גם בתוך פסי ה RGB צריך לעשות חלוקה: פס RGB שניתן לשלוט על כולו בו זמנית ופס RGB מסוג adressable, כלומר, ניתן לפנות אל כל נורה בנפרד ולתת לה פקודה להדלק בזמן מסוים ולהגדיר את הצבע בו תדלק. בפרויקט הזה נשתמש בפס לדים עם ארבעה חיבורים: GND, VCC, DATA, CLOCK.

נתחיל בבניית המעגל:

כמה דגשים:

שימו לב שאם אתם משתמשים ברמקול זעיר מסוג Buzzer, יתכן שתצטרכו לחבר נגד של 100Ω בין ה GND שלו ובין הארדואינו. אני השתמשתי ברמקול קטן וללא נגד.
שימו לב שאתם מתחברים לצד הנכון של פס הלדים. בעיקרון ניתן לחבר פס נוסף לקצה הפס הראשון ולכן יש חיבורים בשני הצדדים. על גבי פס הלדים יש חיצים קטנטנים שאמורים להסביר את כיוון החיבור: החץ מורה על סיום פס הלדים.

בניסיון הראשון התחלתי עם ארדואינו Nano אבל אחרי שהלוח נשרף לי, עברתי, לפחות באופן זמני, לארדואינו אונו.

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

נעלה את הקוד:

#include <Adafruit_DotStar.h>
#include <SPI.h>        
#include <Wire.h>
#include <Keypad.h>

#define NUMPIXELS 60

#define DATAPIN    10
#define CLOCKPIN   11
Adafruit_DotStar strip = Adafruit_DotStar(NUMPIXELS, DATAPIN, CLOCKPIN, DOTSTAR_BRG);

int s=0;
int speakerPin = 12;

char* password = "51762483";

int position = 0;

const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};

byte rowPins[ROWS] = { 9, 8, 7, 6 };
byte colPins[COLS] = { 5, 4, 3, 2 };

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup(){
  
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000L)
clock_prescale_set(clock_div_1); 
#endif

strip.begin(); 
strip.show();  
  
Serial.begin(9600);

LockedPosition(true);

for (int j = 0; j < 60; j++) {
strip.setPixelColor(j, 0x00FF00);
strip.show();                     
delay(0); 
}
}

void loop(){
char key = keypad.getKey(); 
Serial.println(key);
if (key>30) {
tone (speakerPin, 1000);
delay(60);    
noTone(speakerPin);
  
for (int d = 0; d < 60; d++) {
strip.setPixelColor(d, 0);
strip.show();                     
}
    
for (int j = 0; j < 60; j++) {
strip.setPixelColor(j, 0x00FF00);
strip.show();                    
delay(0); 
}
}

if (key == '*'){
position = 0;
s=0;
tone(speakerPin, 600);
delay(60);  
noTone(speakerPin);
tone(speakerPin, 400);
delay(60);  
noTone(speakerPin);
LockedPosition(1);
}

if (key == password[position]) 
{
s=s+1;
position ++;
}
  
if (position == 8) 
{
if (s==8){     
tone(speakerPin, 1000);
delay(60);  
noTone(speakerPin);
tone(speakerPin, 1200);
delay(60);  
noTone(speakerPin);
tone(speakerPin, 1400);
delay(60);  
noTone(speakerPin);
LockedPosition(0); 
}
s=0; 
position=0;
}
LockedPosition(1); 
}

void LockedPosition(int locked){

if (locked==1){
for (int u = 0; u < 3; u++) {
    
for (int d = 0; d < 60; d++) {
strip.setPixelColor(d, 0);
strip.show();                   
}
    
for (int j = 0; j < 60; j++) {
strip.setPixelColor(j, 0x00FF00);
strip.show();                   
}   
}
}
else
{
 for (int j = 0; j < 60; j++) {
strip.setPixelColor(j, 0xFF0000);
strip.show();                     
}
delay(10000);
}
}

השורה:

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

חשוב מאד!!

שתיים ורבע השורות האלו:

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

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

לסיום, נשאר רק לספק חשמל לארדואינו ולארוז הכל יפה...

בהצלחה!!

יום חמישי, 10 במאי 2018

עריכת קובץ Python לטיפול בשגיאת EggBot

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

אז מה עושים? משחקים קצת בקוד שמפעיל את הרחבת ה EggBot שכתוב בשפת Python. מוכנים?

ראשית, עושים חיפוש בתיקיית ה Inkscape ומחפשים את הקובץ "ebb_serial". יש שם שני קבצים בלי שם כזה ואנו צריכים את הקובץ בעל הסיומת py ולא סיומת של pyc. אצלי הקובץ נמצא בכתובת הבאה:

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

חפשו את השורה:

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

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

בהצלחה!

יום ראשון, 6 במאי 2018

בניית ותכנות EggBot - רובוט לשרטוט על ביצה

איך מרכיבים EggBot ומה זה בכלל?!

ה EggBot הוא מכשיר לציור על ביצים מבוסס ארדואינו. המכשיר עובד בדומה מאד למכונת חיתוך לייזר: ציר ה x וציר ה y נקבעים על ידי מנועי צעד (step motor) ובמקום חיתוך בלייזר - אנו נעזרים בטוש דק לציור על הביצה.

לפני שנתחיל, נתאר את השלבים השונים בקווים כלליים:

בניית המכשיר
הורדת הקוד לארדואינו
הורדת תכנת שרטוט למחשב
תכנון השרטוט / שימוש בקובץ מוכן
פקודה דרך התכנה לארדואינו

נתחיל לפרט:

1. כדי לבנות את המכשיר יש צורך להוריד את דף ההנחיות מכאן או מכאן. הרכיבו בעדינות והבריגו בזהירות. חלק מהחלקים די עדינים.

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

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

2. הורידו מכאן את הקוד לארדואינו או מכאן. חלצו את התיקייה למקום הנכון - אצלי זה כאן:

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

חפשו בדוגמאות את ה EggBot ופתחו את הקובץ.

הגדירו פתחה / פורט והעלו את הקוד לארדואינו.

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

חלצו את התיקייה, חפשו בתוכה את היישום Inkscape והפעילו אותו.

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

אפשר גם להוריד מכאן דוגמאות מוכנות לשימוש ב EggBot.

בכל מקרה, הקובץ צריך להיות מותאם לגודל של ביצה.

5. כעת, אם הכל מוכן ובנוי - אפשר להתחיל בניסיון הראשון:

מרכיבים את הביצה במקומה (או כדור פינג פונג, ביצת פלסטיק או אובייקט אחר...)
מחברים את לוח הארדואינו למחשב בכבל ה USB - כבל ה USB חייב להיות מחובר עד לסיום העבודה!!!
מחברים את הטוש ל EggBot.
מפעילים את ה EggBot דרך ההרחבה הייעודית בתכנת ה Inkscape: לוחצים על הרחבות >>> EggBot >>> ובתפריט שנפתח לוחצים על EggBot Control.

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

הכל עובד? כן!!

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

יום רביעי, 18 באפריל 2018

חיבור Esp8266 לרשת ה wifi הביתית

איך מחברים Esp8266 לרשת הביתית? חיפשתי דרך פשוטה לעשות את זה ומצאתי משהו לא מאד מסובך.

רכיבים:

לוח ארדואינו אונו
רכיב Esp8266
מתאם (לא חובה אבל חוסך המון!)
3 נורות LED
3 נגדים בערך של 220Ω
מטריצה
חוטים..

נתחיל לבנות את המעגל:

את ה GND במתאם - נחבר ל GND בלוח הארדואינו
את ה VCC במתאם - נחבר ל 5V בלוח הארדואינו (יציאת 3.3V לא תספק את המתח הרצוי)
את ה TX במתאם - נחבר ליציאה מספר 10 בלוח הארדואינו.
את ה RX במתאם - נחבר ליציאה מספר 11 בלוח הארדואינו.

נוסיף עוד שלוש נורות לד על פי התרשים הבא:

לאחר שבנינו את המעגל, יש להעלות את הקוד:

#include <SoftwareSerial.h>
#include <Servo.h>
SoftwareSerial esp8266(10,11);

#define DEBUG true 
boolean button_state5 = false; 
boolean button_state6 = false; 
boolean button_state7 = false;

char c;

void setup()
{
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);

Serial.begin(9600);
esp8266.begin(115200);

esp8266Data("AT+RST\r\n", 2000, DEBUG); //reset module
esp8266Data("AT+CWMODE=1\r\n", 1000, DEBUG); //set station mode
esp8266Data("AT+CWJAP=\"YOUR SSID\",\"YOUR PASSWORD\"\r\n", 2000, DEBUG);   
while(!esp8266.find("OK")) { 
} 
esp8266Data("AT+CIFSR\r\n", 1000, DEBUG); 
esp8266Data("AT+CIPMUX=1\r\n", 1000, DEBUG); 
esp8266Data("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); 
}

void loop()
{
if (esp8266.available())  
{
if (esp8266.find("+IPD,")) 
{
while (esp8266.available()){
c=esp8266.read();
Serial.print(c);
if(c == 53){ 
delay(300); 
button_state5 = !button_state5;
delay(100); 
}
else{
if(c == 54){ 
delay(300); 
button_state6 = !button_state6;
delay(100); 
}
else{
if(c == 55){ 
delay(300); 
button_state7 = !button_state7;
delay(100); 
}}}

if (button_state5){
digitalWrite(5, HIGH);
} 
else{
digitalWrite(5, LOW);
}
if (button_state6){
digitalWrite(6, HIGH);
} 
else{
digitalWrite(6, LOW);
}
if (button_state7){
digitalWrite(7, HIGH);
} 
else{
digitalWrite(7, LOW);
}
}
}
}
}

String esp8266Data(String command, const int timeout, boolean debug)
{
String response = "";
esp8266.print(command);
long int time = millis();
while ( (time + timeout) > millis())
{
while (esp8266.available())
{
char c = esp8266.read();
response += c;
}
}
if (debug)
{
Serial.print(response);
}
return response;
}

שימו לב רק לכמה דברים חשובים:

בשורה הזאת:

אתם חייבים להזין את שם הרשת הביתית שלכם ואת הסיסמא אחרת זה לא יעבוד...

בנוסף, בשורה הזאת:

אתם צריכים להגדיר את קצב התקשורת של הרכיב שלכם. לא בטוחים? תשאירו ככה ואם תראו ג'יבריש במסך הסיריאלי - תשחקו קצת עם ההגדרות עד שזה יסתדר...

ומה עכשיו?

תפתחו את המסך הסיריאלי. אתם אמורים לראות שהכל מתנהל כשורה..

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

כעת, כל מה שנותר לעשות הוא לשלוח פקודות ללוח הארדואינו. הדרך הקלה ביותר שמצאתי היא דרך אפליקציית Serial WiFi Terminal. לאחר ההורדה וההתקנה פתחו את האפליקציה ועברו ל Devices.

הוסיפו את ה Esp8266 שלכם על ידי לחיצה על הפלוס:

במסך שיפתח, הכניסו את ה IP שלכם ואת הפורט. ה IP שלכם אמור להופיע במסך הסיריאלי (זוכרים?) והפורט הוא 80:

כעת, אשרו את הפרטים ועברו לטרמינל. התחברו למכשיר שלכם על ידי לחיצה על ה"מצלתיים" שעל יד הפח. חכו שתיים - שלוש שניות, הקישו את הספרה 5 / 6 / 7 ושלחו לארדואינו:

אגב, בלחיצה ארוכה על מקשי ה M, תוכלו "לתכנת" אותם לשלוח משהו מסוים לטרמינל בעת לחיצה עליהם. אני בחרתי כצפוי לתכנת את M5 לשלוח את הספרה 5, את M6 לשלוח את הספרה 6 ואת M7 לשלוח את הספרה 7.

זהו... סיימנו!

ואם נותר בכם כח - עוד כמה דברים קטנים:

בגלל תקשורת לא מדויקת, לפעמים מתקבל מספר שונה בארדואינו מהמספר שנשלח. אני מניח שהבעיה היא בלוח Esp שלי ויתכן שעם לוח אחר - הבעיה תיפתר לחלוטין. כרגע זה עובד ב 90 ומשהו אחוז מהפעמים וזה מספיק לי כרגע...
הטרמינל שולח ספרה אולם הארדואינו מקבל את ה ASCII שלה, לכן, אני שולח את הספרה 5 ואילו בקוד של הארדואינו הגדרתי 53.
כאשר ניסיתי לעבוד עם יציאות 2,3,4 בארדואינו זה עבד לא טוב, בעיקר הספרה 2 שעשתה קצת בעיות שנפתרו ברגע שעשיתי שינוי בקוד ל 4,5,6. אני לא חושב שזה קשור ליציאה בארדואינו אלא לקוד ה ASCII שקצת עשה בעיות.
כמובן שאפשר להחליף את נורות ה LED ב Relay ואז כל האפשרויות פתוחות...

בהצלחה!!

דפים