דילוג לתוכן
  • חוקי הפורום
  • פופולרי
  • לא נפתר
  • משתמשים
  • חיפוש גוגל בפורום
  • צור קשר
עיצובים
  • 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. המלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא

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

מתוזמן נעוץ נעול הועבר עזרה הדדית - מחשבים וטכנולוגיה
158 פוסטים 47 כותבים 3.5k צפיות 46 עוקבים
  • מהישן לחדש
  • מהחדש לישן
  • הכי הרבה הצבעות
תגובה
  • תגובה כנושא
התחברו כדי לפרסם תגובה
נושא זה נמחק. רק משתמשים עם הרשאות מתאימות יוכלו לצפות בו.
  • כ כבוד הרב

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        שלום לכולם!

        אני רוצה לשתף אתכם בפרויקט מחקר ופיתוח שעבדתי עליו בתקופה האחרונה (הקוד נבנה ע"י 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.

        בהצלחה! 🚀

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

        @כבוד-הרב אז הפרויקט המהפכני שלך זה העברת מידע באמצעות ביטים רק שבמקום 1 ו0 וזה סאונד של ביפ אם הבנתי נכון?

        כ מתכנת חובבמ 2 תגובות תגובה אחרונה
        0
        • ח חנוך הכהן

          @כבוד-הרב אז הפרויקט המהפכני שלך זה העברת מידע באמצעות ביטים רק שבמקום 1 ו0 וזה סאונד של ביפ אם הבנתי נכון?

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

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

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

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

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

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

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

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

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

            ח מתכנת חובבמ 2 תגובות תגובה אחרונה
            0
            • ד מנותק
              ד מנותק
              דוד יצחק
              כתב נערך לאחרונה על ידי
              #77

              אני מציע פה עוד כיון לעשות את ההקלטה קצת יותר מהר

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

                @כבוד-הרב אז הפרויקט המהפכני שלך זה העברת מידע באמצעות ביטים רק שבמקום 1 ו0 וזה סאונד של ביפ אם הבנתי נכון?

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

                @חנוך-הכהן לא מדוייק
                תנסה לחשוב על גל קול כמו על גל רדיו
                אפשר לאפנן בתדר
                אפשר לאפנן באמפליטודה
                ואפשר לאפנן בפאזה
                אפנון בפאזה לא אפשרי כאן כי הדחיסה של amr - קידוד האודיו בדור 3 מעוותת את הפאזה כדי לשמור על קו מיושר כמה שאפשר ולהשמיט רעשי רקע
                אפנון באמפליטודה מטבעו פחות רלוונטי בגל קול אז אפשר להקביל אותו ל LSP's או לאיזה שהוא ממוצע שלהם
                ואפנון בתדר הוא קצת טריקי כי למרות שיש טווח תדרים יחסית רחב אבל אופן חישוב התדר הוא על פי ה lag ואז בגבוהים זה נהיה מידי צמוד ולכן בפועל אפשר לקודד בטווח קטן יחסית של תדרים
                כאן בכל אופן בוצע אפנון תדר ברוחב 2 ביט לכאורה כל מסגרת זה מידע חדש

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

                תגובה 1 תגובה אחרונה
                1
                • ד דוד יצחק

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

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

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

                  P תגובה 1 תגובה אחרונה
                  0
                  • ד דוד יצחק

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

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

                    @דוד-יצחק דחיסה לא מאוד תעזור למסמכים כמו וורד או PDF - אולי באחוזים בודדים

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

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

                      @דוד-יצחק דחיסה לא מאוד תעזור למסמכים כמו וורד או PDF - אולי באחוזים בודדים

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

                      @מתכנת-חובב אתה בטוח?
                      כי אם אני זוכר נכון לפני כמה שנים חילצתי את תורת אמת וזה שקל פי 2 אחרי חילוץ (כמדומני שזה היה קבצי HTML)

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

                        @מתכנת-חובב אתה בטוח?
                        כי אם אני זוכר נכון לפני כמה שנים חילצתי את תורת אמת וזה שקל פי 2 אחרי חילוץ (כמדומני שזה היה קבצי HTML)

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

                        @דוד-יצחק תורת אמת זה קבצי plain text שהם הקבצים שהכי נדחסים
                        קבצי וורד ו PDF כבר מממשים בתוכם כיווץ - גם אם לא מאוד יעיל ולכן כיווץ חיצוני נוסף לא יוסיף הרבה גם אם זה יהיה באלגוריתם מתוחכם מאוד

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

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

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

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

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

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

                            @חנוך-הכהן האדמור מגור

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

                              שלום לכולם!

                              אני רוצה לשתף אתכם בפרויקט מחקר ופיתוח שעבדתי עליו בתקופה האחרונה (הקוד נבנה ע"י 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.

                              בהצלחה! 🚀

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

                              @כבוד-הרב רעיון מטורף אדיר
                              אם היה לי מספיק מוניטין הייתי שם לך אבל אני לא יכול

                              א תגובה 1 תגובה אחרונה
                              1
                              • א אשריך עליך

                                @כבוד-הרב רעיון מטורף אדיר
                                אם היה לי מספיק מוניטין הייתי שם לך אבל אני לא יכול

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

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

                                יאיר דניאלי תגובה 1 תגובה אחרונה
                                1
                                • א אליהו בשטח

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

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

                                  @אליהו-בשטח איך המחשב יכול לקבל שמע דרך בלוטוס ממכשיר סללורי?
                                  לא מכיר כזה דבר.

                                  א תגובה 1 תגובה אחרונה
                                  0
                                  • יאיר דניאלי יאיר דניאל

                                    @אליהו-בשטח איך המחשב יכול לקבל שמע דרך בלוטוס ממכשיר סללורי?
                                    לא מכיר כזה דבר.

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

                                    הפיכת המחשב למקלט שמע (Bluetooth A2DP Sink) באמצעות קוד
                                    ניתן להפוך את המחשב ל"רמקול בלוטוס" על ידי שימוש בשימוש ב-WinRT APIs (בווינדוס) או BlueZ (בלינוקס), המאפשרים למחשב להירשם כצומת A2DP Sink המקבל זרם שמע ממכשירים חיצוניים.

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

                                    from winsdk.windows.devices.bluetooth import BluetoothDevice
from winsdk.windows.devices.enumeration import DeviceInformation

async def connect_audio_sink(device_name):
    # חיפוש התקנים מותאמים (Paired)
    devices = await DeviceInformation.find_all_async(BluetoothDevice.get_device_selector())
    
    for info in devices:
        if device_name in info.name:
            device = await BluetoothDevice.from_id_async(info.id)
            # כאן מתבצע הרישום לשירות ה-A2DP Sink
            print(f"Connecting to {info.name} as Audio Source...")
            # המערכת תנתב אוטומטית את השמע ל-Output ברירת המחדל
            return True
    return False

# הרצת החיבור
# asyncio.run(connect_audio_sink("Your_Phone_Name"))
                                    תגובה 1 תגובה אחרונה
                                    0
                                    • כ כבוד הרב

                                      שלום לכולם!

                                      אני רוצה לשתף אתכם בפרויקט מחקר ופיתוח שעבדתי עליו בתקופה האחרונה (הקוד נבנה ע"י 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.

                                      בהצלחה! 🚀

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

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

                                      @מתכנת-חובב לדעתי תהנה מהתוכנה הזו.

                                      מדריך מלא: העברת קבצים למחשב מנותק (Offline) דרך קו טלפון

                                      באמצעות מערכת "ימות המשיח" ותוכנת Fldigi

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

                                      רשימת ציוד נדרש

                                      1. מחשב שולח (מחובר): להכנת הקובץ.
                                      2. מחשב מקבל (מנותק): אליו נעביר את המידע.
                                      3. תוכנת Fldigi: להורדה מכאן (SourceForge).
                                      4. מיקרופון: מחובר למחשב המנותק (או כבל AUX).

                                      שלב א': התקנה והגדרות ראשוניות (חובה בשני המחשבים)

                                      לאחר התקנת התוכנה והפעלתה בפעם הראשונה, יפתח "אשף ההגדרות". יש לפעול בדיוק לפי השלבים הבאים:

                                      1. מסך 1 (Welcome): לחץ Next.
                                      2. מסך 2 (Operator Info):
                                        • מלא פרטים פיקטיביים (למשל: TEST ב-Callsign, ו-USER ב-Name).
                                        • זה לא משנה לשימוש שלנו. לחץ Next.
                                      3. מסך 3 (Audio Devices) - המסך הכי חשוב!
                                        • סמן את האפשרות PortAudio.
                                        • Capture: בחר את המיקרופון שדרכו תקלוט את הצלילים.
                                        • Playback: בחר את הרמקולים של המחשב.
                                        • חשוב מאוד: וודא שהתיבה "File I/O only" אינה מסומנת (ריקה). אם היא מסומנת, לא תוכל לייצר קבצי שמע.
                                        • לחץ Next.
                                      4. מסכים 4, 5, 6 (Rig Control - Flrig/RigCAT/Hamlib):
                                        • אל תיגע בכלום. מסכים אלו מיועדים למכשירי קשר פיזיים.
                                        • פשוט לחץ Next שוב ושוב עד שתעבור אותם.
                                      5. מסכים 7, 8 (Updates/Web):
                                        • לחץ Finish.

                                      שלב ב': הכנת הקובץ לשידור (במחשב השולח)

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

                                      1. המרת הקובץ לטקסט:

                                        • פתח שורת פקודה (CMD) בתיקייה שבה נמצא הקובץ.
                                        • הקלד: certutil -encode file.pdf data.txt (החלף את file.pdf בשם הקובץ שלך).
                                        • פתח את data.txt והעתק את כל תוכנו (כולל השורות BEGIN CERTIFICATE).

                                      2. המרת הטקסט לקובץ שמע (WAV) ב-Fldigi:

                                        • פתח את Fldigi.
                                        • בחר פרוטוקול עמיד לרעשים: Op Mode > MT63 > MT63-2000L.
                                        • הדבק את הטקסט שהעתקת בחלון התכלת (התחתון).
                                        • בתפריט: File > Audio > TX Generate.
                                        • שמור את הקובץ בשם 000.wav.
                                        • אינדיקציה: הטקסט בחלון התכלת ישנה צבע במהירות – סימן שהקובץ נוצר.

                                      שלב ג': העלאה למערכת "ימות המשיח"

                                      1. כנס לממשק הניהול -> שלוחה ריקה.
                                      2. הגדרות מתקדמות: הגדר type=playfile.
                                      3. קבצים: העלה את הקובץ 000.wav שיצרת בשלב הקודם.

                                      שלב ד': ביצוע ההעברה למחשב המנותק

                                      1. פתח את Fldigi במחשב המנותק.
                                      2. הגדרות קליטה:
                                        • וודא שהפרוטוקול הוא: MT63-2000L.
                                        • ביטול סינון רעשים (SQL): בפינה הימנית התחתונה, וודא שכפתור SQL כבוי (לא ירוק) והמחוון שלידו למטה לגמרי. המחשב צריך "לשמוע הכל".
                                        • ווליום: בהגדרות ווינדוס, וודא שהמיקרופון על 100%.
                                      3. לחץ קליק ימני על החלון הלבן (העליון) -> Clear.
                                      4. השידור:
                                        • חייג בטלפון למערכת ימות המשיח.
                                        • הצמד את הטלפון למיקרופון (או חבר כבל). שמור על שקט בחדר.
                                      5. בזמן השיחה:
                                        • תראה פסים צהובים יורדים ב"מפל" השחור למטה.
                                        • בחלון הלבן יופיע ג'יבריש, ואז הטקסט הנקי: -----BEGIN CERTIFICATE-----.

                                      שלב ה': שחזור הקובץ (במחשב המנותק)

                                      1. כשהשידור מסתיים, סמן ב-Fldigi את הטקסט רק מהשורה -----BEGIN CERTIFICATE----- ועד -----END CERTIFICATE----- (כולל).
                                      2. העתק את הטקסט (Ctrl+C).
                                      3. פתח "פנקס רשימות" (Notepad), הדבק ושמור בשם received.txt.
                                      4. פתח שורת פקודה (CMD) באותה תיקייה והרץ:
                                        certutil -decode received.txt final_file.pdf
                                        (שנה את הסיומת pdf לסיומת המקורית של הקובץ).

                                      פתרון תקלות

                                      • הטקסט יוצא "זבל" (ג'יבריש) ללא הפסקה: האות חלש מדי. הגבר את הווליום בטלפון לאזור 80%-90% וודא שמיקרופון המחשב על 100%.
                                      כ ד 2 תגובות תגובה אחרונה
                                      4
                                      • כ כבוד הרב

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

                                        @מתכנת-חובב לדעתי תהנה מהתוכנה הזו.

                                        מדריך מלא: העברת קבצים למחשב מנותק (Offline) דרך קו טלפון

                                        באמצעות מערכת "ימות המשיח" ותוכנת Fldigi

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

                                        רשימת ציוד נדרש

                                        1. מחשב שולח (מחובר): להכנת הקובץ.
                                        2. מחשב מקבל (מנותק): אליו נעביר את המידע.
                                        3. תוכנת Fldigi: להורדה מכאן (SourceForge).
                                        4. מיקרופון: מחובר למחשב המנותק (או כבל AUX).

                                        שלב א': התקנה והגדרות ראשוניות (חובה בשני המחשבים)

                                        לאחר התקנת התוכנה והפעלתה בפעם הראשונה, יפתח "אשף ההגדרות". יש לפעול בדיוק לפי השלבים הבאים:

                                        1. מסך 1 (Welcome): לחץ Next.
                                        2. מסך 2 (Operator Info):
                                          • מלא פרטים פיקטיביים (למשל: TEST ב-Callsign, ו-USER ב-Name).
                                          • זה לא משנה לשימוש שלנו. לחץ Next.
                                        3. מסך 3 (Audio Devices) - המסך הכי חשוב!
                                          • סמן את האפשרות PortAudio.
                                          • Capture: בחר את המיקרופון שדרכו תקלוט את הצלילים.
                                          • Playback: בחר את הרמקולים של המחשב.
                                          • חשוב מאוד: וודא שהתיבה "File I/O only" אינה מסומנת (ריקה). אם היא מסומנת, לא תוכל לייצר קבצי שמע.
                                          • לחץ Next.
                                        4. מסכים 4, 5, 6 (Rig Control - Flrig/RigCAT/Hamlib):
                                          • אל תיגע בכלום. מסכים אלו מיועדים למכשירי קשר פיזיים.
                                          • פשוט לחץ Next שוב ושוב עד שתעבור אותם.
                                        5. מסכים 7, 8 (Updates/Web):
                                          • לחץ Finish.

                                        שלב ב': הכנת הקובץ לשידור (במחשב השולח)

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

                                        1. המרת הקובץ לטקסט:

                                          • פתח שורת פקודה (CMD) בתיקייה שבה נמצא הקובץ.
                                          • הקלד: certutil -encode file.pdf data.txt (החלף את file.pdf בשם הקובץ שלך).
                                          • פתח את data.txt והעתק את כל תוכנו (כולל השורות BEGIN CERTIFICATE).

                                        2. המרת הטקסט לקובץ שמע (WAV) ב-Fldigi:

                                          • פתח את Fldigi.
                                          • בחר פרוטוקול עמיד לרעשים: Op Mode > MT63 > MT63-2000L.
                                          • הדבק את הטקסט שהעתקת בחלון התכלת (התחתון).
                                          • בתפריט: File > Audio > TX Generate.
                                          • שמור את הקובץ בשם 000.wav.
                                          • אינדיקציה: הטקסט בחלון התכלת ישנה צבע במהירות – סימן שהקובץ נוצר.

                                        שלב ג': העלאה למערכת "ימות המשיח"

                                        1. כנס לממשק הניהול -> שלוחה ריקה.
                                        2. הגדרות מתקדמות: הגדר type=playfile.
                                        3. קבצים: העלה את הקובץ 000.wav שיצרת בשלב הקודם.

                                        שלב ד': ביצוע ההעברה למחשב המנותק

                                        1. פתח את Fldigi במחשב המנותק.
                                        2. הגדרות קליטה:
                                          • וודא שהפרוטוקול הוא: MT63-2000L.
                                          • ביטול סינון רעשים (SQL): בפינה הימנית התחתונה, וודא שכפתור SQL כבוי (לא ירוק) והמחוון שלידו למטה לגמרי. המחשב צריך "לשמוע הכל".
                                          • ווליום: בהגדרות ווינדוס, וודא שהמיקרופון על 100%.
                                        3. לחץ קליק ימני על החלון הלבן (העליון) -> Clear.
                                        4. השידור:
                                          • חייג בטלפון למערכת ימות המשיח.
                                          • הצמד את הטלפון למיקרופון (או חבר כבל). שמור על שקט בחדר.
                                        5. בזמן השיחה:
                                          • תראה פסים צהובים יורדים ב"מפל" השחור למטה.
                                          • בחלון הלבן יופיע ג'יבריש, ואז הטקסט הנקי: -----BEGIN CERTIFICATE-----.

                                        שלב ה': שחזור הקובץ (במחשב המנותק)

                                        1. כשהשידור מסתיים, סמן ב-Fldigi את הטקסט רק מהשורה -----BEGIN CERTIFICATE----- ועד -----END CERTIFICATE----- (כולל).
                                        2. העתק את הטקסט (Ctrl+C).
                                        3. פתח "פנקס רשימות" (Notepad), הדבק ושמור בשם received.txt.
                                        4. פתח שורת פקודה (CMD) באותה תיקייה והרץ:
                                          certutil -decode received.txt final_file.pdf
                                          (שנה את הסיומת pdf לסיומת המקורית של הקובץ).

                                        פתרון תקלות

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

                                        מי שרוצה לראות תוצאות ומהירות בשטח.
                                        יש לבחור בפרוטוקול MFSK32 (בהודעה הקודמת כתוב איך לעשות את זה לגבי MT63-2000L).
                                        להתקשר לקו שמספרו: 0794946346 להפעיל על רמקול לא מדאי חזק אבל שיהיה קרוב למיקרופון ותראו את התוצאות בחלון הצהוב של התוכנה הנ"ל.

                                        תגובה 1 תגובה אחרונה
                                        0
                                        • צדיק תמיםצ צדיק תמים

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

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

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

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

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

                                          מי שרוצה אינטרנט שפשוט יקנה סים עם אינטרנט...

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

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

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