עזרה בקטע קוד C++

OdedDvir

הקטע הבא אמור לעבוד בארדואינו:

while(http.connected() && (len > 0 || len == -1)) {
// get available data size
    size_t size = stream->available();
    if(size) {
        // read up to 128 byte
        int c = stream->readBytes(buff, ((size > sizeof(buff)) ? sizeof(buff) : size));

        // write it to Serial
        USE_SERIAL.write(buff, c);

        // insert into string and send it to other function
        String segment = String((char *)buff);
        doSomething(segment);

        // decrease length
        if(len > 0) {
            len -= c;
        }
    }
    delay(1);
}

...

void doSomething(String segment) {
    // do your thing
}

איש ימיני

@yossiz כתב בעזרה בקטע קוד C++:

@איש-ימיני
היה כדאי שהיית מציין שמדובר בארדואינו ולא ++C רגיל

אני לא מכיר ++C ולכן לא חשבתי שזה שונה.

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

או להקצות מראש buffer בגודל של התשובה, ובכל איטרציה של הלולאה להעתיק לשם את המידע שמתקבל (אבל כדי ליישם את זה תצטרך לדעת מראש את גודל התשובה)

או להשתמש ב-buffer בגודל דינאמי (לא יודע אם יש כזה דבר בקלות בארדואינו)

כפי שכתבתי יש לי חוסר ידע בסיסי ב ++C.
אני אפילו לא יודע מה זה buffer, ואיך עובדים איתו, אני מכיר משתנים ומערכים מ phpו VBA.
הייתי רוצה משהו כזה:

String test = "";
test += Serial.write(buff, c);

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

dovid

@איש-ימיני כתב בעזרה בקטע קוד C++:

אני לא מכיר ++C ולכן לא חשבתי שזה שונה.

זה תשובה משונה.
אם אתה לא מכיר C++ עוד יותר מתבקש שתכתוב מה זה כן ולא מה נראה לך.
אתה לא צריך להתנצל על אי ידע, אבל לעזור לעונים לנחות מהר לעניין.

OdedDvir

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

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

void doSomething(String segment) { 
 result += segment;
}

yossiz

@OdedDvir כתב בעזרה בקטע קוד C++:

הקטע הבא אמור לעבוד בארדואינו:

נראה לי ש-segment.getBytes עושה הפוך ממה שהתכוונת,
https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/getbytes

איש ימיני

@OdedDvir כתב בעזרה בקטע קוד C++:

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

לגבי היישום, תבדוק את הקטע האחרון שצירפתי. בפונקציה doSomething אתה יכול ליישם איזו לוגיקה שאתה רוצה.
למשל, בהנחה שיש לך משתנה מחרוזת גלובלי בשם result, אתה יכול להוסיף את המקטע למחרוזת:
void doSomething(String segment) { 
 result += segment;
}

ניסיתי.
result נשאר ריק.

OdedDvir

@איש-ימיני זה בגלל שהיתה לי טעות בקוד, כמו שציין @yossiz. תיקנתי במקור והפכתי את ההשמה ל:

// insert into string and send it to other function
String segment = String((char *)buff);

ובעצם אפשר ישר כך:

doSomething(String((char *)buff));

yossiz

אני רואה בפורומים של ארדואינו שממליצים לא להשתמש ב-String

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

OdedDvir

@yossiz לכאורה אפשר לוותר על זה לגמרי, אבל אז צריך לשלוח גם את הגודל של המערך (כי אין null char בסוף)

// cast into char array and send it to other function
   doSomething((char *)buff, c);

...
void doSomething(char * segment, int size) {
 // do your thing
}

yossiz

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

@איש-ימיני אם במקרה, ידוע מראש שהתשובה לא יארוך יותר מ-X תווים, או שלא תצטרך יותר מ-X תווים מהתשובה, זה יפשט בהרבה את הפתרון

yossiz

@OdedDvir כתב בעזרה בקטע קוד C++:

@איש-ימיני זה בגלל שהיתה לי טעות בקוד, כמו שציין @yossiz. תיקנתי במקור והפכתי את ההשמה ל:
// insert into string and send it to other function
String segment = String((char *)buff);
ובעצם אפשר ישר כך:
doSomething(String((char *)buff));

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

איש ימיני

@OdedDvir כתב בעזרה בקטע קוד C++:

@yossiz לכאורה אפשר לוותר על זה לגמרי, אבל אז צריך לשלוח גם את הגודל של המערך (כי אין null char בסוף)
// cast into char array and send it to other function
   doSomething((char *)buff, c);

...
void doSomething(char * segment, int size) {
 // do your thing
}

הפתרון הזה עובד טוב מאוד.
עזרת לי מאוד.
תודה רבה.

OdedDvir

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

yossiz

@OdedDvir כתב בעזרה בקטע קוד C++:

מעכשיו אני אשתדל לשבת בשקט

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

@איש-ימיני חשוב להבין ששפת ++C לא דומה כלל ל-php או vba

יש ב-++C הרבה הזדמנויות לעשות טעויות קטנות שלא תשים לב עליהם ואף אחד לא יתריע לך עד שפתאום משהו (שנראה) לא קשור לגמרי יתפוצץ לך בפנים ולא תבין מאיפה זה בא לך

כל זה תוצאה של חסרון "אבטחת זכרון" (memory safety) של השפה

איש ימיני

@OdedDvir
הקוד עובד די טוב, אבל יש קטע מוזר שהמקטע האחרון חוזר על עצמו.
זה הקוד הסופי כרגע:

while(http.connected() && (len > 0 || len == -1)) {
// get available data size
    size_t size = stream->available();
    if(size) {
        // read up to 128 byte
        int c = stream->readBytes(buff, ((size > sizeof(buff)) ? sizeof(buff) : size));
 
        // write it to Serial
        Serial.write(buff, c);
        doSomething((char *)buff, c);

        // decrease length
        if(len > 0) {
            len -= c;
        }
    }
    delay(1);
}

void doSomething(char * segment, int size) {
    result += segment;
}
Serial.println(result);

בעת שאני מדפיס את התוצאה

Serial.println(result);

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

OdedDvir

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

    result += segment;

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

if (size < 128)
   segment[size] = '\0';
result += segment;

למעשה זה קצת מטריד אותי שזה עבד בלי לקרוס, כי לא ברור לי מניין ידוע גודל המערך segment להיות 128, בכל האיטרציות הקודמות. הקוד הזה לא מניח את דעתי לגמרי. הפתרון הכי טוב זה להעתיק תמיד size תוים.
ובלאו הכי, נראה לי שהפעולה += מבצעת המרה לא מפורשת לאובייקט String. הכי טוב להגדיר מראש את הגודל המקסימלי של result, ולהשתמש בהעתקה ישירה ע"י memcpy.

// Globals
define MAX_LEN 1000
char result[MAX_LEN+1];  // save space for trailing null char
int resultSize = 0;

...
void doSomething(char * segment, int size) {
   int charsToCopy;
   charsToCopy = resultSize+size > MAX_LEN ? MAX_LEN-resultSize : size;
   if (charsToCopy > 0) {
      memcpy(result[resultSize], segment, charsToCopy);
      resultSize += charsToCopy;
      result[resultSize] = '\0'; // add trailing null char
   }
}

ככה זה יותר בטוח

תחומים - פורום חרדי מקצועי

עזרה בקטע קוד C++