דילוג לתוכן
  • חוקי הפורום
  • פופולרי
  • לא נפתר
  • משתמשים
  • חיפוש גוגל בפורום
  • צור קשר
עיצובים
  • Light
  • Brite
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • ברירת מחדל (ללא עיצוב (ברירת מחדל))
  • ללא עיצוב (ברירת מחדל)
כיווץ
מתמחים טופ
  1. דף הבית
  2. מחשבים וטכנולוגיה
  3. עזרה הדדית - מחשבים וטכנולוגיה
  4. המלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא

המלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא

מתוזמן נעוץ נעול הועבר עזרה הדדית - מחשבים וטכנולוגיה
162 פוסטים 49 כותבים 3.8k צפיות 48 עוקבים
  • מהישן לחדש
  • מהחדש לישן
  • הכי הרבה הצבעות
תגובה
  • תגובה כנושא
התחברו כדי לפרסם תגובה
נושא זה נמחק. רק משתמשים עם הרשאות מתאימות יוכלו לצפות בו.
  • Y yb linux

    @cfopuser התכונתי שהרי המידע במחשב נשמר בקוד בינרי (0101 או טרו ופולס) שיכול להיתפרש גם כמיספרים (אינטג׳ר/שלם או פלוט/עשרוני וכדומה) ואולי אפשר לשמור את הקובץ עם קיצורי דרך שהחשב יפענח לבד על ידי הכפלות

    cfopuserC מנותק
    cfopuserC מנותק
    cfopuser
    כתב נערך לאחרונה על ידי cfopuser
    #113

    @yb-linux עדיין אתה לא ממש מובן.

    בכול אופן כיווץ פועל בדרכים מאוד חכמות כיום,
    (פעם זה היה על ידי זיהוי כפילויות וכתיבה במקום aaaa היו כותבים a4 לדוג')

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

    תוכנות נפוצות הן 7zip וrar למרות שכולם היום משולבות בחלקן לתוך ווינדוס.

    אם אני חושב שאני מבין מה אתה מתכוון שבמקום לכתוב 100 נכתוב 2 * 50
    אני עדיין לא חושב שאתה מובן כי אנחנו צריכים לשמור בזיכרון את המספר 50 ואת המספר 2 והנה הגענו לקובץ גדול ממה שהתחלנו

    Y תגובה 1 תגובה אחרונה
    2
    • cfopuserC cfopuser

      @yb-linux עדיין אתה לא ממש מובן.

      בכול אופן כיווץ פועל בדרכים מאוד חכמות כיום,
      (פעם זה היה על ידי זיהוי כפילויות וכתיבה במקום aaaa היו כותבים a4 לדוג')

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

      תוכנות נפוצות הן 7zip וrar למרות שכולם היום משולבות בחלקן לתוך ווינדוס.

      אם אני חושב שאני מבין מה אתה מתכוון שבמקום לכתוב 100 נכתוב 2 * 50
      אני עדיין לא חושב שאתה מובן כי אנחנו צריכים לשמור בזיכרון את המספר 50 ואת המספר 2 והנה הגענו לקובץ גדול ממה שהתחלנו

      Y מנותק
      Y מנותק
      yb linux
      כתב נערך לאחרונה על ידי
      #114

      @cfopuser אם למשל התוכנה תמיד תחפיל הכול ביחד פי 100 למשל אז אולי הקובץ ישקול קצת יותר ממאית או שבתחילת הקובץ תהיה כותרת בכמה צריך להכפיל הכל בייחד (בתנאי שזה לא יהיה מספר עשרוני בן הרבה ספרות)

      cfopuserC תגובה 1 תגובה אחרונה
      0
      • Y yb linux

        @cfopuser אם למשל התוכנה תמיד תחפיל הכול ביחד פי 100 למשל אז אולי הקובץ ישקול קצת יותר ממאית או שבתחילת הקובץ תהיה כותרת בכמה צריך להכפיל הכל בייחד (בתנאי שזה לא יהיה מספר עשרוני בן הרבה ספרות)

        cfopuserC מנותק
        cfopuserC מנותק
        cfopuser
        כתב נערך לאחרונה על ידי
        #115

        @yb-linux זיכרון של מחשבים לא עובד ככה.
        זיכרון של מחשב שומר כול מספר שהוא באותו קבוצה של בייטים כך שהמספר 256 והמספר 8 לוקחים בדיוק את אותו מקום,
        בגלל ששיטת הספירה הבינארית עובדת בחזקות של שתים ככה שלא משנה איזה מספר את מיצג זה יקח את אותו מקום.

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

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

        מתכנת חובבמ תגובה 1 תגובה אחרונה
        1
        • ה מנותק
          ה מנותק
          החפץ בעילום שם 0
          כתב נערך לאחרונה על ידי
          #116

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

          שלום לכולם, רציתי להציע כיוון שיפתור את בעיית האיטיות שכולם מדברים עליה כאן. כרגע, שליחת קובץ מעוצב (כמו PDF או Word) לוקחת דקות ארוכות כי הקבצים האלו "כבדים".

          הפתרון הוא לעבור לשיטה שבה אנחנו לא שולחים את "הקובץ", אלא שולחים "הוראות בנייה" (קוד HTML).

          איך זה יעבוד בפועל?

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

          השידור: התוכנה המצוינת של @כבוד-הרב תשדר את הקוד הזה בשיחה הקולית. בגלל שהקוד קצר, השידור יסתיים תוך 30 עד 60 שניות בלבד!

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

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

          מה דעתכם? האם מישהו מרים את הכפפה להוסיף לתוכנה הקיימת מודול של "HTML To Acoustic Code" שיהפוך את זה לאוטומטי?

          מתכנת חובבמ תגובה 1 תגובה אחרונה
          0
          • cfopuserC cfopuser

            @yb-linux זיכרון של מחשבים לא עובד ככה.
            זיכרון של מחשב שומר כול מספר שהוא באותו קבוצה של בייטים כך שהמספר 256 והמספר 8 לוקחים בדיוק את אותו מקום,
            בגלל ששיטת הספירה הבינארית עובדת בחזקות של שתים ככה שלא משנה איזה מספר את מיצג זה יקח את אותו מקום.

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

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

            מתכנת חובבמ מנותק
            מתכנת חובבמ מנותק
            מתכנת חובב
            מדריכים
            כתב נערך לאחרונה על ידי
            #117

            @cfopuser כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

            שהמספר 256

            *255

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

            צריך עזרה בשחזור מידע? ייעוץ? egozkokus1@gmail.com

            תגובה 1 תגובה אחרונה
            0
            • ה החפץ בעילום שם 0

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

              שלום לכולם, רציתי להציע כיוון שיפתור את בעיית האיטיות שכולם מדברים עליה כאן. כרגע, שליחת קובץ מעוצב (כמו PDF או Word) לוקחת דקות ארוכות כי הקבצים האלו "כבדים".

              הפתרון הוא לעבור לשיטה שבה אנחנו לא שולחים את "הקובץ", אלא שולחים "הוראות בנייה" (קוד HTML).

              איך זה יעבוד בפועל?

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

              השידור: התוכנה המצוינת של @כבוד-הרב תשדר את הקוד הזה בשיחה הקולית. בגלל שהקוד קצר, השידור יסתיים תוך 30 עד 60 שניות בלבד!

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

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

              מה דעתכם? האם מישהו מרים את הכפפה להוסיף לתוכנה הקיימת מודול של "HTML To Acoustic Code" שיהפוך את זה לאוטומטי?

              מתכנת חובבמ מנותק
              מתכנת חובבמ מנותק
              מתכנת חובב
              מדריכים
              כתב נערך לאחרונה על ידי
              #118

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

              צריך עזרה בשחזור מידע? ייעוץ? egozkokus1@gmail.com

              ה תגובה 1 תגובה אחרונה
              2
              • מתכנת חובבמ מתכנת חובב

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

                ה מנותק
                ה מנותק
                החפץ בעילום שם 0
                כתב נערך לאחרונה על ידי
                #119

                @מתכנת-חובב צודק...
                אבל לטעת ג'מיני אפשר להוסיף (למתכנתים בלבד...) כפתור שלפני השליחה זה ייהפך לHTML
                אני לא מבין בזה כ"כ אז אולי זה רעיון יצירתי

                cfopuserC תגובה 1 תגובה אחרונה
                0
                • ה החפץ בעילום שם 0

                  @מתכנת-חובב צודק...
                  אבל לטעת ג'מיני אפשר להוסיף (למתכנתים בלבד...) כפתור שלפני השליחה זה ייהפך לHTML
                  אני לא מבין בזה כ"כ אז אולי זה רעיון יצירתי

                  cfopuserC מנותק
                  cfopuserC מנותק
                  cfopuser
                  כתב נערך לאחרונה על ידי
                  #120

                  @החפץ-בעילום-שם-0 זה לא רעיון טוב קבצי וורד מודרנים הם גם ככה קבצי xml ככה שלא הרווחנו כלום.

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

                  מתכנת חובבמ תגובה 1 תגובה אחרונה
                  1
                  • cfopuserC cfopuser

                    @החפץ-בעילום-שם-0 זה לא רעיון טוב קבצי וורד מודרנים הם גם ככה קבצי xml ככה שלא הרווחנו כלום.

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

                    מתכנת חובבמ מנותק
                    מתכנת חובבמ מנותק
                    מתכנת חובב
                    מדריכים
                    כתב נערך לאחרונה על ידי
                    #121

                    @cfopuser הוא דיבר על pdf ששם זה אולי הגיוני אבל רק בעיצובים גנריים
                    בכל אופן הבעיה היא כרגע איך מעבירים קילובייט בזמן סביר
                    על קבצים שלמים אין על מה לדבר (זה יהיה יעיל יותר בכיוון של הודעות קצרות ולא העברת קבצים מכל סוג שהוא)

                    צריך עזרה בשחזור מידע? ייעוץ? egozkokus1@gmail.com

                    תגובה 1 תגובה אחרונה
                    0
                    • A מנותק
                      A מנותק
                      AMDesign
                      כתב נערך לאחרונה על ידי AMDesign
                      #122

                      לזה קוראים גאונות

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

                      מתכנת חובבמ תגובה 1 תגובה אחרונה
                      3
                      • A AMDesign

                        לזה קוראים גאונות

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

                        מתכנת חובבמ מנותק
                        מתכנת חובבמ מנותק
                        מתכנת חובב
                        מדריכים
                        כתב נערך לאחרונה על ידי
                        #123

                        @AMDesign כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

                        לזה קוראים גאונות

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

                        צריך עזרה בשחזור מידע? ייעוץ? egozkokus1@gmail.com

                        צבי דורש ציוןצ תגובה 1 תגובה אחרונה
                        2
                        • כ כבוד הרב

                          שלום לכולם!

                          אני רוצה לשתף אתכם בפרויקט מחקר ופיתוח שעבדתי עליו בתקופה האחרונה (הקוד נבנה ע"י gemini-3-pro-preview), שמוכיח שהבלתי אפשרי - אפשרי.
                          הצלחתי לפתח מודם אקוסטי (Data-over-Sound) שמאפשר להעביר קבצים (טקסט, תמונות, מסמכים) לתוך מחשב מנותק רשת (Offline/Air-Gapped) באמצעות שיחה קולית פשוטה מטלפון כשר! (דרך מערכת טלפונית בימות המשיח וכד')

                          זה נשמע כמו מדע בדיוני או חזרה לשנות ה-80, אבל עם האלגוריתמים הנכונים, זה עובד בצורה מדהימה ב-2026.

                          💡 למה זה טוב?

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

                          🛠️ מה יש מתחת למכסה המנוע? ("פרוטוקול טיטניום")

                          כדי להתגבר על האיכות הגרועה של קווי הטלפון (דחיסת GSM/G.729) ורעשי הרקע, בניתי פרוטוקול שידור סופר-קשוח שכולל:

                          1. Triple Voting (הצבעת רוב): כל בייט נשלח 3 פעמים. אם רעש הורס אחד מהם, המחשב לוקח את הרוב הקובע.
                          2. Reed-Solomon ECC: תיקון שגיאות מתמטי (כמו ב-QR Code) שמשחזר מידע שנמחק.
                          3. Interleaving (ערבוב): פיזור הביטים כך שקטיעה רגעית בקו לא תמחק אות שלמה, אלא רק "שריטות" קטנות שקל לתקן.
                          4. CRC32: בדיקת תקינות סופית - אם הקובץ לא שוחזר ב-100% דיוק, המערכת תודיע.

                          🎯 המטרה שלי בפרסום

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

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

                          שימו לב זו גרסה ראשונית לצורך ניסוים בלבד! מומלץ לנסות בהתחלה להמיר קובץ טקסט בעל מילים בודדות בלבד!

                          📢 הוראות שימוש (חובה לקרוא!)

                          הפיזיקה של הסאונד היא עדינה. כדי שזה יעבוד "אחד לאחד", הקפידו על הכללים הבאים:

                          1. ווליום (הכי חשוב!):

                            • אין להגביר את הטלפון למקסימום! זה יוצר עיוות (Distortion) שהורס את האות הדיגיטלי.
                            • יש לכוון לעוצמה של כ-60%-70%.
                            • בתוכנה יש "מד עוצמה" – כוונו כך שהפס יהיה ירוק. אם הוא אדום, זה לא יעבוד.
                          2. חיבור AUX (מומלץ):

                            • הדרך הכי נקייה היא לחבר כבל AUX בין הטלפון לכניסת המיקרופון (Line-In) במחשב.
                            • שים לב: במחשבים ניידים עם שקע בודד (Combo Jack), כבל AUX רגיל לא יעבוד כמיקרופון! צריך כרטיס קול USB פשוט (עולה כמה שקלים) או מפצל ייעודי.
                          3. שימוש ברמקול (אקוסטי):

                            • אפשרי בהחלט!
                            • יש להיות בחדר שקט יחסית.
                            • יש להצמיד את רמקול הטלפון למיקרופון של המחשב.

                          💻 המדריך הטכני למפתח

                          כדי להריץ את זה, תצטרכו Python מותקן על המחשב.

                          1. התקנת הספריות הדרושות:
                          פתחו CMD והריצו:

                          pip install numpy scipy sounddevice soundfile reedsolo pyinstaller
                          

                          2. הקוד המלא:
                          העתיקו את הקוד הבא ושמרו אותו בקובץ בשם main.py. הקוד כולל ממשק גרפי (GUI), מקודד (Encoder) ומפענח (Decoder).

                          import sys
                          import os
                          import struct
                          import threading
                          import base64
                          import time
                          import queue
                          import zlib
                          import datetime
                          import numpy as np
                          import sounddevice as sd
                          import soundfile as sf
                          from scipy.io import wavfile
                          from scipy import signal as sig
                          from reedsolo import RSCodec, ReedSolomonError
                          import tkinter as tk
                          from tkinter import filedialog, messagebox, ttk
                          
                          # === הגדרות מודם: "Titanium Edition" ===
                          SAMPLE_RATE = 8000
                          BAUD_RATE = 40        # מהירות יציבה
                          FREQ_MARK = 900       # תדרים אופטימליים לקו טלפון
                          FREQ_SPACE = 1700
                          RS_ECC_SYMBOLS = 20   # תיקון שגיאות בסיסי (השילוש עושה את רוב העבודה)
                          INTERLEAVE_STEP = 40  # פיזור רחב מאוד
                          
                          # סנכרון
                          SYNC_DURATION = 0.8
                          t_sync = np.arange(int(SAMPLE_RATE * SYNC_DURATION)) / SAMPLE_RATE
                          SYNC_SIGNAL = sig.chirp(t_sync, f0=FREQ_MARK, f1=FREQ_SPACE, t1=SYNC_DURATION, method='linear')
                          
                          # Magic Byte
                          MAGIC_BITS = "01000010" # 'B'
                          
                          TEXT_EXTENSIONS = ['.txt', '.csv', '.json', '.xml', '.html', '.php', '.py', '.js', '.ini', '.log']
                          
                          # === לוגים ===
                          def write_log(msg):
                              ts = datetime.datetime.now().strftime("%H:%M:%S")
                              print(f"[{ts}] {msg}")
                              try:
                                  with open("LOG_TITANIUM.txt", "a", encoding="utf-8") as f: f.write(f"[{ts}] {msg}\n")
                              except: pass
                          
                          # === לוגיקה מתמטית ===
                          def interleave_bits(bits):
                              n = len(bits)
                              padding = (INTERLEAVE_STEP - (n % INTERLEAVE_STEP)) % INTERLEAVE_STEP
                              bits_padded = bits + [0] * padding
                              interleaved = [0] * len(bits_padded)
                              rows = len(bits_padded) // INTERLEAVE_STEP
                              for i in range(len(bits_padded)):
                                  row = i // INTERLEAVE_STEP
                                  col = i % INTERLEAVE_STEP
                                  new_idx = col * rows + row
                                  interleaved[new_idx] = bits_padded[i]
                              return interleaved, padding
                          
                          def deinterleave_bits(bits, padding):
                              n = len(bits)
                              rows = n // INTERLEAVE_STEP
                              if rows == 0: return bits
                              deinterleaved = [0] * n
                              for i in range(n):
                                  col = i // rows
                                  row = i % rows
                                  original_idx = row * INTERLEAVE_STEP + col
                                  if original_idx < n:
                                      deinterleaved[original_idx] = bits[i]
                              if padding > 0: return deinterleaved[:-padding]
                              return deinterleaved
                          
                          def text_to_bits(data_bytes):
                              bits = []
                              for byte in data_bytes:
                                  for i in range(7, -1, -1): bits.append((byte >> i) & 1)
                              return bits
                          
                          def bits_to_bytes(bits):
                              chars = []
                              for b in range(0, len(bits), 8):
                                  byte = bits[b:b+8]
                                  if len(byte) < 8: break
                                  chars.append(int(''.join(map(str, byte)), 2))
                              return bytes(chars)
                          
                          def vote_byte(b1, b2, b3):
                              if b1 == b2 or b1 == b3: return b1
                              if b2 == b3: return b2
                              return b1 # ברירת מחדל
                          
                          # === Encoder ===
                          def generate_signal(filename, file_content, output_wav):
                              try:
                                  write_log(f"מקודד: {filename}")
                                  ext = os.path.splitext(filename)[1].lower()
                                  is_text = ext in TEXT_EXTENSIONS
                                  fname_bytes = os.path.basename(filename).encode('utf-8')
                                  
                                  if is_text:
                                      content_bytes = file_content
                                      type_flag = 1 
                                  else:
                                      content_bytes = base64.b64encode(file_content)
                                      type_flag = 0 
                                      
                                  if len(fname_bytes) > 200: fname_bytes = fname_bytes[:200]
                                  
                                  # 1. אריזה + CRC
                                  crc = zlib.crc32(content_bytes) & 0xffffffff
                                  packet = struct.pack('B', len(fname_bytes)) + fname_bytes + struct.pack('B', type_flag) + content_bytes + struct.pack('>I', crc)
                                  
                                  # 2. קידוד RS
                                  rsc = RSCodec(RS_ECC_SYMBOLS)
                                  encoded_data = rsc.encode(packet)
                                  
                                  # 3. שילוש הנתונים (Triple Redundancy) על הכל!
                                  # זה השדרוג הגדול. כל בייט הופך ל-3.
                                  tripled_data = bytearray()
                                  for b in encoded_data:
                                      tripled_data.extend([b, b, b])
                                      
                                  # 4. המרה לביטים
                                  raw_bits = text_to_bits(tripled_data)
                                  
                                  # 5. ערבוב (Interleaving)
                                  # זה מפזר את השילוש, כך שרעש לא ימחק את כל ה-3 עותקים
                                  shuffled_bits, padding = interleave_bits(raw_bits)
                                  
                                  # 6. כותרת: [Magic] [Length] [Padding]
                                  magic_bits = text_to_bits(bytes([0x42])) # 'B'
                                  
                                  # האורך הוא של הביטים המעורבבים
                                  header_info = struct.pack('>IB', len(shuffled_bits), padding)
                                  header_bits = text_to_bits(header_info)
                                  header_bits_tripled = header_bits * 3 
                                  
                                  final_stream_bits = magic_bits + header_bits_tripled + shuffled_bits
                                  
                                  # 7. יצירת אודיו
                                  samples_per_bit = int(SAMPLE_RATE / BAUD_RATE)
                                  t_wake = np.arange(int(SAMPLE_RATE * 3.0)) / SAMPLE_RATE
                                  wake = np.sin(2 * np.pi * FREQ_SPACE * t_wake)
                                  
                                  t_bit = np.arange(samples_per_bit) / SAMPLE_RATE
                                  phase = 0
                                  waves = []
                                  
                                  for bit in final_stream_bits:
                                      freq = FREQ_MARK if bit == 1 else FREQ_SPACE
                                      w = np.sin(2 * np.pi * freq * t_bit + phase)
                                      waves.append(w)
                                      phase += 2 * np.pi * freq * (samples_per_bit / SAMPLE_RATE)
                                      phase %= 2 * np.pi
                                      
                                  final_audio = np.concatenate([wake, SYNC_SIGNAL, np.concatenate(waves)])
                                  final_audio = sig.lfilter([1.0, -0.8], [1.0], final_audio)
                                  m = np.max(np.abs(final_audio))
                                  final_audio = (final_audio / m * 32767).astype(np.int16)
                                  
                                  wavfile.write(output_wav, SAMPLE_RATE, final_audio)
                                  return True, "קובץ טיטניום נוצר! (Triple Payload)"
                                  
                              except Exception as e: return False, str(e)
                          
                          # === Decoder ===
                          def decode_signal(input_wav, output_folder):
                              try:
                                  with open("LOG_TITANIUM.txt", "w", encoding="utf-8") as f: f.write("=== LOG START ===\n")
                                  
                                  rate, data = wavfile.read(input_wav)
                                  if len(data.shape) > 1: data = data[:, 0]
                                  
                                  sos = sig.butter(6, [600, 2000], btype='bandpass', fs=SAMPLE_RATE, output='sos')
                                  clean = sig.sosfilt(sos, data.astype(float))
                                  
                                  mx = np.max(np.abs(clean))
                                  if mx < 0.01: return False, "שקט מדי"
                                  clean /= mx
                                  
                                  # 1. סנכרון
                                  corr = sig.correlate(clean, SYNC_SIGNAL, mode='valid')
                                  peak = np.argmax(np.abs(corr))
                                  if np.abs(corr[peak]) < 3: return False, "לא נמצא אות סנכרון"
                                  
                                  approx_start = peak + len(SYNC_SIGNAL)
                                  relevant = clean[approx_start:]
                                  spb = int(SAMPLE_RATE / BAUD_RATE)
                                  num_bits = len(relevant) // spb
                                  
                                  t = np.arange(spb) / SAMPLE_RATE
                                  ref_m = np.exp(-2j * np.pi * FREQ_MARK * t)
                                  ref_s = np.exp(-2j * np.pi * FREQ_SPACE * t)
                                  
                                  bits_str = ""
                                  for i in range(num_bits):
                                      chunk = relevant[i*spb : (i+1)*spb]
                                      pm = np.abs(np.dot(chunk, ref_m))**2
                                      ps = np.abs(np.dot(chunk, ref_s))**2
                                      bits_str += "1" if pm > ps else "0"
                                      
                                  # 2. Magic Byte
                                  magic_idx = bits_str.find(MAGIC_BITS)
                                  if magic_idx == -1:
                                      inv = bits_str.replace('0','x').replace('1','0').replace('x','1')
                                      magic_idx = inv.find(MAGIC_BITS)
                                      if magic_idx != -1:
                                          bits_str = inv
                                          write_log("היפוך פאזה זוהה")
                                      else: return False, "Magic Byte לא נמצא"
                                  
                                  data_start = magic_idx + 8
                                  
                                  # 3. Header Voting
                                  if len(bits_str) < data_start + 120: return False, "קצר מדי"
                                  
                                  h_part = bits_str[data_start : data_start + 120]
                                  h_chunks = [h_part[0:40], h_part[40:80], h_part[80:120]]
                                  
                                  if h_chunks[0] == h_chunks[1] or h_chunks[0] == h_chunks[2]: final_h = h_chunks[0]
                                  elif h_chunks[1] == h_chunks[2]: final_h = h_chunks[1]
                                  else: final_h = h_chunks[0]
                                  
                                  try:
                                      h_bytes = bits_to_bytes([int(x) for x in final_h])
                                      data_len, padding = struct.unpack('>IB', h_bytes)
                                      write_log(f"אורך מעורבב: {data_len}, ריפוד: {padding}")
                                  except: return False, "שגיאת כותרת"
                                  
                                  if data_len > 10000000 or data_len == 0: return False, f"אורך לא הגיוני {data_len}"
                                  
                                  # 4. חילוץ וסידור מחדש (De-Interleave)
                                  payload_idx = data_start + 120
                                  if len(bits_str) < payload_idx + data_len:
                                      bits_str = bits_str.ljust(payload_idx + data_len, '0')
                                      
                                  shuffled = [int(b) for b in bits_str[payload_idx : payload_idx + data_len]]
                                  raw_bits = deinterleave_bits(shuffled, padding)
                                  raw_bytes = bits_to_bytes(raw_bits)
                                  
                                  # 5. הצבעת רוב על התוכן (Payload Voting) - החלק החדש!
                                  # יש לנו כעת רצף בייטים שכל אחד מהם חוזר 3 פעמים
                                  # [A, A, A, B, B, B, ...]
                                  
                                  reconstructed_payload = bytearray()
                                  fixed_count = 0
                                  
                                  for i in range(0, len(raw_bytes), 3):
                                      chunk = raw_bytes[i : i+3]
                                      if len(chunk) < 3: break
                                      
                                      b1, b2, b3 = chunk[0], chunk[1], chunk[2]
                                      
                                      if b1 == b2 and b2 == b3:
                                          # הסכמה מלאה
                                          res = b1
                                      else:
                                          # נדרש תיקון
                                          res = vote_byte(b1, b2, b3)
                                          fixed_count += 1
                                          
                                      reconstructed_payload.append(res)
                                      
                                  write_log(f"תוקנו באמצעות Voting: {fixed_count} בייטים")
                                  
                                  # 6. RS Decode (שכבה שנייה)
                                  try:
                                      rsc = RSCodec(RS_ECC_SYMBOLS)
                                      decoded_packet = rsc.decode(bytes(reconstructed_payload))[0]
                                      
                                      # 7. פירוק
                                      ptr = 0
                                      name_len = decoded_packet[ptr]; ptr+=1
                                      filename = decoded_packet[ptr:ptr+name_len].decode('utf-8', errors='ignore'); ptr+=name_len
                                      file_type = decoded_packet[ptr]; ptr+=1
                                      content = decoded_packet[ptr:-4]
                                      rec_crc = struct.unpack('>I', decoded_packet[-4:])[0]
                                      
                                      calc_crc = zlib.crc32(content) & 0xffffffff
                                      if calc_crc != rec_crc:
                                          write_log(f"CRC שגוי: {rec_crc} != {calc_crc}")
                                          # אם ה-RS עבר, אולי נשמור בכל זאת עם אזהרה?
                                          # לא, נחמיר
                                          return False, "שגיאת CRC (תוכן לא תואם)"
                                          
                                      final_data = content
                                      if file_type == 0: 
                                          try: final_data = base64.b64decode(content)
                                          except: pass
                                          
                                      path = os.path.join(output_folder, filename)
                                      with open(path, 'wb') as f: f.write(final_data)
                                      
                                      return True, f"הצלחה! {filename}"
                                      
                                  except ReedSolomonError:
                                      write_log("RS נכשל")
                                      return False, "תיקון שגיאות סופי נכשל"
                                      
                              except Exception as e: return False, str(e)
                          
                          # === GUI ===
                          class ModemApp:
                              def __init__(self, root):
                                  self.root = root
                                  self.root.title("Acoustic Modem - TITANIUM EDITION")
                                  self.root.geometry("600x700")
                                  self.audio_buffer = [] 
                                  self.is_rec = False
                                  
                                  tabs = ttk.Notebook(root)
                                  t1 = ttk.Frame(tabs); tabs.add(t1, text="Encode")
                                  t2 = ttk.Frame(tabs); tabs.add(t2, text="Decode")
                                  tabs.pack(fill="both", expand=True)
                                  
                                  tk.Button(t1, text="צור קובץ (Titanium - Full Triple)", command=self.do_enc, bg="#007bff", fg="white", font=("Arial", 14)).pack(pady=50)
                                  self.lbl_enc = tk.Label(t1, text="", fg="green")
                                  self.lbl_enc.pack()
                                  
                                  self.canvas_vol = tk.Canvas(t2, width=400, height=30, bg="black")
                                  self.canvas_vol.pack(pady=10)
                                  self.vol_bar = self.canvas_vol.create_rectangle(0,0,0,30, fill="green")
                                  
                                  self.dev_combo = ttk.Combobox(t2, values=self.get_devs(), width=50)
                                  if self.get_devs(): self.dev_combo.current(0)
                                  self.dev_combo.pack(pady=10)
                                  
                                  self.btn_rec = tk.Button(t2, text="🔴 התחל הקלטה", command=self.toggle_rec, bg="#dc3545", fg="white", font=("Arial", 14))
                                  self.btn_rec.pack(pady=20)
                                  
                                  self.lbl_status = tk.Label(t2, text="מוכן", font=("Arial", 14, "bold"))
                                  self.lbl_status.pack()
                                  
                                  tk.Button(t2, text="טען קובץ WAV", command=self.load_file).pack(pady=20)
                                  tk.Button(t2, text="פתח לוג", command=lambda: os.startfile("LOG_TITANIUM.txt") if os.path.exists("LOG_TITANIUM.txt") else None).pack()
                          
                              def get_devs(self):
                                  try: return [f"{i}: {d['name']}" for i,d in enumerate(sd.query_devices()) if d['max_input_channels']>0]
                                  except: return []
                          
                              def do_enc(self):
                                  fn = filedialog.askopenfilename()
                                  if not fn: return
                                  sn = filedialog.asksaveasfilename(defaultextension=".wav", filetypes=[("WAV","*.wav")])
                                  if not sn: return
                                  try:
                                      with open(fn,'rb') as f: c=f.read()
                                      ok, msg = generate_signal(fn, c, sn)
                                      if ok: messagebox.showinfo("Success", msg)
                                      else: messagebox.showerror("Error", msg)
                                  except Exception as e: messagebox.showerror("Error", str(e))
                          
                              def toggle_rec(self):
                                  if not self.is_rec:
                                      self.is_rec = True
                                      self.btn_rec.config(text="⏹️ סיים ופענח", bg="#333")
                                      self.audio_buffer = []
                                      self.lbl_status.config(text="מקליט...", fg="red")
                                      threading.Thread(target=self.rec_thread).start()
                                  else:
                                      self.is_rec = False
                                      self.btn_rec.config(text="⏳ מעבד...", state="disabled")
                                      self.lbl_status.config(text="מפענח (Voting & RS)...", fg="blue")
                          
                              def update_vol(self, indata):
                                  peak = np.max(np.abs(indata)) / 32768.0
                                  w = min(400, int(peak * 400))
                                  c = "green" if w < 300 else "red"
                                  self.canvas_vol.coords(self.vol_bar, 0, 0, w, 30)
                                  self.canvas_vol.itemconfig(self.vol_bar, fill=c)
                          
                              def rec_thread(self):
                                  idx = int(self.dev_combo.get().split(":")[0]) if self.dev_combo.get() else None
                                  def cb(indata, f, t, s):
                                      if self.is_rec:
                                          self.audio_buffer.append(indata.copy())
                                          try: self.root.after(10, lambda: self.update_vol(indata))
                                          except: pass
                                  try:
                                      with sd.InputStream(device=idx, samplerate=44100, channels=1, dtype='int16', callback=cb):
                                          while self.is_rec: sd.sleep(100)
                                      self.process_audio()
                                  except Exception as e:
                                      self.is_rec = False
                                      messagebox.showerror("Error", str(e))
                                      self.root.after(0, lambda: self.btn_rec.config(text="🔴 התחל הקלטה", bg="#dc3545", state="normal"))
                          
                              def process_audio(self):
                                  if not self.audio_buffer: return
                                  full = np.concatenate(self.audio_buffer, axis=0)
                                  sf.write("DEBUG_INPUT.wav", full, 44100)
                                  num = int(len(full) * SAMPLE_RATE / 44100)
                                  data = sig.resample(full, num).astype(np.int16)
                                  tmp = "temp_dec.wav"
                                  wavfile.write(tmp, SAMPLE_RATE, data)
                                  dl = "Recovered_Files"
                                  if not os.path.exists(dl): os.makedirs(dl)
                                  ok, msg = decode_signal(tmp, dl)
                                  self.root.after(0, lambda: self.finish(ok, msg))
                          
                              def load_file(self):
                                  fn = filedialog.askopenfilename()
                                  if not fn: return
                                  self.lbl_status.config(text="מעבד...", fg="blue")
                                  dl = "Recovered_Files"
                                  if not os.path.exists(dl): os.makedirs(dl)
                                  ok, msg = decode_signal(fn, dl)
                                  self.finish(ok, msg)
                          
                              def finish(self, ok, msg):
                                  self.is_rec = False
                                  self.btn_rec.config(text="🔴 התחל הקלטה", bg="#dc3545", state="normal")
                                  self.lbl_status.config(text="הסתיים", fg="black")
                                  if ok: messagebox.showinfo("Success", msg)
                                  else: messagebox.showerror("Failed", msg)
                          
                          if __name__ == "__main__":
                              root = tk.Tk()
                              app = ModemApp(root)
                              root.mainloop()
                          

                          3. יצירת קובץ EXE (קומפילציה):
                          כדי להפוך את זה לתוכנה ניידת ללא צורך בהתקנת פייתון הריצו את הפקודה הבאה בתקיה שבה נמצא הקוד למעלה:

                          pyinstaller --onefile --noconsole --name "AcousticModem" main.py
                          

                          הקובץ המוכן יחכה לכם בתיקייה dist.


                          בהצלחה! 🚀

                          י מנותק
                          י מנותק
                          יונתן 2
                          כתב נערך לאחרונה על ידי
                          #124

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

                          תגובה 1 תגובה אחרונה
                          2
                          • מתכנת חובבמ מתכנת חובב

                            @AMDesign כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

                            לזה קוראים גאונות

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

                            צבי דורש ציוןצ מנותק
                            צבי דורש ציוןצ מנותק
                            צבי דורש ציון
                            כתב נערך לאחרונה על ידי
                            #125

                            @מתכנת-חובב שאלה: למה אי אפשר לבנות פשוט שפה ייחודית, שתדע לתרגם כל תו להברה, אולי אפילו הבהרה+חוזק או מנגינה וכו', ואז יוכלו לכתוב טקסט ארוך במנגינה קצרה? או שבעצם זה הכוונה (או למשהו קצר בהרבה שזה אפילו לא אומר משהו) רק שאני לא הבנתי...

                            מתכנת חובבמ תגובה 1 תגובה אחרונה
                            0
                            • צבי דורש ציוןצ צבי דורש ציון

                              @מתכנת-חובב שאלה: למה אי אפשר לבנות פשוט שפה ייחודית, שתדע לתרגם כל תו להברה, אולי אפילו הבהרה+חוזק או מנגינה וכו', ואז יוכלו לכתוב טקסט ארוך במנגינה קצרה? או שבעצם זה הכוונה (או למשהו קצר בהרבה שזה אפילו לא אומר משהו) רק שאני לא הבנתי...

                              מתכנת חובבמ מנותק
                              מתכנת חובבמ מנותק
                              מתכנת חובב
                              מדריכים
                              כתב נערך לאחרונה על ידי
                              #126

                              @צבי-דורש-ציון זה בדיוק הרעיון
                              הבעיות מתחילות כשצריך לוודא שזה לא יתעוות בהמרה שיהיה מספיק מהיר ושוני מהותי שאפשר להבחין בו בהקלטה (ומלחמות עם המקודד של amr)

                              צריך עזרה בשחזור מידע? ייעוץ? egozkokus1@gmail.com

                              כ תגובה 1 תגובה אחרונה
                              1
                              • עם ישראל חייע מנותק
                                עם ישראל חייע מנותק
                                עם ישראל חיי
                                כתב נערך לאחרונה על ידי
                                #127

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

                                מתרגם אפליקציות

                                תגובה 1 תגובה אחרונה
                                0
                                • מתכנת חובבמ מתכנת חובב

                                  @צבי-דורש-ציון זה בדיוק הרעיון
                                  הבעיות מתחילות כשצריך לוודא שזה לא יתעוות בהמרה שיהיה מספיק מהיר ושוני מהותי שאפשר להבחין בו בהקלטה (ומלחמות עם המקודד של amr)

                                  כ מנותק
                                  כ מנותק
                                  כבוד הרב
                                  כתב נערך לאחרונה על ידי
                                  #128

                                  @מתכנת-חובב ממה שאני בדקתי וניסיתי המודל המהיר ביותר שתפס טוב זה היה BPSK-250 שהוא ממש מהיר משמעותית מכל מה שבדקתי עד עכשיו והוא עבד מעולה כמעט ללא שגיאות, לדעתי זה פשוט צלילים שפחות מסוננים בחברות תקשורת.
                                  יש לציין שעדיין לא הצלחתי לחבר את הטלפון עם כבל אוקס למחשב ושהמחשב יקלוט אותו אני משער שאם הייתי מצליח הייתי יכול אפילו להשתמש ביותר מהירים.
                                  כמו כן יש לציין שזה עבד לי רק כשהיה לי דור 4 ברמה יציבה בדור שלוש זה פשוט לא עבד.
                                  יצרתי גם סקריפט להמרת קובץ לפורמט טוב לתוכנה:
                                  Drag_To_Encode.bat
                                  גוררים על זה קובץ והוא מעתיק אוטמטית את הטקסט להדבקה בתוכנה.
                                  וסקריפט להמרה בחזרה מהתוכנה:
                                  Paste_To_File.bat
                                  פותחים את הסקריפט לוחצים על כל מקש במקלדת ואז נפתח חלון של פנקס רשימות מדביקים בו את התוצאה של ההמרה של הצליל מהתוכנה ואז שומרים וסוגרים את החלון של פנקס רשימות ואז צריך להקליד שם לשמירה (כולל סיומת) והקובץ נשמר.
                                  כמו כן יש פרוטוקול מיוחד לתמונות שהוא עובר שורה שורה ומדפיס אותה וגם אם התפשל שורה אחת השורה הבאה יכולה לצאת טובה קוראים לו WEFAX-IOS288 (כמדומני ש-WEFAX-IOS576 לא עבד טוב עם ימות המשיח) מגעים לממשק של שליחת תמונה ככה: View > Weather Fax Image TX.

                                  מתכנת חובבמ תגובה 1 תגובה אחרונה
                                  1
                                  • כ כבוד הרב

                                    @מתכנת-חובב ממה שאני בדקתי וניסיתי המודל המהיר ביותר שתפס טוב זה היה BPSK-250 שהוא ממש מהיר משמעותית מכל מה שבדקתי עד עכשיו והוא עבד מעולה כמעט ללא שגיאות, לדעתי זה פשוט צלילים שפחות מסוננים בחברות תקשורת.
                                    יש לציין שעדיין לא הצלחתי לחבר את הטלפון עם כבל אוקס למחשב ושהמחשב יקלוט אותו אני משער שאם הייתי מצליח הייתי יכול אפילו להשתמש ביותר מהירים.
                                    כמו כן יש לציין שזה עבד לי רק כשהיה לי דור 4 ברמה יציבה בדור שלוש זה פשוט לא עבד.
                                    יצרתי גם סקריפט להמרת קובץ לפורמט טוב לתוכנה:
                                    Drag_To_Encode.bat
                                    גוררים על זה קובץ והוא מעתיק אוטמטית את הטקסט להדבקה בתוכנה.
                                    וסקריפט להמרה בחזרה מהתוכנה:
                                    Paste_To_File.bat
                                    פותחים את הסקריפט לוחצים על כל מקש במקלדת ואז נפתח חלון של פנקס רשימות מדביקים בו את התוצאה של ההמרה של הצליל מהתוכנה ואז שומרים וסוגרים את החלון של פנקס רשימות ואז צריך להקליד שם לשמירה (כולל סיומת) והקובץ נשמר.
                                    כמו כן יש פרוטוקול מיוחד לתמונות שהוא עובר שורה שורה ומדפיס אותה וגם אם התפשל שורה אחת השורה הבאה יכולה לצאת טובה קוראים לו WEFAX-IOS288 (כמדומני ש-WEFAX-IOS576 לא עבד טוב עם ימות המשיח) מגעים לממשק של שליחת תמונה ככה: View > Weather Fax Image TX.

                                    מתכנת חובבמ מנותק
                                    מתכנת חובבמ מנותק
                                    מתכנת חובב
                                    מדריכים
                                    כתב נערך לאחרונה על ידי
                                    #129

                                    @כבוד-הרב כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

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

                                    זה מודל אפנון פאזה שדי ברור שלא יעבוד בדור 3 וכבר כתבתי את זה למעלה
                                    הסיבה היא הדחיסה של ה vocoder ולא חברות התקשורת
                                    בדור 4 יש רוחב פס הרבה יותר גדול לשיחה ולכן המקודד לא צריך למרוח את הפאזות כדי לחסוך

                                    @כבוד-הרב כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

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

                                    אני בספק כי אתה מתקרב לקצה גודל הפריימים ואתה מקודד רק בתדר אחד ולכן אתה יכול לאפנן רק 2 מצבים בכל פאזה (כנראה) ואם תשתמש באפנון תדר כבל יתן לך קצב הרבה יותר גבוה מאפנון פאזה כי הוא ישדר אות נקי יותר

                                    @כבוד-הרב כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

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

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

                                    @כבוד-הרב כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

                                    כמו כן יש פרוטוקול מיוחד לתמונות שהוא עובר שורה שורה ומדפיס אותה וגם אם התפשל שורה אחת השורה הבאה יכולה לצאת טובה קוראים לו WEFAX-IOS288 (כמדומני ש-WEFAX-IOS576 לא עבד טוב עם ימות המשיח) מגעים לממשק של שליחת תמונה ככה: View > Weather Fax Image TX.

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

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

                                    צריך עזרה בשחזור מידע? ייעוץ? egozkokus1@gmail.com

                                    כ תגובה 1 תגובה אחרונה
                                    2
                                    • מתכנת חובבמ מתכנת חובב

                                      @כבוד-הרב כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

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

                                      זה מודל אפנון פאזה שדי ברור שלא יעבוד בדור 3 וכבר כתבתי את זה למעלה
                                      הסיבה היא הדחיסה של ה vocoder ולא חברות התקשורת
                                      בדור 4 יש רוחב פס הרבה יותר גדול לשיחה ולכן המקודד לא צריך למרוח את הפאזות כדי לחסוך

                                      @כבוד-הרב כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

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

                                      אני בספק כי אתה מתקרב לקצה גודל הפריימים ואתה מקודד רק בתדר אחד ולכן אתה יכול לאפנן רק 2 מצבים בכל פאזה (כנראה) ואם תשתמש באפנון תדר כבל יתן לך קצב הרבה יותר גבוה מאפנון פאזה כי הוא ישדר אות נקי יותר

                                      @כבוד-הרב כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

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

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

                                      @כבוד-הרב כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

                                      כמו כן יש פרוטוקול מיוחד לתמונות שהוא עובר שורה שורה ומדפיס אותה וגם אם התפשל שורה אחת השורה הבאה יכולה לצאת טובה קוראים לו WEFAX-IOS288 (כמדומני ש-WEFAX-IOS576 לא עבד טוב עם ימות המשיח) מגעים לממשק של שליחת תמונה ככה: View > Weather Fax Image TX.

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

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

                                      כ מנותק
                                      כ מנותק
                                      כבוד הרב
                                      כתב נערך לאחרונה על ידי כבוד הרב
                                      #130

                                      @מתכנת-חובב
                                      לגבי המרת Base64 מול בינארי:
                                      אתה צודק ש-Base64 מוסיף תקורה של כ-33% וזה לא יעיל.
                                      פשוט מסיבה פרקטית שאיך שאני משתמש עכשי בתוכנה זה עובד רק עם הדבקה של טקסט ורק ככה אפשר לשלוח קובץ בימארי בטקסט.
                                      לגבי WEFAX:
                                      נכון, זה פרוטוקול עתיק ואיטי. היתרון היחיד שלו הוא שהוא ויזואלי וסלחן לשגיאות. אם יש קטיעה בשידור, אתה מקבל פס שחור קטן בתמונה אבל שאר התמונה ממשיכה להגיע. בהעברת קובץ ZIP, ביט אחד שגוי והקובץ מושחת. למשתמש הפשוט שרוצה להעביר מסמך קריא, לפעמים הויזואליות עדיפה על היעילות.

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

                                      מתכנת חובבמ תגובה 1 תגובה אחרונה
                                      0
                                      • כ כבוד הרב

                                        @מתכנת-חובב
                                        לגבי המרת Base64 מול בינארי:
                                        אתה צודק ש-Base64 מוסיף תקורה של כ-33% וזה לא יעיל.
                                        פשוט מסיבה פרקטית שאיך שאני משתמש עכשי בתוכנה זה עובד רק עם הדבקה של טקסט ורק ככה אפשר לשלוח קובץ בימארי בטקסט.
                                        לגבי WEFAX:
                                        נכון, זה פרוטוקול עתיק ואיטי. היתרון היחיד שלו הוא שהוא ויזואלי וסלחן לשגיאות. אם יש קטיעה בשידור, אתה מקבל פס שחור קטן בתמונה אבל שאר התמונה ממשיכה להגיע. בהעברת קובץ ZIP, ביט אחד שגוי והקובץ מושחת. למשתמש הפשוט שרוצה להעביר מסמך קריא, לפעמים הויזואליות עדיפה על היעילות.

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

                                        מתכנת חובבמ מנותק
                                        מתכנת חובבמ מנותק
                                        מתכנת חובב
                                        מדריכים
                                        כתב נערך לאחרונה על ידי מתכנת חובב
                                        #131

                                        @כבוד-הרב כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

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

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

                                        @כבוד-הרב כתב בהמלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:

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

                                        בא נחשב את זה ככה
                                        תמונה ברזולוציה של 1024x1024 תדרוש שידור של מיליון ביטים בשיטה הזאת
                                        לעומת זאת אם נדחוס את התמונה לפורמט מקביל כמו png או tiff לדוגמה באותו עומק צבע (שחור לבן) היא תשקול פחות מעשירית מזה
                                        עדיף כבר להשתמש בחבילות קטנות של מידע ולהפעיל עליהם checksum ותיקון שגיאות

                                        צריך עזרה בשחזור מידע? ייעוץ? egozkokus1@gmail.com

                                        תגובה 1 תגובה אחרונה
                                        2
                                        • H מנותק
                                          H מנותק
                                          hartkhartk
                                          כתב נערך לאחרונה על ידי
                                          #132

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

                                          A0533057932A תגובה 1 תגובה אחרונה
                                          0

                                          • התחברות

                                          • אין לך חשבון עדיין? הרשמה

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