לחץ כאן לקריאת המאמר המלא

‫נכתב ע"י‪:‬‬
‫רוני פאר‬
‫‪[email protected]‬‬
‫תאריך עדכון אחרון‪:‬‬
‫‪7.12.2010‬‬
‫מעודכן לגרסה‪:‬‬
‫‪MATLAB 7.11 - R2010b‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫הקדמה‬
‫השימוש בתוכנת ‪ MATLAB‬הרגיל את משתמשיה לעבוד בצורה חופשית ‪ -‬ללא דאגה להקצאות‬
‫זיכרון‪ ,‬ללא חשש להגדרת סוגי המשתנים‪ ,‬והנאה רבה מהיכולת לביצוע פעולות על מטריצות‬
‫בצורה פשוטה וקלה‪ .‬עקב כך‪ ,‬אלגוריתמאים ומתכננים מתחומי תעשייה שונים עושים שימוש רב‬
‫ומתקדם בתוכנה זו‪.‬‬
‫תיכנות בשפת ‪ ,C‬מאידך‪ ,‬הוא אופטימלי לתכנון מערכות זמן‪-‬אמת מבחינת ביצועים‪ ,‬ניצול‬
‫הזיכרון ועוצמת החישוב‪ .‬קוד זה יכול לכלול גם שימוש ב‪ ,Fixed Point-‬ומהנדסי חומרה ותוכנה‬
‫עובדים שעות רבות על ניצול מקסימלי של רכיבים אלו‪ ,‬בכדי להפיק מהם את המירב ולהשיג‬
‫יתרון של ממש על פני המתחרים‪.‬‬
‫כתוצאה מכך‪ ,‬אחד מאתגרי הפיתוח הנפוצים בתעשיה הוא כיצד לבצע המרה מהירה‪ ,‬יעילה‬
‫ואוטומטית במידת האפשר ‪ -‬של תוכנית שנכתבה בסביבה החופשית של ‪ ,MATLAB‬לסביבה‬
‫בעלת האילוצים הקשים וצורת התכנות של שפת ‪.C‬‬
‫מטרת מסמך זה הינה להציג את אחד הפתרונות לאתגר זה‪ :‬שימוש בפרדיגמת ה‪Embedded-‬‬
‫‪) MATLAB‬או‪ (EML :‬ויצירת קוד ‪ C‬באמצעות ‪ .Real-Time Workshop‬ע"י שימוש בדוגמא‬
‫של פונקציה הכתובה ב‪ ,MATLAB-‬מוסבר הליך המרת הקוד כך שיכיל עקרונות תכנות של שפת‬
‫‪ :C‬הגדרות טיפוסי משתנים – לרבות ‪ ,Fixed Point‬הקצאות זיכרון וביצוע אופטימיזציה לניצול‬
‫זיכרון הרכיב וייעול הקוד עצמו‪ .‬כמו כן‪ ,‬משולבים ידע ופרקטיקות שנאספו מתחומי תעשייה‬
‫רבים מרחבי העולם ומקנים לקורא תהליכים מומלצים לביצוע המרה אוטומטית של קוד‬
‫‪ MATLAB‬ל‪.C-‬‬
‫יש לציין כי גם במודלים של ‪ Simulink‬ניתן לשלב פונקציות של ‪ .EML‬בצורה שכזו ניתן לבנות‬
‫סביבת בדיקות קלה ונוחה יותר‪ ,‬או לשלב קוד ‪ EML‬בתוך מודלים מערכתיים גדולים יותר שנבנו‬
‫בעזרת ‪.Simulink‬‬
‫מסמך זה מסתמך בחלקו הגדול על מסמכי ה‪ help-‬המסופקים עם תוכנת ‪ ,MATLAB‬ובא לתת‬
‫מראי מקום חשובים מתוכם – מומלץ לקרוא מסמכים אלו‪.‬‬
‫עמוד ‪ 2‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫תוכן העניינים‬
‫‪.1‬‬
‫הגדרות כלליות ‪5......................................................................................................‬‬
‫‪5.............................................................................................................. MATLAB .1.1‬‬
‫‪ Embedded MATLAB .1.2‬או ‪5........................................................................... EML‬‬
‫‪5....................................................................................................................... RTW .1.3‬‬
‫‪6................................................................................................................ RTW-EC .1.4‬‬
‫‪6....................................................................................................................... MEX .1.5‬‬
‫‪.2‬‬
‫אבני דרך מרכזיות ‪7..................................................................................................‬‬
‫‪ .2.1‬כתיבת קוד ‪ MATLAB‬ובדיקה התנהגותית של האלגוריתם‪7...........................................‬‬
‫‪ .2.2‬בדיקה האם הקוד שנכתב תואם ל‪7.......................................................................EML-‬‬
‫‪ .2.3‬התאמת הקוד למערכות זמן‪-‬אמת ‪8.................................................................................‬‬
‫‪ .2.4‬יצירת פונקציית ‪ MEX‬לצורך בדיקה פונקציונלית של הקוד ‪8............................................‬‬
‫‪ .2.5‬יצירת קוד ‪9...................................................................................................................‬‬
‫‪.3‬‬
‫בדיקה האם הקוד שנכתב תואם ל‪10 ............................................................... EML-‬‬
‫‪ .3.1‬טיפול והסרה של כל ה"הערות" שנתגלו ע"י שימוש ב‪10 ........................................ m-lint-‬‬
‫‪ .3.2‬שימוש בפרגמה ‪11 ............................................................................................ %#eml‬‬
‫‪.4‬‬
‫התאמת הקוד למערכות זמן‪-‬אמת ‪14 ..........................................................................‬‬
‫‪" .4.1‬טיפול" בפונקציות של ‪ MATLAB‬באמצעות ‪14 .................................... eml.extrinsic‬‬
‫‪ 4.2‬הגדרת טיפוסי משתנים ‪15 ...............................................................................................‬‬
‫‪ .4.3‬הגדרת פרמטרים בעלי גודל משתנה )‪16 .................................................. (Variable Size‬‬
‫‪ .4.4‬עבודה עם פרמטרים מסוג ‪18 ............................................................................... struct‬‬
‫‪ .4.5‬עבודה עם מטריצות "ריקות" ‪19 ......................................................................................‬‬
‫‪ .4.6‬הגדרת משתנים בצורה מותנית ‪19 ...................................................................................‬‬
‫‪ .4.7‬הקצאת זיכרון מינימלית באמצעות ‪20 ..................................................... eml.nullcopy‬‬
‫‪ .4.8‬אינדקסים של וקטורים בעלי גודל משתנה ‪20 ....................................................................‬‬
‫‪ .4.9‬תמיכה במשתנים גלובליים ‪21 ........................................................................... global -‬‬
‫‪ .4.10‬שימוש ב‪21 ............................................................................................. streaming-‬‬
‫‪ .4.11‬בדיקה פונקציונלית ‪22 ..................................................................................................‬‬
‫‪.5‬‬
‫יצירת פונקציית ‪ MEX‬לצורך בדיקה פונקציונלית של הקוד ‪24 .....................................‬‬
‫‪ .5.1‬יצירת פונקציית ‪25 .............................................................................................. MEX‬‬
‫‪ .5.2‬בדיקה למול קוד המקור ‪26 .............................................................................................‬‬
‫‪ .5.3‬בדיקת זמני ריצה של קוד ה‪ MEX-‬והשוואה למקור ‪26 .....................................................‬‬
‫‪.6‬‬
‫יצירת קוד ‪27 ...........................................................................................................‬‬
‫‪ .6.1‬תוצרים שונים מהפקודה ‪27 ................................................................................... emlc‬‬
‫‪ .6.2‬התאמה אישית של הקוד הנוצר )דגלון ‪28 ................................................................... (–s‬‬
‫עמוד ‪ 3‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .6.3‬שימוש בדו"ח יצירת הקוד ‪32 ..........................................................................................‬‬
‫סיכום ‪33 .................................................................................................................‬‬
‫‪.7‬‬
‫עמוד ‪ 4‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .1‬הגדרות כלליות‬
‫במסמך זה נעשה שימוש במספר ביטויים מעולם התוכן של משתמשי ‪ .MATLAB‬מטרת חלק זה‬
‫היא להבהיר מושגים אלו‪ ,‬וליצור שפה משותפת אחידה‪:‬‬
‫‪MATLAB .1.1‬‬
‫ה"סטנדרט" בתעשייה ‪ -‬התוכנה מבית היוצר של חברת ™‪ MathWorks‬אשר מאפשרת‬
‫לבצע חישובים נומריים‪ ,‬לנתח מידע ולהציגו בצורה גרפית‪ ,‬לפתח ולבדוק אלגוריתמים‬
‫סבוכים ופשוטים כאחד‪ ,‬והבסיס לכל המוצרים הנלווים של ‪ - MathWorks‬המוסיפים‬
‫יכולות מתקדמות בתחום עיבוד התמונה‪ ,‬עיבוד האות‪ ,‬תכנון מערכות בקרה‪ ,‬ועוד‪.‬‬
‫‪ MATLAB‬הינה שפה עילית‪ ,‬המאפשרת לבנות אלגוריתמים מורכבים ללא צורך לדאגה‬
‫להקצאת זיכרון‪ ,‬להגדרות משתנים ופעולות נוספות הנדרשות בשפות תכנות נמוכות יותר‪.‬‬
‫‪ Embedded MATLAB .1.2‬או ‪EML‬‬
‫כאשר אנו מעוניינים לעבור מעולם הפיתוח ב‪ MATLAB®-‬למערכות זמן‪-‬אמת‪ ,‬אנו‬
‫צריכים לכתוב בפונקציות המתאימות למערכות אלו‪ .‬אוסף הפונקציות הזה‪ ,‬הנגזר מתוך‬
‫‪ MATLAB‬עצמה – נקרא ‪ .Embedded MATLAB‬האיור הבא מדגים את עולם ה‪-‬‬
‫‪ ,Embedded‬בהשוואה למקור‪.‬‬
‫כפי שניתן לראות‪ ,‬הפעולות שאינן נתמכות מחולקות ל‪ 2-‬סוגים – ויזואליזציה והקצאת‬
‫זיכרון דינמית‪ .‬עם זאת‪ ,‬חשוב לזכור שבמערכות זמן‪-‬אמת אמיתיות‪ ,‬אין שימוש של ממש‬
‫בפעולות אלו‪ ,‬ולכן אין כאן פגיעה ברמת העבודה‪.‬‬
‫‪RTW .1.3‬‬
‫על מנת לייצר קוד ‪ C‬מתוך ‪ ,MATLAB‬יש להתקין כלי נוסף‪ ,‬הנקרא ‪Real-Time‬‬
‫‪ ,Workshop‬או בקיצור ‪ .RTW‬כלי זה מאפשר לייצר קוד ‪ C‬גנרי‪ ,‬שניתן להפעילו על כל‬
‫מערכות המחשוב הקיימות כיום )‪ Linux ,MAC ,PC‬וכדומה(‪ .‬הקוד הנוצר מיועד‬
‫למערכות אלו‪ ,‬שבעיקרן אינן מוגבלות מבחינת משאבים )למשל ‪ -‬תמיד ניתן להוסיף עוד‬
‫זיכרון או לעבור ל‪ 64-‬ביט(‪ ,‬ועל כן הוא יעיל בצורה הולמת‪.‬‬
‫עמוד ‪ 5‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪RTW-EC .1.4‬‬
‫למערכות זמן‪-‬אמת המוגבלות במשאבים )זיכרון‪ ,‬זמני ריצה( קיים כלי נוסף‪ ,‬אשר נקרא‬
‫‪ ,Real-Time Workshop – Embedded Coder‬או בקצרה ‪ .RTW-EC‬כלי זה מאפשר‬
‫לייצר קוד ‪ C‬המותאם למעבדים ספציפיים )אינטל‪ ,‬מוטורולה‪ ,‬מיקרוצ'יפ‪Analog ,TI ,‬‬
‫‪ Devices‬וכדומה(‪ .‬הקוד שנוצר הוא יעיל ביותר‪ ,‬ניתן לשלוט על מראהו ועל אופן השמתו‬
‫במרחב הזיכרון של הרכיב‪ ,‬ועוד‪.‬‬
‫‪MEX .1.5‬‬
‫פונקציות ‪) MEX‬או ‪ (MATLAB Executables‬הן למעשה פונקציות שנכתבו בשפה השונה‬
‫מ‪ ,MATLAB-‬ושולבו בתוך ‪ .MATLAB‬ניתן לייבא קוד ‪ C‬קיים‪ ,‬קוד ‪ Fortran‬ואפילו‬
‫קוד ‪ .ADA‬השימוש בפונקציות אלו זהה לשימוש בפונקציות ‪ ,MATLAB‬והן מאפשרות‬
‫למשתמשי ה‪ MATLAB-‬לנצל קוד קיים במקום לכותבו שוב‪.‬‬
‫עמוד ‪ 6‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .2‬אבני דרך מרכזיות‬
‫תהליך יצירת הקוד והמרת קוד ה‪ MATLAB-‬לקוד ‪ C‬מושתת על מספר שלבים מרכזיים‪ ,‬אשר‬
‫אופייניים גם לשלבי הפיתוח המקובלים בתעשיה‪ .‬בפרק זה יפורטו השלבים המרכזיים ו הפעולות‬
‫המרכזיות המבוצעות בשלבים אלו‪ .‬בהמשך יפורטו שלבים אלו בצורה מעמיקה ורחבה יותר‪,‬‬
‫וישולבו דוגמאות הלכה למעשה‪.‬‬
‫להלן הסכימה הכללית של התהליך‪:‬‬
‫‪ .2.1‬כתיבת קוד ‪ MATLAB‬ובדיקה התנהגותית של האלגוריתם‬
‫בשלב הראשון‪ ,‬נכתב האלגוריתם הטהור ע"י המתכנן או האלגוריתמאי‪ .‬אלגוריתם זה יכול‬
‫לכלול פעולות הנוגעות לתחום עיבוד תמונה‪/‬וידאו‪ ,‬עיבוד אותות‪ ,‬מערכות בקרה ועוד‪,‬‬
‫ויתכן כי המתכנן נעזר בפונקציות עזר מתוך ספריות המסופקות עם ‪ MATLAB‬או עם כלי‬
‫ההרחבה הנשענים עליה‪.‬‬
‫ברוב המקרים יבנה המתכנן סביבת בדיקות לאלגוריתם שלו‪ ,‬באמצעותה יבדוק פרמטרים‬
‫שונים ואליה יכניס כניסות שונות ויבחן את תוצאות האלגוריתם באמצעים ויזואליים‬
‫)גרפים‪ ,‬סקופים וכדומה(‪ ,‬יקרא או יכתוב מידע מסביבת העבודה או מקבצים‪ ,‬ויבצע‬
‫השוואות לתיאוריה שאותה בחן‪.‬‬
‫בסוף הליך זה נמצא בידי המתכנן קוד הכתוב בשפת ‪ MATLAB‬אשר מממש את‬
‫האלגוריתם בצורה המדוייקת ביותר‪ .‬נהוג לקרוא לאלגוריתם זה "‪"Golden Reference‬‬
‫או "אמת הסמך להשוואה"‪ .‬בכל אחד מהשלבים הבאים‪ ,‬נרצה לבחון את השינויים שנעשו‬
‫למול המקור‪ ,‬ולוודא כי פונקציית ה‪ MATLAB-‬עדיין תואמת בפעולתה ל‪Golden -‬‬
‫‪.Reference‬‬
‫חלק זה לא יפורט בהמשך‪ ,‬ומסתמך על כך שהקורא מכיר את התכנות ב‪MATLAB-‬‬
‫ברמה בסיסית‪.‬‬
‫‪ .2.2‬בדיקה האם הקוד שנכתב תואם ל‪EML-‬‬
‫כפי שהוזכר קודם‪ ,‬בכדי לייצר קוד ‪ C‬מתוך ‪ ,MATLAB‬ראשית עלינו לוודא כי צורת‬
‫הכתיבה שלנו‪ ,‬והפונקציות שבהן השתמשנו נתמכות ל‪ .EML-‬קיימות כ‪ 300-‬פונקציות‬
‫‪ MATLAB‬הנתמכות ל‪ ,EML-‬עוד כ‪ 100-‬פונקציות נוספות הקשורות ל‪ Fixed Point-‬ועוד‬
‫עמוד ‪ 7‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫כ‪ 40-‬פונקציות הקשורות לכלי ה‪ .Signal Processing-‬רשימת הפונקציות המלאה ניתן‬
‫למצוא בקישור הבא )או ב‪ help-‬של ‪ ,MATLAB‬תחת ‪:(Embedded MATLAB‬‬
‫‪http://www.mathworks.com/access/helpdesk/help/toolbox/eml/ug/bq1h2z7-9.html‬‬
‫הערה‪ :‬יש לציין כי בגרסה ‪ R2010a‬פיתחה חברת ‪ MathWorks‬את השימוש ב‪System -‬‬
‫‪ ,Objects‬אשר מרחיבים פונקציות אלו וכוללים פונקציות רבות מתחום עיבוד התמונה‪,‬‬
‫עיבוד האות )והחל מ‪ R2010b-‬התקשורת( – אשר עד כה נתמכו ליצירת קוד רק מתוך‬
‫‪.Simulink‬‬
‫כאמור‪ ,‬על מנת לייצר קוד‪ ,‬נדרש כי כל הפונקציות ייתמכו‪.‬‬
‫על מנת לוודא התאמה זו‪ ,‬יתכן ונידרש לכתוב מחדש חלק מהפונקציות שאנו משתמשים‬
‫בהן‪ .‬לצורך כך‪ ,‬מומלץ כי ההמרה תיעשה ע"י המתכנן‪ ,‬אשר מכיר את אופן הפעולה של‬
‫הפונקציה ויודע במידת הצורך כיצד ניתן להמירה‪.‬‬
‫‪ .2.3‬התאמת הקוד למערכות זמן‪-‬אמת‬
‫לאחר שבסעיף הקודם בדקנו כי כל ה"טקסט" הנמצא בתוך קוד ה‪ MATLAB-‬תואם ל‪-‬‬
‫‪ ,EML‬עלינו כעת לחבוש את כובע המתכנת‪ ,‬ולדאוג לכך שהאלגוריתם לא רק יהיה כתוב‬
‫ב‪ ,EML-‬אלא גם יתאים מבחינת אופן הפעולה שלו למערכות זמן אמת – מערכות‬
‫‪ .Embedded‬למשל‪ ,‬עלינו לוודא שהאלגוריתם מקבל כניסות שהן ב‪ Stream-‬של מידע‪ ,‬ולא‬
‫כ‪ Bulk-‬של מידע‪ .‬לרוב מערכות זמן‪-‬האמת ישנה כניסה דיגיטלית אשר מסוגלת להעביר‬
‫מידע ב"חבילות" )או ‪ (Packets‬של מידע‪ ,‬ולא נעשה תרגום אוטומטי ל"תמונה" או ל"אות"‬
‫או ל"חיישן"‪ .‬לכן‪ ,‬עלינו לדאוג לכך שהאלגוריתם הנדון יידע לאגור מידע שמגיע אליו‬
‫בתצורה של חבילות מידע‪ ,‬ולבצע את הפעולה שלשמה נועד רק כאשר קיבל מספיק מידע‪.‬‬
‫בנוסף‪ ,‬עלינו לוודא שהקוד יהיה יעיל וינצל כמה שפחות זיכרון או משאבי מערכת‪.‬‬
‫בשלב זה גם לרוב נוסיף שימוש באותות בעלי גודל משתנה )או ‪ (Variable Size‬אשר‬
‫מאפשרים לנו לעבוד עם כניסות שגודלן אינו קבוע בכל שלב ושלב של ריצת האלגוריתם‪.‬‬
‫בשלב זה יש כמובן להחליט על ארכיטקטורת המעבד שאיתו נעבוד‪ ,‬וכתוצאה מכך גודל‬
‫המשתנים שאיתם נעבוד )‪ 16 ,8‬או ‪ 32‬ביט(‪ .‬בעבודה עם ‪ MATLAB‬ניתן לבחור כל אחד‬
‫מהגדלים הללו תוך כדי ריצה‪ ,‬אך מערכות זמן אמת חייבות לדעת מראש מהם סוגי‬
‫המשתנים‪.‬‬
‫‪ .2.4‬יצירת פונקציית ‪ MEX‬לצורך בדיקה פונקציונלית של הקוד‬
‫בטרם נייצר קוד ‪ C‬ונטמיע אותו ברכיב החומרה שבחרנו‪ ,‬נרצה לוודא כי הקוד שאנחנו‬
‫כותבים מבצע את אותן הפעולות כמו ה‪ .Golden Reference-‬לשם כך‪ ,‬נייצר פונקציית‬
‫‪ .MEX‬פונקציות ‪) MEX‬או ‪ (MATLAB Executable‬הן פונקציות שניתן להריץ אותן‬
‫בסביבת ‪ ,MATLAB‬אך הן למעשה קוד ‪ C‬שעבר תהליך של קומפילציה – כלומר הרצה‬
‫של קוד ‪ C‬בתוך ‪.MATLAB‬‬
‫את פונקציית ה‪ MEX-‬ניתן לשלב באותה סביבת בדיקות שבה נבדק האלגוריתם המקורי‪.‬‬
‫את אותן הפעולות שבוצעו על קוד ה‪ MATLAB-‬ניתן לבצע גם על פונקציה זו‪ ,‬ולהשוות‬
‫עמוד ‪ 8‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫בצורה מלאה ביניהן‪ .‬כל שינוי בתוצאות המתקבלות מפונקציית ה‪ MEX-‬מעיד על חוסר‬
‫דיוק שהוכנס בהליך ההמרה ל‪ .EML-‬המטרה היא לוודא שחוסר הדיוק הוא מספיק קטן‬
‫בכדי שיהיה "זניח"‪ .‬יש להבין כי חוסר דיוק זה נובע מהמעבר מעבודה בסביבת מחשוב של‬
‫‪ 64‬ביט )עם דיוק כפול( לסביבת עבודה הנמצאת לרוב ב‪ 32-‬ביט )דיוק יחיד(‪ .‬לכן – שגיאות‬
‫קוונטיזציה צפויות להתקבל‪.‬‬
‫בשלב זה יש גם להחליט על האם המעבד הסופי שאליו נייצר קוד הוא מסוג ‪ Float‬או‬
‫‪ .Fixed‬במידה והוא מסוג ‪ – Float‬נוכל להמשיך לשלב הבא‪ .‬אחרת‪ ,‬עלינו לעבור שלב נוסף‬
‫של המרת האלגוריתם לעבודה ב‪ .Fixed-‬הליך זה יכול להיות קל יותר ע"י שימוש ב‪Fixed -‬‬
‫‪ ,Point Toolbox‬ולאחר סיומו מצריך בדיקה נוספת של פונקציית ‪ MEX‬למול ה‪Golden -‬‬
‫‪ ,Reference‬בכדי לוודא שחוסר הדיוק הנובע מקוונטיזציה לא פגע באופן הפעולה של‬
‫האלגוריתם‪.‬‬
‫‪ .2.5‬יצירת קוד‬
‫לאחר שייצרנו פונקציית ‪ MEX‬ובדקנו אותה למול ה‪ ,Golden Reference-‬ניתן לייצר‬
‫קוד‪ .‬בשלב זה עלינו להגדיר לאיזה מעבד ברצוננו לייצר קוד‪ ,‬כאשר הרשימה של המעבדים‬
‫הנתמכים הינה ארוכה )ומתארכת עם השנים(‪ .‬רשימה מלאה ניתן למצוא ב‪:‬‬
‫‪http://www.mathworks.com/products/rtwembedded/supportedio.html‬‬
‫יש להדגיש כי ישנן פעולות מתימטיות רבות אשר יש להן מימוש אופטימלי בהתאם לסוג‬
‫החומרה‪ ,‬ולכן מומלץ להגדיר מהי החומרה שעובדים איתה‪ .‬מעבר להגדרות הבסיסיות‬
‫האופייניות למעבדים )כמו ‪ ,Big/Little Endian‬גודל משתנים וכדומה(‪ ,‬גם המימוש עצמו‬
‫ייעשה בהתאם למעבד‪.‬‬
‫במידה ועל מחשב יצירת הקוד מותקנים כלי יצירת קוד מתקדמים )כמו ‪Embedded IDE‬‬
‫‪ Link‬או ‪ (Target Support Package‬אזי ניתן לממש בצורה יעילה גם פונקציות מתקדמות‬
‫יותר )כמו ‪ ,(FFT‬ולהגיע למימוש חומרתי ברמת אסמבלי של פעולות בסיסיות אשר זמינות‬
‫על הרכיב עצמו )כמו ‪ PID‬עבור בקר מסדרת ‪ C2000‬של ‪ Texas Instruments‬או ‪ADC‬‬
‫למעבדים של ‪.(Analog Devices‬‬
‫את הקוד שייצרנו ניתן לשלב בפרוייקט גדול יותר של ‪ Visual C++‬למשל‪ ,‬או בפרוייקטים‬
‫של מערכות זמן‪-‬אמת הקשורים ל‪ IDE-‬של הסביבה איתה עובדים )כמו ‪ CCS‬של ‪Texas‬‬
‫‪ Instruments‬או ‪ Visual DSP++‬של ‪ .(Analog Devices‬את הקוד הזה לא ניתן כמובן‬
‫להחזיר לתוך ‪ MATLAB‬ולבדוק אותו שוב – שכן הארכיטקטורה איננה זהה‬
‫לארכיטקטורה של המחשב עליו מותקן ‪.MATLAB‬‬
‫במידה ואנחנו עובדים עם ‪ ,Simulink‬ניתן לשלב את קוד ה‪ EML-‬בתוך מודל רחב יותר‪,‬‬
‫ולהמשיך בהליך הפיתוח כאשר האלגוריתם שנכתב הוא כעת בלוק אחד מתוך מערכת‬
‫מלאה יותר‪ ,‬לאחר שנבדק בצורה מלאה וידוע אופן פעולתו‪.‬‬
‫ישנה כמובן אפשרות לשילוב קוד ‪ C‬קיים‪ ,‬שנכתב בעבר‪ ,‬בתוך ‪ EML‬או בתוך ‪,Simulink‬‬
‫ובמקרה זה סביבת הפיתוח של ‪ MATLAB‬יכולה להיות סביבת האינטגרציה המלאה‪.‬‬
‫עמוד ‪ 9‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .3‬בדיקה האם הקוד שנכתב תואם ל‪EML-‬‬
‫בתחילת שלב זה‪ ,‬קיים אלגוריתם הכתוב בשפת ‪ ,MATLAB‬ואשר נבדק כי הוא מבצע את‬
‫תפקידו בצורה תקינה‪ .‬מטרת שלב זה היא ליצור קוד הכתוב ב‪ .EML-‬לפני תחילת העבודה‬
‫המפורטת בפרק זה‪ ,‬מומלץ לשמור גרסה חדשה של הקובץ שעימו עובדים – בכדי לא לפגוע ב‪-‬‬
‫‪.Golden Reference‬‬
‫המלצה מס' ‪1‬‬
‫בטרם ביצוע שינויים כלשהם‪ ,‬מומלץ לשמור את הקובץ בשם חדש‪ ,‬על מנת שתמיד יהיה ניתן לחזור‬
‫לשמירה האחרונה‪.‬‬
‫לדוגמא‪ :‬אם שם הפונקציה המקורית הוא ‪ ,myFunction‬מומלץ לשמור את הגרסאות בסדר עולה‪ ,‬כגון‬
‫‪. myFunction_01‬‬
‫את השינויים שבוצעו מומלץ לתעד באמצעות הערות‪ ,‬וניתן כמובן לשמור גרסאות שונות בכלי ה‪Version -‬‬
‫‪ Control‬במידה והוא בשימוש במערכותיכם‪ .‬קראו על איך ‪ MATLAB‬מחובר למערכות ‪:VC‬‬
‫‪http://www.mathworks.com/access/helpdesk/help/techdoc/matlab_env/f7-5297.html‬‬
‫או ב‪ help-‬כמובן‪.‬‬
‫‪ .3.1‬טיפול והסרה של כל ה"הערות" שנתגלו ע"י שימוש ב‪m-lint-‬‬
‫החל מגרסה ‪ ,R2007a‬שולב בתוך ה‪ editor-‬של ‪ MATLAB‬כלי ה‪ m-lint-‬אשר בודק את‬
‫הקוד בצורה סטטית‪ .‬תפקידו הוא לוודא כי הקוד שכתבנו אינו מכיל שגיאות‪ ,‬ובמידה‬
‫ושגינו‪ ,‬יעיר לנו על "הערה" )הקוד בעייתי‪ ,‬אך יכול לרוץ( או "שגיאה" )הקוד בעייתי‪ ,‬ולא‬
‫יכול לרוץ(‪.‬‬
‫בטרם אנו ממשיכים הלאה‪ ,‬מומלץ )וחובה( לוודא כי אין הערות‪/‬הודעות‪/‬שגיאות כלשהן‬
‫אשר לא טופלו‪ .‬במידת הצורך יש להשתמש ב‪ "Suppress this Instance of … "-‬ע"י‬
‫לחיצת כפתור ימני בעכבר על ההערה שהתגלתה‪ .‬להלן דוגמא להערה על כך שמומלץ לסיים‬
‫כל פקודה ב ";"‪:‬‬
‫עמוד ‪ 10‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .3.2‬שימוש בפרגמה ‪%#eml‬‬
‫כאשר נעבוד ב‪ ,EML-‬ה‪ m-lint-‬הוא בעל יכולות נוספות‪ ,‬ויכול לבדוק נושאים הקשורים ל‪-‬‬
‫‪ .EML‬למשל ‪ -‬לבדוק שכל הפונקציות שאנו משתמשים בהן‪ ,‬נתמכות ב‪ .EML-‬על מנת‬
‫להפעיל את ה‪ m-lint-‬במצב זה‪ ,‬יש להשתמש בפרגמה ‪ . %#eml‬את הפרגמה ניתן למקם‬
‫בכל מקום בתוך קובץ ה‪ ,m-‬אך מומלץ לשים אותה לפני הגדרת הפונקציה‪ .‬להלן דוגמא‪:‬‬
‫לאחר שמיקמנו את הפרגמה במקומה‪ ,‬על ה‪ m-lint-‬להיות "ירוק"‪ ,‬כלומר לא להכיל אף‬
‫שגיאה )ראה תמונה(‪.‬‬
‫להלן דוגמא לקוד שמכיל שגיאה שכזו‪ .‬קוד זה משתמש בפונקציית ה‪ edge-‬מתוך ספריית‬
‫ה‪ .Image Processing-‬פונקציה זו איננה נתמכת ב‪ ,EML-‬ולכן מתקבלת שגיאה‪:‬‬
‫עמוד ‪ 11‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫מהיכרות עם הקוד‪ ,‬קובץ ה‪ m-‬שנכתב אמור להשתמש בשיטת ‪ sobel‬של פונקציה זו‪.‬‬
‫אלגוריתם זה מבוסס על שימוש ב‪ 2-‬פעולות של קונבולוציה‪ ,‬ולכן אם נכתוב רק אותו‬
‫כפונקציה‪ ,‬הוא כן ייתמך והשגיאות כבר לא קיימות‪:‬‬
‫באופן זה יש לוודא כי כל הפונקציות שאנו משתמשים בהן ייתמכו‪.‬‬
‫דוגמא נוספת אשר עשויה להתקבל‪ ,‬היא על ביצוע הקצאות דינמיות של זיכרון‪ ,‬אשר אינן‬
‫נתמכות‪ .‬נסתכל לדוגמא על מקטע הקוד הבא‪ ,‬אשר אמור לבצע העתקה פשוטה של זכרון‬
‫בין ‪ 2‬משתנים‪ .‬המשתנה ‪ CarbonCopy‬הוא לא בעל גודל מוגדר מראש‪ ,‬ולכן מתקבלת‬
‫הערה על כך שמשתנה זה חייב להיות מוגדר בזמן הקריאה לפונקציה‪:‬‬
‫עמוד ‪ 12‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫מצב זה הינו מקובל ביותר בעבודה עם ‪ ,MATLAB‬שכן מערכת ההפעלה של ‪MATLAB‬‬
‫המטפלת בנושא הקצאת הזיכרון‪ ,‬תדאג בכל שלב ריצה של הלולאה להגדיל את המשתנה‬
‫בהתאם‪ .‬היא למעשה תעשה בכל שלב הקצאה מחודשת של זיכרון‪ ,‬ותעתיק אליו את‬
‫הערכים החדשים‪.‬‬
‫פעולה זו כמובן איננה נתמכת ב‪ ,EML-‬שכן בזמן הקריאה לפונקציה לא ידוע כמה פעמים‬
‫תיקרא‪ ,‬ולכן גודל המשתנה איננו מוגדר מראש‪ .‬הקצאת זיכרון דינמית זו איננה נתמכת‪,‬‬
‫מה גם שבמערכות זמן‪-‬אמת רבות לא היינו רוצים לקבל גדילה של משתנים בצורה לא‬
‫מבוקרת‪.‬‬
‫על מנת לטפל בבעיה זו‪ ,‬יש לבצע הקצאה של גודל המשתנה בזמן הכניסה לפונקציה‪ .‬דוגמא‬
‫לכך מצויה בשורה ‪ 3‬של הקוד לעיל – ע"י שימוש בפקודה ‪.zeros‬‬
‫הערה‪:‬‬
‫בהתאם ל‪ 2-‬הדוגמאות שראינו לעיל‪ ,‬ניתן להסיק כי ייתכן מצב שבו נכתוב חלק מהקוד‬
‫מחדש‪ ,‬ולא "נהנה" מהיתרונות שבעבודה עם ‪ .MATLAB‬עם זאת‪ ,‬ברגע שנבצע את‬
‫השינויים‪ ,‬אנו נקבל פעולה מהירה יותר גם של קוד ה‪ ,MATLAB-‬שכן הוא ירוץ בצורה‬
‫יעילה יותר ‪ -‬ההעתקות הרבות שלא יבוצעו‪ ,‬ההימנעות מבדיקות "מיותרות" של פונקציות‬
‫רובסטיות וכדומה ‪ -‬יחסכו זמן ריצה רב‪ .‬משתמשים רבים שעברו מ‪ MATLAB-‬ל‪EML-‬‬
‫דיווחו על חיסכון בזמני ריצה ברמה של אחוזים רבים‪ ,‬ובמקרים קיצוניים עד כדי ‪90%‬‬
‫מזמן הריצה )!(‪.‬‬
‫המלצה מס' ‪2‬‬
‫מומלץ לפעול בהתאם להנחיות ה‪ .m-lint-‬הנחיות אלו נובעות מסיבות של יעילות‪ ,‬בדיקת אפשרות‬
‫ליצירת קוד‪ ,‬וכן הימנעות משגיאות מיותרות‪ .‬קיימת אפשרות לביצוע תיקון אוטומטי לחלק מההערות‪.‬‬
‫ניתן להפעיל את ה‪ M-Lint-‬ולבחור בדיקות ספציפיות ע"י שינוי ה‪ Preferences-‬של ה‪ m-lint-‬באופן‬
‫הבא )תחת סביבת העבודה של ‪:(MATLAB‬‬
‫‪File-> Preferences-> M-Lint-> Enable Integrated M-Lint Warnings and Error Messages‬‬
‫עמוד ‪ 13‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .4‬התאמת הקוד למערכות זמן‪-‬אמת‬
‫בשלב זה יש לחבוש את כובע המתכנת יותר מאשר את כובע האלגוריתמאי ב‪ ,MATLAB-‬שכן‬
‫כעת עלינו לחשוב על הקוד שהולך להיווצר ובאיזו מערכת הוא הולך להיות משולב‪.‬‬
‫בקוד הנוצר‪ ,‬נרצה למנוע שכפולים מיותרים של משתנים )על מנת לחסוך בזיכרון(‪ ,‬להגדיר את‬
‫טיפוסי המשתנים ואת גודלם המירבי בכדי להקצות זיכרון בצורה מתאימה‪ ,‬ולטפל בפונקציות‬
‫הדואגות לויזואליזציה של ‪ ,MATLAB‬או בקריאה לפונקציות שאינן נתמכות‪ .‬כאן נטפל גם‬
‫בממשקי הפונקציה ולכך שהיא צריכה לעבוד בסופו של דבר על מעבד בזמן‪-‬אמת‪.‬‬
‫‪" .4.1‬טיפול" בפונקציות של ‪ MATLAB‬באמצעות ‪eml.extrinsic‬‬
‫תוכנת ‪ MATLAB‬מכילה הרבה מאד פונקציות אשר אינן נתמכות ליצירת קוד‪ .‬הדוגמא‬
‫הכי פשוטה לפונקציה שכזו היא פונקציית ‪ ,plot‬אשר מדפיסה גרף בחלון חדש‪ .‬פונקציה זו‬
‫כמובן איננה רלוונטית בעיסוק במערכות זמן‪-‬אמת‪.‬‬
‫על מנת שלא לשנות את כל הקוד מספר פעמים‪ ,‬וליצור פונקציות נפרדות לריצה ב‪-‬‬
‫‪ MATLAB‬ופונקציות אחרות ליצירת קוד‪ ,‬ניתן להגדיר פונקציות אלו כפונקציות‬
‫"חיצוניות" )או ‪ .(extrinsic‬הגדרה זו בעלת ‪ 2‬משמעויות‪ .1 :‬בזמן הרצת הפונקציה ב‪-‬‬
‫‪ – MATLAB‬תתנהג באופן רגיל‪ .2 .‬בזמן יצירת קוד – לא ייווצר קוד מפונקציה זו‪.‬‬
‫להלן דוגמא לפונקציה שכזו‪:‬‬
‫בדוגמא זו ניתן לראות הגדרת הפונקציות ‪ patch‬ו‪ axis-‬כ‪ .extrinsic-‬כפי שניתן לראות‬
‫הפונקציה הסופית נתמכת ב‪ %#eml-‬ונתמכת גם ליצירת קוד כמובן‪.‬‬
‫עמוד ‪ 14‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫המלצה מס' ‪3‬‬
‫בצעו הפרדה בתוך הפונקציות בין פעולות הקשורות לויזואליזציה לבין האלגוריתם המקורי‪.‬‬
‫בדוגמא הקודמת הייתה הפרדה בין ‪ – create_plot‬פונקציה הדואגת להדפסת התוצאות לבין‬
‫‪ – Pythagoras‬הפונקציה אשר מבצעת את עיבוד הנתונים‪ .‬בצורה כזו ייחסכו קריאות רבות‪,‬‬
‫והקוד שנוצר יהיה "נקי" ויעיל יותר‪ .‬בדוגמא שלעיל – כלל לא ייווצר קוד מהפונקציה השניה‪.‬‬
‫‪ .4.2‬הגדרת טיפוסי משתנים‬
‫על מנת ליצור את טיפוסי המשתנים‪ ,‬עלינו להצהיר עליהם‪ .‬ניתן לעשות זאת ב‪ 2-‬אופנים‪:‬‬
‫‪ .1‬שימוש בפקודה ‪.assert‬‬
‫‪ .2‬שימוש במשתנה לדוגמא‪ ,‬שמכיל את הגודל וטיפוס המשתנה‪.‬‬
‫שימוש בפקודה ‪assert‬‬
‫הפקודה ‪ assert‬מחזירה ערך שלילי כאשר התנאי שהיא בודקת איננו מתקיים‪ .‬למשל‪ ,‬קטע‬
‫הקוד הבא איננו נכון ולכן התוצאה היא שלילית‪:‬‬
‫כאשר אנו משתמשים ב‪ ,EML-‬לפונקציה זו ישנה חשיבות ראשונה במעלה‪ ,‬שכן במהלך‬
‫יצירת הקוד‪ ,‬הקומפיילר בוחן את הערכים הנבדקים ע"י פונקציה זו‪ ,‬ומשתמש בהם בכדי‬
‫להגדיר את הפרמטרים השונים מבחינת טיפוס ומבחינת גודל‪.‬‬
‫לדוגמא‪ ,‬אם ברצוננו להגדיר פרמטר סקלרי‪ ,X ,‬שיהיה מטיפוס ‪ uint16‬ובעל גודל מקסימלי‬
‫של ‪ ,1,000‬נעשה זאת ע"י ההגדרה הבאה‪:‬‬
‫;))'‪assert(isa(X, 'uint16‬‬
‫;)‪assert(X <= 1000‬‬
‫הפקודה ‪ isa‬בודקת את טיפוס הפרמטר ומשווה אותו ל‪ uint16-‬במקרה זה‪.‬‬
‫באופן דומה‪ ,‬אם ברצוננו להגדיר פרמטר‪ ,A ,‬כך שיהיה מטריצה בגודל ‪ ,10x20‬מטיפוס‬
‫‪ ,complex‬נעשה זאת באופן הבא‪:‬‬
‫;))‪assert(~isreal(A‬‬
‫;))]‪asser(all(size(A) == [10 20‬‬
‫הפקודה ‪ all‬בודקת כי בתוצאה המתקבלת מההשוואה‪ ,‬כל הערכים הם "נכונים"‪.‬‬
‫עמוד ‪ 15‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫באופן זהה‪ ,‬ניתן להשתמש בפקודה ‪ assert‬בכדי לוודא גדלי וטיפוסי פרמטרים סקלריים‪,‬‬
‫מטריצות בעלות ‪ N‬מימדים‪ ,‬מערכים )‪ ,(struct‬משתני ‪) Fixed Point‬עם הפקודה ‪,(isfi‬‬
‫משתני כניסה לפונקציה ומשתנים שנעשה בהם שימוש בתוך הפונקציה‪.‬‬
‫==< משתני המוצא "יורשים" ערכים אלו מתוך נתוני המשתנים הבונים אותם – ולכן לא‬
‫נדרש להגדירם‪.‬‬
‫שימוש במשתנה לדוגמא‬
‫השימוש במשתנים לדוגמא יכול להיעשות רק בזמן הליך יצירת הקוד עצמו ולא ניתן‬
‫לשילוב בתוך הקוד‪ .‬לצורך כך נעשה שימוש בדגלון ‪ –eg‬בתוספת לפונקציה ‪emlmex‬‬
‫)יצירת ‪ (MEX‬או ‪) emlc‬יצירת קוד ‪:(C‬‬
‫‪emlmex -eg {single(0)} myFunction‬‬
‫‪emlc -eg {zeros(1,4,'uint16'),double(0)} myFunc‬‬
‫‪1.‬‬
‫‪2.‬‬
‫בדוגמא הראשונה‪ ,‬נאמר לקומפיילר שהפונקציה מצפה לקבל משתנה מטיפוס ‪.single‬‬
‫שימו לב כי ערך המספר עצמו – ‪ 0‬בדוגמא זו – כלל איננו משפיע על התוצאה‪ ,‬אלא רק על‬
‫טיפוס המשתנה‪.‬‬
‫בדוגמא השניה‪ ,‬נאמר לקומפיילר שהפונקציה מצפה לקבל ‪ 2‬פרמטרים‪ .‬הראשון הוא מערך‬
‫בגודל ‪ 1x4‬מטיפוס ‪ uint16‬והשני הוא מטיפוס ‪.double‬‬
‫השימוש במשתנים לדוגמא יכול להכיל רק את סוג המשתנים‪ ,‬ולא הגודל המקסימלי‬
‫שלהם‪ .‬לכן הדרך הראשונה )ע"י שימוש ב‪ (assert-‬היא מומלצת יותר‪.‬‬
‫בשלב יצירת הקוד נדון בהרחבה בפקודות ‪ emlc‬ו‪.emlmex-‬‬
‫המלצה מס' ‪4‬‬
‫השתמש ב‪ assert-‬בתוך קובץ האלגוריתם‪ .‬בצורה זו יצירת הקוד איננה תלויה בקובץ הבנייה‬
‫ובדוגמאות חיצוניות אשר עלולות להפריע להליך זה‪.‬‬
‫ניתן לקרוא על פונקציות המסייעות לה‪ ,‬כגון‪ any ,isa, all, isfi :‬ו‪.isequal -‬‬
‫‪ .4.3‬הגדרת פרמטרים בעלי גודל משתנה )‪(Variable Size‬‬
‫פרמטרים בעלי גודל משתנה הינם פרמטרים אשר גודלם יכול להשתנות במהלך ריצת הקוד‪.‬‬
‫גודל זה חייב להיות תחום בגבול עליון כלשהו‪ ,‬על מנת שבשלב יצירת הקוד ניתן יהיה‬
‫להקצות מספיק זיכרון לעבודה עימם‪.‬‬
‫השימוש בפרמטרים אלו הוא הכרח המציאות כאשר עובדים עם כניסות שגודלן יכול‬
‫להשתנות – למשל גודל תמונה או אורך אות‪ .‬שימוש אחר נפוץ הוא בפקודה ‪ – find‬אשר‬
‫מחזירה תוצאות חיפוש על מערך בהתאם לקריטריון מסויים‪.‬‬
‫קיימות מספר דרכים להגדרת פרמטרים כבעלי גודל משתנה‪:‬‬
‫שימוש ב‪eml.varsize-‬‬
‫תחת ‪ EML‬נוספה הפונקציה ‪ eml.varsize‬אשר מאפשרת להגדיר בצורה ישירה כי פרמטר‬
‫מסויים הוא בעל גודל משתנה‪ .‬למשל הפקודה‪:‬‬
‫;)]‪eml.varsize('Y', [1 8‬‬
‫עמוד ‪ 16‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫מגדירה מטריצה ‪,Y‬בעלת ‪ 2‬מימדים מטיפוס ‪ ,double‬כאשר גודל המטריצה יכול להיות‬
‫‪ ,1x:8‬כלומר "אחד על )עד שמונה("‪ .‬הגודל השני של המטריצה יכול להשתנות בכל הטווח‬
‫מ‪ 0-‬ועד ‪ .8‬יש לשים לב כי פרמטרים בעלי גודל משתנה מקבלים את הסימון "‪ ,":‬אשר‬
‫מסמל את השינוי הצפוי בגודלם‪.‬‬
‫בצורה דומה‪ ,‬הפקודה הבאה‪:‬‬
‫;)]‪eml.varsize('myMatrix',[100 20000], [0 1‬‬
‫מגדירה את המטריצה ‪ myMatrix‬שגודלה המקסימלי הוא ‪ .100x20000‬עם זאת במקרה‬
‫זה‪ ,‬תוספת ההגדרה ]‪ [0 1‬מוסיפה אילוץ שרק הגודל השני של המטריצה הוא משתנה‪,‬‬
‫כלומר גודל המטריצה יהיה ‪ .100x:20000‬כלומר "מאה על )עד ‪ 20‬אלף("‪.‬‬
‫ובכדי להגדיר ‪ struct‬כבעל גודל משתנה‪:‬‬
‫;)‪d = struct('values', zeros(1,0), 'color', 0‬‬
‫;)]‪data = repmat(d, [3 3‬‬
‫;)'‪eml.varsize('data(:).values‬‬
‫כאן מוגדר ‪ struct‬בעל השם ‪ ,data‬אשר כל שדות ה‪ values-‬שלו הם בעלי גודל משתנה‪.‬‬
‫הערה בנוגע ליצירת הקוד‪:‬‬
‫קוד בעל פרמטרים בגודל משתנה‪ ,‬מתוקף היותו כזה‪ ,‬יהיה פחות יעיל‪ .‬זאת עקב הבדיקות‬
‫הנוספות שיש לבצע על הפרמטרים‪ ,‬העברת משתנים שמייצגים את גודלו הנוכחי של‬
‫הפרמטר‪ ,‬ועוד‪ .‬מומלץ להשתמש ביכולת זו רק כאשר אין כל פתרון אחר‪.‬‬
‫הגדרת חסמים עליונים באמצעות שימוש בפרמטרים‬
‫ניתן להגדיר פרמטרים בעלי גודל משתנה גם באמצעות חסימת גודלם המקסימלי באמצעות‬
‫פרמטר נוסף‪ .‬למשל הדוגמא הבאה‪:‬‬
‫‪function y = dim_need_bound(n) %#eml‬‬
‫;)‪assert (n <= 5‬‬
‫;)‪L= ones(n,n‬‬
‫;)‪M = zeros(n,n‬‬
‫;]‪M = [L; M‬‬
‫;‪y = M‬‬
‫בדוגמא זו מוגדרים הפרמטרים ‪ L‬ו‪ M-‬שהן מטריצות בעלות גודל של ‪. :5x:5‬‬
‫במקרים רבים נראה את הסימון "?‪ ,":‬אשר מייצג את הפרמטר שגודלו בזמן ריצה למעשה‬
‫איננו חסום בגודל‪ ,‬אלא רק בטיפוסו‪ .‬הודעה זו לרוב תלווה בהודעת שגיאה‪ ,‬שכן הגדרה זו‬
‫איננה נתמכת ב‪.EML-‬‬
‫הגדרת הפרמטר ע"י שימוש בפקודה ‪ emlcoder.egs‬ובדוגמא‬
‫כפי שראינו בפרק ‪ ,4.2‬ניתן להשתמש בפרמטר לדוגמא בשימוש עם ‪ emlmex‬או ‪ .emlc‬ניתן‬
‫להשתמש בדרך זו גם בכדי להגדיר פרמטר כבעל גודל משתנה‪ ,‬באופן הבא‪:‬‬
‫})]‪emlmex myFcn -eg {emlcoder.egs(0,[2 4‬‬
‫בדוגמא זו מוגדר כי הפרמטר המסופק לפונקציה ‪ myFcn‬הינו מטריצה בעלת הגודל‬
‫המשתנה ‪ , :2x:4‬והיא מטיפוס ‪ ,double‬בהתאם לדוגמא )]‪. (0, [2 4‬‬
‫עמוד ‪ 17‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫פתרון "אוטומטי" של הגדרת הפרמטר כבעל גודל משתנה‬
‫נסתכל על הדוגמא הבאה‪:‬‬
‫‪function y = var_by_multiassign(u) %#eml‬‬
‫)‪if (u > 0‬‬
‫;)‪y = ones(3,4,5‬‬
‫‪else‬‬
‫;)‪y = zeros(3,1‬‬
‫‪end‬‬
‫בדוגמא זו מוגדר המשתנה ‪ Y‬כמטריצה בעלת הערכים )‪ .3x(nxm‬כלומר – המימד הראשון‬
‫הוא תמיד ‪ ,3‬והערכים האחרים משתנים בהתאם לתנאי ה‪ .if-‬על מנת לפתור בעיה זו‪ ,‬נוקט‬
‫הקומפיילר בגישה המתפשרת ומגדיר את ‪ Y‬כבעל המימדים ‪.3x:4x:5‬‬
‫המלצה מס' ‪5‬‬
‫במידה והקוד אמור לקבל פרמטרים בעלי גודל משתנה‪ ,‬מומלץ להגדיר אותם בצורה חד‪-‬‬
‫ערכית בקוד עצמו‪ ,‬ע"י השימוש ב‪ eml.varsize-‬וב‪ assert-‬בכדי לחסום את גודלם‪ .‬בדרך זו לא‬
‫תהיה תלות בקריאה חיצונית לפונקציה ויופחת הסיכוי לשגיאות‪.‬‬
‫ בגרסה ‪ R2010b‬נוספה היכולת לייצר באמצעות הקצאת זיכרון דינמי עבור פרמטרים‬
‫שאינם חסומים בגודלם מלמעלה‪ .‬קראו על יכולת חדשה זו ב‪ help-‬או בקישור הבא‪:‬‬
‫‪http://www.mathworks.com/help/toolbox/eml/ug/br7rggy.html#bspud0r‬‬
‫‪ .4.4‬עבודה עם פרמטרים מסוג ‪struct‬‬
‫במידה ובקוד משולבים טיפוסי פרמטרים מסוג ‪ ,struct‬יש לפעול לפי ההנחיות הבאות‪:‬‬
‫יש להגדיר ‪ struct‬בצורה מלאה לפני השימוש באיבריו השונים‬
‫לא ניתן לקרוא לאחד מאיברי ה‪ ,struct-‬ולאחר מכן להגדיר איבר אחר‪ .‬למשל‪:‬‬
‫‪function y = Struct_01(x) %#eml‬‬
‫;‪y.f = x‬‬
‫;‪a = y.f * y.f‬‬
‫;‪y.h = exp(a) + y.f‬‬
‫פעולה זו תחזיר שגיאה‪.‬‬
‫על מנת להימנע מבעיה זו‪ ,‬יש לאתחל את כל איברי המ‪ struct-‬לפני השימוש בהם‪ .‬בדוגמא‬
‫לעיל‪ ,‬ניתן להוסיף את השורה‬
‫;‪y.h = 0‬‬
‫לפני ביצוע הפעולה על ‪ .a‬כעת הפעולה כן תיתמך‪.‬‬
‫יש להגדיר בצורה מפורשת את שדות ה‪ struct-‬כמשתנים‬
‫בתחילת הפרק דובר על השימוש בפקודה ‪ assert‬בכדי להגדיר גדלי משתנים וטיפוסים‪.‬‬
‫בעבודה עם ‪ ,struct‬יש לבצע זאת עבור כל אחד מהשדות השונים‪ ,‬בצורה מפורשת‪ .‬כלומר‪,‬‬
‫במידה וישנו ‪ struct‬בעל ‪ 2‬שדות‪ - Values, Length :‬יש להגדיר את שניהם‪.‬‬
‫עמוד ‪ 18‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫עם זאת‪ ,‬במידה ונעזרים בפרמטר לדוגמא )ע"י שימוש ב‪ ,("-eg"-‬אזי ה‪ struct-‬המקורי‬
‫מגדיר את כל השדות‪ ,‬ואין צורך לעשות זאת שוב‪.‬‬
‫שליטה על שם ה‪ struct-‬בקוד ה‪C-‬‬
‫בתהליך המרת הקוד‪ ,‬שמות ה‪ struct-‬הם אקראיים‪ .‬במידה וברצונך לשלוט על שמות אלו‪,‬‬
‫יש להשתמש בפקודה ‪ eml.cstructname‬באופן הבא‪:‬‬
‫‪%#eml‬‬
‫)‪function y = topfun(x‬‬
‫;)'‪eml.cstructname(x, 'MyStruct‬‬
‫;‪y = x‬‬
‫במידה וכבר קיים ‪ struct‬ב‪ ,C-‬ואנו רוצים להשתמש בהגדרה הקיימת עבורו‪ ,‬אזי נעשה‬
‫שימוש בדגלון '‪ 'extern‬בפקודה זו‪ ,‬לפי הדוגמא הבאה‪:‬‬
‫;)'‪eml.cstructname(structVar, 'MyStruct', 'extern‬‬
‫יש לשים לב כי במקרה זה‪ ,‬נדרש כי ‪ MyStruct‬יהיה מוגדר בקוד ‪ C‬שנכתב או הוגדר‬
‫במיקום אחר בקוד‪ .‬ניתן כמובן להשתמש ב"קבצים החיצוניים" בשימוש בפקודה ‪,emlc‬‬
‫עליה ידובר בשלב יצירת הקוד‪.‬‬
‫‪ .4.5‬עבודה עם מטריצות "ריקות"‬
‫במקרים רבים נהוג לאתחל פרמטרים כבעלי ערך "ריק" )או "]["(‪ ,‬ואז להגדיל את‬
‫הפרמטר בתוך לולאות‪ .‬בעבודה עם ‪ EML‬יש להתייחס למטריצות ריקות בצורה שונה‬
‫מהרגיל‪ ,‬שכן היינו רוצים להגדיר אותן כבעלות גודל משתנה‪ .‬במקרה זה‪ ,‬במקום ההגדרה‬
‫הבאה‪:‬‬
‫‪function y = NullMatrix(x) %#eml‬‬
‫;][ = ‪y‬‬
‫)‪while (x > 0‬‬
‫;‪x = sqrt(x) – 1‬‬
‫;]‪y = [y x‬‬
‫‪end‬‬
‫יש כמובן להגדיר את ‪ y‬כפרמטר בעל גודל משתנה‪ .‬אך במקרה זה יש להגדירו באופן הבא‪:‬‬
‫;)‪y = zeros(1, 0‬‬
‫;]‪eml.varsize('y', [1 10‬‬
‫זאת‪ ,‬כיוון שבכדי שפרמטר יוגדר כבעל גודל משתנה‪ ,‬אחד מהגדלים שלו חייב להיות שונה‬
‫מאפס‪ .‬בהגדרה "] [ "– גודל המשתנה הוא ‪ ,0x0‬ולכן לא יהיה בעל גודל משתנה‪ .‬ברגע‬
‫שנוסיף את השימוש ב‪ – zeros(1, 0)-‬הבעיה תיפתר‪.‬‬
‫‪ .4.6‬הגדרת משתנים בצורה מותנית‬
‫השימוש ב‪ EML-‬אינו מאפשר להגדיר משתנים בצורה התלויה בתנאי כלשהו‪ .‬לדוגמא‪:‬‬
‫‪function y = NullMatrix_02(x) %#eml‬‬
‫)‪if (x > 0‬‬
‫;‪y = 1‬‬
‫‪end‬‬
‫)‪if (x < 0‬‬
‫עמוד ‪ 19‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫;‪y = 2‬‬
‫‪end‬‬
‫בפונקציה זו יתכן מצב שבו אף אחד מהתנאים לא יתקיים‪ ,‬ולכן המשתנה ‪ y‬לעולם לא‬
‫יוגדר‪ EML .‬מחייב שכל הפרמטרים יאותחלו ויוגדרו‪ ,‬ועל כן יש להוסיף אתחול למשתנה‬
‫‪ ,y‬למשל הוספת ‪ y=0‬בתחילת הפונקציה‪.‬‬
‫‪ .4.7‬הקצאת זיכרון מינימלית באמצעות ‪eml.nullcopy‬‬
‫במקרים רבים נהוג לאתחל פרמטרים ע"י השימוש בפקודה ‪ ,zeros‬ולאחר מכן לשנות את‬
‫ערכם‪ .‬מצב זה יכול להוביל להעתקות זיכרון רבות אשר עשויות להיות מיותרות ולארוך‬
‫זמן רב‪.‬‬
‫בעזרת השימוש בפונקציה ‪ ,eml.nullcopy‬ניתן להגדיר את כמות הזיכרון הנדרשת‪ ,‬אך לא‬
‫לאתחל אותה בערך ראשוני‪ .‬להלן דוגמא‪:‬‬
‫‪%#eml‬‬
‫‪function X = foo‬‬
‫;‪N = 5‬‬
‫;))‪X = eml.nullcopy(zeros(1,N‬‬
‫‪for i = 1:N‬‬
‫‪if mod(i,2) == 0‬‬
‫;‪X(i) = i‬‬
‫‪else‬‬
‫;‪X(i) = 0‬‬
‫‪end‬‬
‫‪end‬‬
‫בדוגמא זו‪ ,‬המשתנה ‪ X‬מאותחל לגודל ראשוני של ]‪ ,[1 5‬מטיפוס ‪ double‬אך ערכיו ניתנים‬
‫לו רק בתוך לולאת ה‪.for-‬‬
‫יש לשים לב כי בהקצאת זיכרון‪ ,‬הערך המצוי בתא זה הוא אקראי‪ ,‬ויש לוודא כי לא נעשה‬
‫שימוש בערכים אלו לפני אתחולם‪ .‬פעולה זו עשויה להוביל לתוצאות בלתי צפויות ובלתי‬
‫רצויות‪.‬‬
‫‪ .4.8‬אינדקסים של וקטורים בעלי גודל משתנה‬
‫בשימוש באינדקסים ב‪ ,EML-‬יש לחסום את גודל הווקטור כך שיהיה סופי‪ .‬לשם כך‪ ,‬לא‬
‫ניתן להשתמש בהגדרה הבאה‪:‬‬
‫;)‪myMatrix(n:n+L-1‬‬
‫מאחר והגדלים ‪ n‬ו‪ L-‬הם בעלי גודל משתנה‪ ,‬האינדקסים של המטריצה אינם חסומים‬
‫בצורה מפורשת‪ .‬על כן‪ ,‬יש להשתמש בהגדרה הבאה‪:‬‬
‫;))‪myMatrix(n+(0:L-1‬‬
‫אשר הינה זהה לחלוטין בתפקודה‪ ,‬וכך גם האינדקסים חסומים בגודלם‪.‬‬
‫המלצה מס' ‪6‬‬
‫בדקו את הפונקציות הבאות וכיצד הן יכולות לסייע בייעול הקוד‪:‬‬
‫* ‪eml.unroll‬‬
‫* ‪eml.inline‬‬
‫עמוד ‪ 20‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .4.9‬תמיכה במשתנים גלובליים ‪global -‬‬
‫החל מגרסה ‪ ,R2010a‬נוספה התמיכה במשתנים גלובליים‪ ,‬כלומר משתנים המזוהים בכל‬
‫קבצי ה‪ m-‬עימם עובדים‪ .‬הגדרת משתנה שכזה מבוצעת באמצעות הפקודה ‪:global‬‬
‫)‪function y = use_globals(u‬‬
‫‪%#eml‬‬
‫‪% Turn off inlining to make‬‬
‫‪% generated code easier to read‬‬
‫;)'‪eml.inline('never‬‬
‫‪% Declare AR and B as global variables‬‬
‫;‪global AR‬‬
‫;‪global B‬‬
‫;)‪AR(1) = u + B(1‬‬
‫;‪y = AR * 2‬‬
‫;))‪yMatrix(n+(0:+L-1‬‬
‫כשננסה לייצר קוד או ‪ MEX‬מפונקציה זו‪ ,‬הקומפיילר יזהה כי קיימים כאן פרמטרים‬
‫גלובליים‪ ,‬ויגדיר אותם בהתאם‪ .‬אם נרצה להגדיר אותם באמצעות הדגלון ‪ ,-eg‬נעשה זאת‬
‫כך‪:‬‬
‫… ‪>> emlmex -o myGlobalMEXFunction‬‬
‫‪-global {'AR',ones(4),'B',[1 2 3]} my_Global_UsingFunction‬‬
‫‪ .4.10‬שימוש ב‪streaming-‬‬
‫ברוב מערכות זמן‪-‬האמת‪ ,‬האלגוריתם נועד לבצע פעולה מסויימת על גודל מסויים של‬
‫מידע‪ .‬עם זאת‪ ,‬המידע מגיע בתצורה של חבילות )או חלקי מידע(‪ ,‬ולכן יש לאגור את המידע‬
‫החלקי בכדי לבנות ממנו מידע בגודל הנדרש‪.‬‬
‫לדוגמא‪ ,‬עבור אלגוריתם שמבצע זיהוי שפות בתמונה‪ ,‬יש לוודא כי התמונה מגיעה במלואה‬
‫לאלגוריתם‪ ,‬ורק לאחר מכן הוא מופעל‪ .‬לשם כך יש לאסוף את המידע שמגיע בחבילות של‬
‫‪ 32‬ביט‪ ,‬לשחזר את התמונה ממצב של שורה‪-‬שורה לרמה של תמונה בגודל אמיתי‪.‬‬
‫לשם כך‪ ,‬יש להשתמש בחוצץ )או ‪ ,(buffer‬אשר מסוגל לשמור מידע לאורך זמן ריצת הקוד‪,‬‬
‫גם כאשר הפונקציה איננה פעילה‪ .‬ב‪ ,MATLAB-‬על מנת להגדיר משתנה בצורה כזו‪,‬‬
‫משתמשים בהגדרת ‪ .persistent‬צורת פתרון זו קיימת גם ב‪ ,EML-‬ואיננה מצריכה שינוי‬
‫מסויים‪.‬‬
‫להלן מקטע קוד לדוגמא להגדרת חוצצים בעלי השם ‪ fifo‬ו‪:weights-‬‬
‫‪%#eml‬‬
‫)‪function [signal_out] = myFunction(signal_in, desired‬‬
‫הגדרת הפרמטרים‬
‫אתחול ראשוני‬
‫}‬
‫}‬
‫;‪persistent weights‬‬
‫;‪persistent fifo‬‬
‫‪% Filter length:‬‬
‫;)‪L = uint32(32‬‬
‫‪% Adaptation step size:‬‬
‫;)‪mu = 4/(32*1024‬‬
‫‪% Signal length:‬‬
‫;)‪N = length(signal_in‬‬
‫‪if length(desired) == N‬‬
‫)‪if isempty(weights‬‬
‫‪% Filter coefficients:‬‬
‫;)‪weights = zeros(L,1‬‬
‫‪% FIFO Shift Register:‬‬
‫;)‪fifo = zeros(L,1‬‬
‫עמוד ‪ 21‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪end‬‬
‫‪% Pre-allocate output and error signals:‬‬
‫;)‪signal_out = zeros(N,1‬‬
‫;)‪err = zeros(N,1‬‬
‫‪% Filter Update Loop:‬‬
‫‪for n = 1:N‬‬
‫עדכון בזמן ריצה‬
‫;)‪fifo(1:L-1) = fifo(2:L‬‬
‫;)‪fifo(L) = distorted(n‬‬
‫;‪signal_out(n) = weights' * fifo‬‬
‫; )‪err(n) = desired(n) - signal_out(n‬‬
‫;‪weights = weights + mu*err(n)*fifo‬‬
‫‪end‬‬
‫}‬
‫‪else‬‬
‫;)'‪error('Lengths of input signals are not equal‬‬
‫‪end‬‬
‫‪end‬‬
‫מקטע קוד זה נתמך ליצירת קוד ו‪ ,EML-‬במגבלה הבאה‪:‬‬
‫פרמטר שמוחזר מהפונקציה לא יכול להיות משתנה מסוג ‪ .persistent‬כלומר – הפרמטר‬
‫‪ fifo‬או ‪ weights‬לא יכול להיות מוצא מפורש של הפונקציה‪ .‬במידה ונדרש לעשות זאת‪ ,‬יש‬
‫להגדיר פרמטר חדש שיכיל ערכים אלו‪ .‬למשל‪ ,‬הגדרת השורה הבאה‪:‬‬
‫;‪weights_out = weights‬‬
‫⇐ יש לשים לב‪ ,‬כי במידה ונדרש לבצע ‪ Streaming‬לאלגוריתמים העוסקים בעיבוד אותות‪,‬‬
‫עיבוד תמונה או מערכות תקשורת‪ ,‬אזי החל מגרסה ‪ R2010a‬קיימות פונקציות אלו‬
‫לשימוש המתכנן בצורה חופשית‪ ,‬בכלים המוספים – ‪Video and Image Processing‬‬
‫‪ Signal Processing Blockset ,Blockset‬ו‪.Communications Blockset-‬‬
‫המלצה מס' ‪7‬‬
‫לאחר ביצוע השינויים‪ ,‬ניתן להשוות בין קובץ המקור לקובץ עם השינויים מבחינת ה"טקסט"‪,‬‬
‫ע"י שימוש ב‪ . Tools > Compare Against > Browse -‬בחלון ה‪ editor-‬ייפתחו ‪ 2‬הקבצים‬
‫וניתן יהיה להשוות ביניהם בצורה פשוטה‪.‬‬
‫‪ .4.11‬בדיקה פונקציונלית‬
‫בפרק זה נעשו לא מעט שינויים בקובץ המקור‪ ,‬וייתכן והוזרקו מספר שגיאות לאלגוריתם‪.‬‬
‫על מנת לוודא שהקובץ החדש מבצע בדיוק את אותה הפעולה כמו הקובץ המקורי‪ ,‬יש‬
‫להשוות בין פעולתם‪.‬‬
‫בדיקה זו ניתן לבצע בפשטות ע"י כתיבת ‪ test-script‬אשר יקח כניסות מסוג מסויים‬
‫וישתמש בהן בכדי לקרוא לפונקציה המקורית ולפונקציה הנתמכת ב‪ .EML-‬באמצעות‬
‫‪ MATLAB‬ככלי וריפיקציה נוכל לאגור את התוצאות מכל פונקציה‪ ,‬ולהראות את‬
‫הסטיות בצורה ויזואלית – במידה וישנן כאלו‪.‬‬
‫מאחר והאלגוריתם החדש הוא זה שיועבר ליצירת קוד‪ ,‬בדיקה זו הינה חשובה יותר‪,‬‬
‫ואיננה בגדר "המלצה"‪.‬‬
‫יש לוודא כי הסטיות ‪ -‬במידה ונתגלו ‪ -‬הן מזעריות‪ ,‬או כאלו שהן צפויות בשינוי בין‬
‫המימושים – למשל שגיאות קוונטיזציה במעבר מ‪ double-‬ל‪.uint8-‬‬
‫עמוד ‪ 22‬מתוך ‪33‬‬
MATLAB ‫ מתוך‬C ‫קווים מנחים ליצירת קוד‬
‫ מקטעי הקוד )הקוד המקורי‬2-‫ המראה כיצד ניתן לקרוא ל‬test-script-‫להלן דוגמא ל‬
:(EML-‫והקוד הנתמך ל‬
%% Test Bench for LMS Filter Example
% Version #2 -- EML Compliant vs. Baseline MATLAB Code
%% Setting up:
% Initialize:
close all; clear all; clc;
%% Creating Signals:
% Load desired audio signal:
data = load('handel.mat');
desired = data.y;
Fs = data.Fs;
% Length of desired signal:
N = length(desired);
% Maximum signal length:
MaxLength = 128*1024;
% samples
% Filter length:
L = 32;
% Band-limited AWGN:
load emldemo_lms_filter.mat;
lambda = 1.0;
whiteNoise = lambda*randn(N,1);
noise = filter(b,1,whiteNoise);
% Distorted signal:
distorted = desired + noise;
%% Apply Algorithm:
% Golden reference:
[gold.signal gold.error gold.impulse] =
emldemo_lms_01(whiteNoise,distorted,L);
% Algorithm under test:
[test.signal test.error test.impulse] =
emldemo_lms_02_mex(whiteNoise,distorted);
%% Find differences:
diff.signal
=
test.signal
- gold.signal;
diff.error
=
test.error
- gold.error;
diff.impulse =
test.impulse - gold.impulse;
%% Plot differences:
figure;
subplot(3,1,1);
plot(diff.signal);
title({'Algorithm Under Test versus Golden Reference' 'Output
Signal'});
subplot(3,1,2);
plot(diff.error);
title('Error Signal');
subplot(3,1,3);
stem(diff.impulse);
title('Impulse Response');
8 '‫המלצה מס‬
:‫ למשל‬.‫ מומלץ לתת שמות התואמים לפעולת הקוד‬script ‫ או קבצי‬m ‫בשמירת קבצי‬
.02 ‫ גרסה‬,‫ – האלגוריתם הנדון‬myAlgorithm_02
.01 ‫ גרסה‬,myAlgorithm ‫ – קובץ המסייע לבניית קוד עבור‬myAlgorithm_build_01
.03 ‫ גרסה‬,‫ – קובץ המסייע לבדיקת האלגוריתם‬myAlgorithm_Test_03
33 ‫ מתוך‬23 ‫עמוד‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .5‬יצירת פונקציית ‪ MEX‬לצורך בדיקה פונקציונלית של הקוד‬
‫כפי שנכתב קודם‪ ,‬בטרם נייצר קוד ‪ C‬בצורה סופית‪ ,‬ונטמיע אותו ברכיב החומרה שבחרנו‪ ,‬נרצה‬
‫ראשית לוודא כי הקוד שנוצר מבצע את אותן הפעולות כמו ה‪.Golden Reference-‬‬
‫הדרך לעשות זאת היא ע"י יצירת פונקציית ‪.MEX‬‬
‫פונקציות ‪) MEX‬או ‪ (MATLAB Executable‬הן פונקציות שניתן להריץ אותן בסביבת‬
‫‪ ,MATLAB‬אך הן למעשה קוד ‪ C‬שעבר תהליך של קומפילציה – כלומר הרצה של קוד ‪ C‬בתוך‬
‫‪.MATLAB‬‬
‫את פונקציית ה‪ MEX-‬ניתן לשלב באותה סביבת בדיקות שבה נבדק האלגוריתם המקורי‪ .‬את‬
‫אותן הפעולות שבוצעו על קוד ה‪ MATLAB-‬ניתן לבצע גם על פונקציה זו‪ ,‬ולהשוות בצורה‬
‫מלאה ביניהן‪ .‬כל שינוי בתוצאות המתקבלות מפונקציית ה‪ MEX-‬מעיד על חוסר דיוק שהוכנס‬
‫בהליך ההמרה ל‪ .EML-‬המטרה היא לוודא שחוסר הדיוק הוא מספיק קטן בכדי שיהיה "זניח"‪.‬‬
‫יש להבין כי חוסר דיוק זה נובע מהמעבר מעבודה בסביבת מחשוב של ‪ 64‬ביט )עם ‪Double‬‬
‫‪ (Precision‬לסביבת עבודה הנמצאת לרוב ב‪ 32-‬ביט )‪ .(Single Precision‬לכן – שגיאות‬
‫קוונטיזציה צפויות להתקבל‪.‬‬
‫בשלב זה יש גם להחליט האם על המעבד הסופי שעבורו נייצר קוד הוא מסוג ‪ Float‬או ‪.Fixed‬‬
‫במידה והוא מסוג ‪ – Float‬נוכל להמשיך לשלב הבא‪ .‬אחרת‪ ,‬עלינו לעבור שלב נוסף של המרת‬
‫האלגוריתם לעבודה ב‪ .Fixed-‬הליך זה יכול להיות קצר ביותר ע"י שימוש ב‪Fixed Point -‬‬
‫‪ ,Toolbox‬ולאחר סיומו מצריך בדיקה נוספת של פונקציית ‪ MEX‬למול ה‪,Golden Reference-‬‬
‫בכדי לוודא שחוסר הדיוק הנובע מקוונטיזציה לא פגע באופן הפעולה של האלגוריתם‪.‬‬
‫עמוד ‪ 24‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .5.1‬יצירת פונקציית ‪MEX‬‬
‫על מנת לייצר פונקציית ‪ ,MEX‬יש לוודא כי על עמדת המשתמש מותקן ה‪ Simulink-‬או ה‪-‬‬
‫‪.Fixed Point Toolbox‬‬
‫הפקודה שמייצרת ‪ mex‬מתוך ‪ EML‬היא ‪ ,emlmex‬ושימוש לדוגמא‪:‬‬
‫‪>> emlmex -report -eg { myExamplePARAMS } myEMLFunction‬‬
‫דוגמא זו מייצרת קוד ‪ C‬מתוך הפונקציה ‪ ,myEMLFunction‬ו"עוטפת" אותו במעטפת‬
‫מתאימה לצורך הרצתו בתוך סביבת ‪.MATLAB‬‬
‫במידה וקיימת בעיה כלשהי – פונקציה שאיננה נתמכת למשל – תוצאת הריצה תהיה דו"ח‬
‫שמציג מהי מהות השגיאה והצעה לפתרונה‪.‬‬
‫ יש לשים לב‪ ,‬כי על מנת לייצר ‪ ,MEX‬יש להגדיר קומפיילר נתמך באמצעות הפקודה‪:‬‬
‫‪>> mex -setup‬‬
‫ובחירה של קומפיילר מתאים‪ .‬למערכות ‪ 32‬ביט‪ ,‬מסופק יחד עם ‪ MATLAB‬קומפיילר‬
‫שכזה‪ .LCC ,‬למערכות ‪ 64‬ביט‪ ,‬יש להתקין קומפיילר מתוך רשימה של קומפיילרים‬
‫נתמכים‪ .‬רשימה זו ניתן למצוא ב‪-‬‬
‫‪. http://www.mathworks.com/support/compilers/R2010b/index.html‬‬
‫לאחר סיום יצירת פונקציית ה‪ ,MEX-‬נוצר קובץ חדש‪ ,‬בעל השם ‪ ,myEMLFunction‬ובעל‬
‫הסיומת ‪) .mexw32‬למערכת הפעלה חלונות‪ 32 ,‬ביט(‪ .‬סיומת זו תשתנה ממערכת הפעלה‬
‫אחת לשניה‪) .‬עבור מערכת הפעלה ‪ 64 Linux‬ביט‪ ,‬תתקבל הסיומת ‪.(mexa64‬‬
‫המלצה מס' ‪9‬‬
‫ניתן לייבא לתוך סביבת ‪ MATLAB‬הן קבצי ‪ C‬והן קבצי ‪ Fortran‬שנכתבו בעבר‪ .‬לקריאה‬
‫נוספת על יכולת זו‪ ,‬אשר עשויה לחסוך זמן רב בתהליך הפיתוח‪ ,‬ניתן לקרוא ב‪:‬‬
‫‪>> doc mex‬‬
‫הסיומת ‪ ,MEX‬הינה בעלת קדימות גבוהה יותר מבחינת ‪ .MATLAB‬לכן‪ ,‬אם קיימים ‪2‬‬
‫קבצים‪ ,‬אחד בעל הסיומת ‪ ,.m‬והשני בעל הסיומת ‪ ,.mexw32‬הקובץ השני ייקרא לפני‬
‫הראשון‪ .‬לכן‪ ,‬כשמייצרים את פונקציית ה‪ ,MEX-‬מומלץ לתת לה שם ייחודי בעזרת הדגלון‬
‫‪ , -o‬למשל‪:‬‬
‫‪emlmex -eg { myExamplePARAMS } myFunction –o myMEXFunction‬‬
‫כעת הקובץ החדש יהיה בעל השם הייחודי ‪ , myMEXFunction.mexw32‬ולא ייקרא‬
‫במקום הקוד המקורי‪.‬‬
‫בפרק ‪ 6‬מוצגת היכולת לייצור קוד ‪ C‬מתוך ‪ ,EML‬ע"י השימוש בפקודה ‪ .emlc‬באמצעות‬
‫פקודה זו ניתן לייצר גם קוד ‪ ,MEX‬באופן הבא‪:‬‬
‫‪emlc -eg { myExamplePARAMS } myFunction –o myMEXFunction‬‬
‫או ע"י‪:‬‬
‫‪emlc –T MEX -eg { myExamplePARAMS } myFunction –o myMEXFunction‬‬
‫עמוד ‪ 25‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫תוצאת פקודה זו הינה גם כן קובץ ‪ ,.mexw32‬אך כזה שנוצר ע"י שימוש ב‪ .RTW-‬מאחר וקוד זה‬
‫יעיל יותר‪ ,‬ייתכנו שינויים בזמני ריצה ו‪/‬או ביצועים אחרים בהשוואה בין ‪ 2‬תוצרים אלו‪.‬‬
‫‪ .5.2‬בדיקה למול קוד המקור‬
‫בפרק ‪ 4.11‬בוצעה בדיקה של קוד ה‪ EML-‬למול קוד ה‪ .MATLAB-‬ניתן להשתמש באותה‬
‫סביבת הבדיקות על מנת לבדוק כי גם פונקציית ה‪ MEX-‬מחזירה בדיוק את אותן‬
‫התוצאות כמו ה‪ .EML-‬בבדיקה זו‪ ,‬אנו בודקים את קוד ה‪ C-‬בצורה פונקציונלית‪ ,‬כי הוא‬
‫מבצע בדיוק את מה שציפינו ממנו‪.‬‬
‫כאשר מיוצר קוד מתוך ה‪ ,EML-‬מבוצעות מספר פעולות של אופטימיזציה ושל התאמת‬
‫הקוד לפעולה יעילה יותר‪ .‬לכן‪ ,‬עלולה להתקבל התנהגות השונה מזו שציפינו‪ .‬התנהגות זו‪,‬‬
‫במידה ותתקבל‪ ,‬תתרחש בסבירות גבוהה במקרי קצה של גדלי הנתונים השונים‪.‬‬
‫‪ .5.3‬בדיקת זמני ריצה של קוד ה‪ MEX-‬והשוואה למקור‬
‫אנשים רבים ברחבי העולם טוענים כי קוד ‪ C‬רץ בצורה מהירה יותר מאשר ‪.MATLAB‬‬
‫עקב כך‪ ,‬הציפייה היא שקוד ‪ MEX‬ירוץ מהר יותר מאשר קוד המקור‪ ,‬ולכן מושקע מעמץ‬
‫בהאצת פעולת ‪ MATLAB‬ע"י המרת חלקים מהקוד ל‪.MEX-‬‬
‫ככלל – הנחה זו אינה מתקיימת תמיד – ממספר סיבות‪:‬‬
‫‪ MATLAB‬הינה שפה אשר עובדת כ‪ - Interpreter-‬כלומר לוקחת את הקוד שנכתב‪,‬‬
‫ומריצה אותו שלב אחר שלב ‪ -‬תוך קריאה לפונקציות המתאימות‪ .‬בשנים האחרונות‪,‬‬
‫השקיעה חברת ‪ MathWorks‬משאבים רבים במטרה להאיץ את ‪ .MATLAB‬זאת – ע"י‬
‫מימוש מחדש של חלק גדול מאד מהפונקציות הבסיסיות והמתקדמות‪ ,‬שימוש בספריות‬
‫‪ – (Basic Linear Algebra Subroutines) BLAS‬מימוש מהיר יותר של פעולות מתמטיות‪,‬‬
‫וכן שימוש נרחב יותר ויותר בפעולות ‪ – MultiThreaded‬כלומר מימוש מקבילי של‬
‫הפונקציות‪.‬‬
‫בעקבות עבודה נרחבת זו‪ ,‬ניתן כיום לראות שיפורים משמעותיים בעבודה בגרסה חדשה‬
‫של ‪ MATLAB‬לעומת גרסאות ותיקות יותר‪ .‬באחד המקרים בתעשיה‪ ,‬נתגלה שיפור של‬
‫כ‪ 65%-‬בזמן הרצת הקוד‪ ,‬מתוקף המעבר מגרסה ‪ R2006b‬לגרסה ‪.R2009b‬‬
‫המסקנה היא שגם אם נשלב פונקציות ‪ C‬לתוך ‪ ,MATLAB‬ונריץ את כולן יחדיו – כנראה‬
‫שעדיין ‪ MATLAB‬תוכל לרוץ מהר יותר‪.‬‬
‫חשוב לציין כאן כי כל השוואה בין זמני הריצה של קוד ה‪ MATLAB-‬לקוד הממומש כ‪-‬‬
‫‪ MEX‬היא גם חסרת תועלת – במידה וייוצר קוד ‪ ,C‬הרי הוא יופעל על גבי מערכת הפעלה‬
‫אחרת‪ ,‬ישולב עם קוד נוסף‪ ,‬או יועבר למעבד השונה מהמעבד עליו מותקנת ‪ .MATLAB‬על‬
‫כן‪ ,‬כל עוד לא נבחן את הקוד על מקומו הסופי – לא נדע בדיוק את מהירות הריצה שלו‪.‬‬
‫ואף על פי כן – אם נבדוק את השינויים בזמני הרצת הקוד – למשל‪ ,‬אם נשפר את קוד ה‪-‬‬
‫‪ EML‬וקוד ה‪ MEX-‬יואץ פי ‪ – 2‬אזי כנראה שגם על מעבד המטרה הקוד יעבוד מהר יותר‪.‬‬
‫עמוד ‪ 26‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .6‬יצירת קוד‬
‫מבחינה היסטורית‪ ,‬טכנולוגיית יצירת הקוד של ‪ MathWorks‬פותחה על מנת להאיץ סימולציות‬
‫של מאות ואלפי בלוקים בתוך ‪ .Simulink‬לכן‪ ,‬בכדי לייצר קוד מתוך ‪ ,MATLAB‬נדרש רישיון‬
‫זמין ל‪ Simulink-‬ול‪.RTW-‬‬
‫בפרק זה נדגים כיצד ניתן לייצר קוד מתוך ‪ MATLAB‬עבור ‪.EML‬‬
‫יש לציין כי ניתן לשלב קוד ‪ EML‬בתוך בלוקים של ‪Embedded MATLAB Function Blocks‬‬
‫כחלק מ‪ .Simulink-‬טכנולוגיית יצירת הקוד מתוך ‪ Simulink‬קיימת זמן רב יותר‪ ,‬ולכן קיימות‬
‫אפשרויות רבות יותר דרך הממשק הגרפי של ‪ .Simulink‬בסביבת ‪ Simulink‬ניתן‪ ,‬למשל‪ ,‬להגדיר‬
‫את חלוקת מרחבי הזיכרון למעבד המטרה‪.‬‬
‫עם זאת‪ ,‬גרסה ‪ R2010b‬של ‪ MATLAB‬מהווה קפיצת מדרגה בטכנולוגיה זו‪ ,‬וכמעט כל‬
‫האפשרויות זמינות גם ליצירת קוד מתוך ‪ MATLAB‬בגרסה זו‪.‬‬
‫הפקודה שמייצרת קוד מתוך ‪ EML‬היא ‪ ,emlc‬ושימוש לדוגמא‪:‬‬
‫‪emlc -report -eg { myExamplePARAMS } myEMLFunction –s rtwcfg‬‬
‫דוגמא זו מייצרת קוד ‪ C‬מתוך הפונקציה ‪ ,myEMLFunction‬מייצרת דו"ח ‪ HTML‬של הקוד‪.‬‬
‫במקרה זה ניתן לראות גם את הגדרות יצירת הקוד‪ ,‬ע"י השימוש בדגלון ‪ –s‬כשלאחריו מופיע‬
‫אובייקט הגדרות הקוד‪.‬‬
‫במידה וקיימת בעיה כלשהי – פונקציה שאיננה נתמכת למשל – תוצאת הריצה תהיה דו"ח שמציג‬
‫מהי מהות השגיאה והצעה לפתרונה‪.‬‬
‫ בטרם הגעה לשלב זה‪ ,‬יש לוודא כי קוד ה‪ MATLAB-‬מותאם ל‪ ,EML-‬וכן בוצעו כל‬
‫ההגדרות של הפרקים הקודמים‪.‬‬
‫ הגדרת טיפוסי המשתנים‪ ,‬גודלם ושאר הפרמטרים ‪ -‬מבוצע באותו האופן כמו עבור הפקודה‬
‫‪ emlmex‬כפי שהוצג בפרק הקודם‪.‬‬
‫כמו עבור יצירת ‪ MEX‬יש לשים לב כי על מנת לייצר קוד‪ ,‬יש להגדיר קומפיילר נתמך באמצעות‬
‫הפקודה‪:‬‬
‫‪>> mex –setup‬‬
‫‪ .6.1‬תוצרים שונים מהפקודה ‪emlc‬‬
‫כשאנחנו בוחרים לייצר קוד בצורה אוטומטית‪ ,‬אנחנו נדרשים לבחור גם את אופן יצירת‬
‫הקוד‪ ,‬כלומר באיזה פורמט היינו מעוניינים לקבל אותו‪ ,‬בהתאם לצורכינו‪ emlc .‬מאפשרת‬
‫לנו לייצר קוד במספר סוגים‪:‬‬
‫א‪ .‬ייצור קוד ‪ – MEX‬תוצר הזהה לשימוש בפקודה ‪ ,emlmex‬רק שכעת הקוד יעיל יותר‪,‬‬
‫וניתן לראות גם את קוד המקור שלו‪ .‬זוהי ברירת המחדל‪.‬‬
‫עמוד ‪ 27‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫ב‪ .‬יצירת ספריה – ‪ – lib‬הקוד הנוצר נעטף בספריה מתאימה‪.‬‬
‫ג‪ .‬יצירת קובץ עצמאי – ‪ – EXE‬הקוד נוצר‪ ,‬מקומפל ומקושר בכדי לייצר קובץ עצמאי‪.‬‬
‫בכדי לבחור את התוצר המתאים‪ ,‬יש להשתמש בדגלון ‪ –T‬באופן הבא‪:‬‬
‫‪%Generate mex-function‬‬
‫)‪% Generate library‬‬
‫)‪% Generate Standalone exe‬‬
‫‪>> emlc –T mex myEMLFunction‬‬
‫‪>> emlc –T rtw:lib myEMLFunction‬‬
‫‪>> emlc –T rtw:exe myEMLFunction‬‬
‫‪ .6.2‬התאמה אישית של הקוד הנוצר )דגלון ‪(–s‬‬
‫הקוד נוצר בצורה אוטומטית‪ ,‬ועל כן יש להגדיר כיצד היינו רוצים שהקוד ייראה בסוף‬
‫התהליך‪ .‬בחירת שפת הקוד‪ ,‬שמות המשתנים‪ ,‬הוספת הערות‪ ,‬שליטה על אופטימיזציה‪,‬‬
‫אופן אתחול והעתקת וקטורים וכדומה – כולם פרמטרים שניתן לשלוט עליהם‪.‬‬
‫אופן ההתאמה ב‪ MATLAB-‬נעשה ע"י שימוש ב‪ 3-‬אובייקטים מתאימים‪ ,‬אשר מאפשרים‬
‫לשלוט על‪:‬‬
‫א‪ .‬אופן יצירת קוד ה‪ .MEX-‬בעזרת האובייקט ‪. emlcoder.MEXConfig‬‬
‫ב‪ .‬הגדרות ה‪ .RTW-‬בעזרת האובייקט ‪. emlcoder.RTWConfig‬‬
‫ג‪ .‬הגדרות חומרה עבור מעבד המטרה‪ .‬זאת נבצע ע"י הגדרת האובייקט‬
‫‪. emlcoder.HardwareImplementation‬‬
‫אובייקטים אלו נוצרים בתוך ה‪ Workspace-‬של ‪ ,MATLAB‬וניתן כמובן לשמור אותם‬
‫לקובץ ‪ ,.mat‬ולדאוג להעברתם מ‪ session-‬ל‪ session-‬וממשתמש למשתמש‪ ,‬מבלי לדאוג‬
‫לייצר אותם בכל פעם מחדש‪.‬‬
‫‪ 6.2.1‬שימוש ב‪emlcoder.MEXConfig-‬‬
‫הגדרת האובייקט‪>> mxcfg = emlcoder.MEXConfig :‬‬
‫עריכת האובייקט‪>> open mxcfg :‬‬
‫מתקבל המסך הבא‪ ,‬בו אפשר להגדיר מספר רב של נתונים ואפשרויות‪.‬‬
‫תחת ‪ ,General‬נקבע האם ברצוננו לאפשר שימוש בוקטורים בעלי גודל משתנה‪ ,‬לאפשר‬
‫שימוש ב‪ ,BLAS-‬ולבחור האם למקם כל פונקציית ‪ MATLAB‬שנוצרת לקובץ ‪ C‬נפרד‪,‬‬
‫או האם לשלב את כל הקבצים לקובץ בודד‪ .‬כאן גם נבחר האם ברצוננו לייצר קוד ‪ C‬או‬
‫‪.C++‬‬
‫תחת ‪ Optimization‬ו‪ Advanced-‬מופיעים אובייקטי האופטימיזציה – למשל קביעת‬
‫ספים ל‪ inline-‬של פונקציות‪ ,‬שימוש ב‪ memcpy-‬וב‪ ,memset-‬ועוד‪.‬‬
‫אם ברצוננו להוסיף הערות ותיעוד לקוד המיוצר‪ ,‬נוכל לשלוט על כך ב‪ report-‬וב‪-‬‬
‫‪.comments‬‬
‫עמוד ‪ 28‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫מסך הגדרות ה‪emlcoder.MEXConfig-‬‬
‫‪ 6.2.2‬שימוש ב‪emlcoder.RTWConfig-‬‬
‫הגדרת האובייקט‪>> rtwcfg = emlcoder.RTWConfig :‬‬
‫עריכת האובייקט‪>> open rtwcfg :‬‬
‫מתקבל המסך הבא‪ ,‬בו אפשר להגדיר מספר רב של נתונים ואפשרויות‪.‬‬
‫תחת ‪ ,General‬נקבע האם ברצוננו לאפשר שימוש בוקטורים בעלי גודל משתנה‪ ,‬לאפשר‬
‫שימוש ב‪ ,BLAS-‬ולבחור האם למקם כל פונקציית ‪ MATLAB‬שנוצרת לקובץ ‪ C‬נפרד‪,‬‬
‫או האם לשלב את כל הקבצים לקובץ בודד‪ .‬כאן גם נבחר האם ברצוננו לייצר קוד ‪ C‬או‬
‫‪.C++‬‬
‫תחת ‪ Interface‬מצויות מספר הגדרות מאד משמעותיות‪ ,‬ביניהן בחירת ה‪Target -‬‬
‫)‪ ,Function Library (TFL‬תמיכה במספרים ‪ ,Floating‬הגדרת פונקציית ‪Terminate‬‬
‫ועוד‪.‬‬
‫ במידה וברצוננו לשלוט ולדאוג לאופטימיזציה גבוהה יותר של הקוד‪ ,‬נוכל לעשות‬
‫זאת ע"י שימוש ב‪ .RTW-EC-‬בכדי לייצר את האובייקט המתאים‪ ,‬יש להגדירו באופן‬
‫הבא‪:‬‬
‫עמוד ‪ 29‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫)'‪>> rtwcfg = emlcoder.RTWConfig('ert‬‬
‫מסך הגדרות ה‪emlcoder.RTWConfig('ert')-‬‬
‫‪ 6.2.3‬שימוש ב‪emlcoder.HardwareImplementation-‬‬
‫הגדרת האובייקט‪>> hwcfg = emlcoder.HardwareImplementation :‬‬
‫עריכת האובייקט‪>> open hwcfg :‬‬
‫באמצעות אובייקט זה ניתן לבחור את ארכיטקטורת המעבד והיצרן שעבורו ברצוננו‬
‫לייצר קוד‪.‬‬
‫בחירה ביצרן מסויים מגדירה לנו את ארכיטקטורת יצירת הקוד‪ ,‬שימוש ב‪ Little-‬או‬
‫‪ BigEndian‬וכדומה‪.‬‬
‫ במידה ויש גישה ל‪ ,Target Support Package-‬במסך זה יהיה מספר גדול יותר של‬
‫אפשרויות ומעבדים שונים‪.‬‬
‫עמוד ‪ 30‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫מסך הגדרות ה‪emlcoder.HardwareImplementation-‬‬
‫ במידה וברצוננו להשתמש במספר אובייקטים‪ ,‬נוכל לשרשר אותם‪:‬‬
‫‪>> emlc –T rtw:lib myEMLFunction –s rtwcfg –s hwcfg‬‬
‫עמוד ‪ 31‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .6.3‬שימוש בדו"ח יצירת הקוד‬
‫כחלק מהליך יצירת הקוד‪ ,‬מיוצר דו"ח מפורט המציג מספר נתונים מרכזיים‪:‬‬
‫‪ .1‬נתונים כלליים על מועד יצירת הקוד‪ ,‬סיכום התהליך‪.‬‬
‫‪ .2‬מסך סיכום נתונים על הפרמטרים שהוגדרו בקוד ובממשק אליו – האם הם ממשיים‬
‫או מרוכבים‪ ,‬גודל‪ ,‬טיפוס וכדומה‪.‬‬
‫‪ .3‬מסך על מעבד המטרה שעבורו נוצר הקוד‪.‬‬
‫‪ .4‬מסך קוד המקור שממנו נוצר קוד ה‪.C-‬‬
‫‪ .5‬אופן הקריאה לכל הפונקציות שמהן נוצר הקוד‪.‬‬
‫‪ .6‬הקוד המיוצר בחלוקה לפונקציות‪ ,‬עם ניווט מהיר להגדרות הפרמטרים השונים‪.‬‬
‫דו"ח זה מפשט ומקל על אופן בחינת הקוד והגדרתו‪ ,‬ניתן לייצוא למסמך ‪ word‬ו‪pdf-‬‬
‫וכמובן לבחינה בסקרי תכנון שונים‪.‬‬
‫‪ .6.4‬המלצות לייצור הקוד‬
‫‪ 6.4.1‬כפי שהוצג קודם‪ ,‬ישנן אפשרויות רבות יותר לשליטה על הקוד באמצעות‬
‫‪ .Simulink‬מאחר ומבחינה רישיונית בכל מקרה נעשה שימוש ב‪ ,Simulink-‬הרי שמומלץ‬
‫להשתמש בה כסביבת יצירת קוד‪ .‬משתמשים רבים ב‪ RTW-‬משתמשים ב‪Simulink-‬‬
‫כסביבת בדיקות וכסביבת יצירת קוד ולא כסביבת הפיתוח )למרות היתרונות הרבים‬
‫שלה(‪.‬‬
‫‪ 6.4.2‬תהליך יצירת הקוד יכול להיות מאד מורכב וארוך‪ .‬על כן‪ ,‬מומלץ להיעזר במשתמש‬
‫שכבר עבר הליך זה בעבר‪ ,‬או ביועץ‪/‬מהנדס אפליקציה של נציג ‪ MathWorks‬בארץ‪.‬‬
‫עמוד ‪ 32‬מתוך ‪33‬‬
‫קווים מנחים ליצירת קוד ‪ C‬מתוך ‪MATLAB‬‬
‫‪ .7‬סיכום‬
‫השימוש ב‪ Embedded MATLAB-‬ותהליך יצירת הקוד מסיר את הצורך לקודד‪ ,‬לתחזק ולבדוק‬
‫קוד שנכתב בצורה ידנית‪ .‬סבבי הפיתוח מתקצרים כתוצאה מכך‪ ,‬ומאפשרים להתמקד בשיפור‬
‫וייעול התכנון במקום לתחזק עותקים כפולים של קוד שנכתבו בשפות שונות‪.‬‬
‫במסמך זה הוצג תהליך העבודה הנדרש לצורך התאמת קוד המקור ל‪ ,EML-‬כיצד ניתן לבדוק‬
‫את הקוד מבחינה פונקציונלית ולוודא כי הוא מבצע את הנדרש ממנו‪ ,‬כיצד ניתן לייצר קוד‬
‫‪ C/C++‬בצורה אוטומטית‪ ,‬וכיצד ניתן להתאימו למעבד המטרה‪.‬‬
‫חשוב לציין כי טכנולוגיה זו התפתחה בשנים האחרונות‪ ,‬והיא ממשיכה להתפתח ולהיות יעילה‬
‫יותר עם התקדמות הגרסאות‪ .‬יכולות רבות נוספו בגרסאות האחרונות של התוכנה‪ ,‬אשר לא היו‬
‫זמינות בעבר‪ ,‬ומומלץ לקורא להתעדכן מפעם לפעם על החידושים בגרסאות האחרונות בתחום‬
‫זה‪.‬‬
‫תהליך יצירת הקוד יכול להיות מאד מורכב וארוך‪ .‬על כן‪ ,‬מומלץ להיעזר במשתמש שכבר עבר‬
‫הליך זה בעבר‪ ,‬או ביועץ‪/‬מהנדס אפליקציה של חברת ‪ MathWorks‬בארץ‪.‬‬
‫יש לציין כי מפעם לפעם נערכים סמינרים חופשיים אשר עוסקים בטכנולוגיית יצירת הקוד מתוך‬
‫‪ MATLAB‬ואופן שילובו ובדיקתו בתהליכי הפיתוח‪ .‬במידה ותחום זה חשוב ויכול לתרום‬
‫לחברתך – מומלץ להגיע‪.‬‬
‫עמוד ‪ 33‬מתוך ‪33‬‬