LCD בעית משאבים...

[yair24]

LCD בעית משאבים...

שלום, אני עובד עם LCD שמחובר ונשלט על ידי מיקרוקונטרולר בעל כמות מוגבלת של זיכרון פלאש. לLCD יש רזולוציה של 256X128 פיקסלים. גם לLCD יש כמות מסוימת של זיכרון בלתי נדיף שבו שמורה טבלת פונטים שגודל כל אות הוא 6X8 פיקסלים. גודל זה הוא גודל קטן מאוד. אני רוצה ליצור פונטים משלי בגודל יותר גדול, למשל 12X16 פיקסלים לכל אות. הבעיה היא שאני אצטרך לשמור כל אות בזיכרון פלאש של המיקרוקונטרולר. וכמו שכבר אמרתי הזיכרון שם מוגבל. יש למישהו רעיון איך לשמור ייצוג לכל אות בצורה הכי מינימלית שרק אפשר? (התכנות הוא בשפת C) יאיר

 

[nahsh]

איך מיוצגים הפונטים?

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

 

[yair24]

היי נחשון...

תראה אני עשיתי משהו כזה:

const int s[9][6]= {0,1,1,1,1,0, 1,1,0,0,1,1, 1,1,0,0,0,0, 1,1,0,0,0,0, 0,1,1,1,1,0, 0,0,0,0,1,1, 0,0,0,0,1,1, 1,1,0,0,1,1, 0,1,1,1,1,0};​

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

 

[nahsh]

שוב. אני לא כ"כ מכיר את ייצוג

הפונטים, אבל אני מניח שזה פשוט bitmap. אם תייצג את הפונט כך:

unsigned char s[]={0x1E, 0x33 .....};​

(שני הביטים העליונים תמיד 0 כבויים). זה לא יהיה פשוט יותר? לא תוכל פשוט להציב את הפונט במקום המתאים, בעזרת פונקציה פשוטה בהרבה?

 

[yair24]

אתה מדבר על מסך טקסט...

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

יאיר

 

[nahsh]

זה לא משנה

bitmap תמיד יהיה קטן יותר מייצוג בתווים. אם כל שורה צריכה להיות לדוגמא בת 13 פיקסלים, זה עדיין יותר חסכוני מ13 בתים. שוב, אולי אני פשוט לא מבין משהו יסודי באופן הצגת התוים. ועוד משהו. אם אתה עובד עם 8051, הטיפול שלו בהזזת ביטים הוא מאוד לא יעיל. כדאי לבנות מערך של masks, ולעבוד עם פקודות AND OR XOR.

unsigned char masks[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80}; ... ... כיבוי ביט 4: x &= ~(masks[4]); הדלקת ביט 4: x |= masks[4]; החלפת מצב הביט: x ^= masks[4];​

זה יהיה יותר יעיל, בגלל מבנה המעבד.

 

[yair24]

ברור...

אני לא עובד עם 8051 אלא עם מיקרוקונטרולר של חברת RABBITSEMICONDUCTOR. אני מסכים איתך שביטמפ יהיה יותר חסכוני מאשר בתים זה הרי ברור ששני בתים יהיו יותר חסכוניים מ13 בתים... 3 בתים מ17 ביטים וכו... אבל השאלה היא שונה: בהתחלת השירשור שאלתי על חיסכון בבתים, זה נכון... אבל כרגע זה לא מה שמעניין אותי, אני לא חושב שזה יהיה יותר מהיר אם אני אעבוד בביטים או בבתים כי אני חושב שיש כאן צוואר בקבוק אחר... אני חושב שהכתיבה לזיכרון של הLCD לוקחת יותר מדי זמן (או שאולי זה הדלקת ביט ביט היא זאת שיוצרת כאן את צוואר הבקבוק) אני חייב למצוא לזה פתרון... וכמו שאמרתי עשיתי דבל באפר כלומר שני OFFSETS לשני מקומות בזיכרון של המסך: בOFFSET הראשון כתבתי משפט כזה:

SSSS SSSSSSS SSSS SSSSSSSSSS SSSSSS​

ובחלק השני כתבתי משפט כזה:

PPPPP PPPPPPPP PPPP PPPPPPPPPP​

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

 

[yair24]

ובנוסף אני לא יודע איך להמשיך מכאן.

 

[nahsh]

בטח שזה משנה.

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

 

[gilad_no]

אז תיקח 2 בתים

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

 

[ihovav]

אני לא יודע אם זה יעבוד ויהיה יעיל

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

 

[yair24]

תן דוגמא לDEFINE אחד...