המלצה | 🚀 [פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא
-
הייתי מנותק כמה ימים ולא עברתי על כל השירשור
משהו יכול אולי לתמצת לי מה הרעיון בדיוק עושה? זה בעצם שולח קובצי טקסט?@hartkhartk מכיר פקס \ אינטרנט מהימים הראשונים וכד'
אז משהו דומהבמילים אחרות
שידור מידע רק בקצת של חילזון
דרך קול (די דומה למורס בסוף)רעיון חמוד
שימוש מעשי 0
כי הרבה יותר פשוט יהיה לשלוח פקס -
@hartkhartk מכיר פקס \ אינטרנט מהימים הראשונים וכד'
אז משהו דומהבמילים אחרות
שידור מידע רק בקצת של חילזון
דרך קול (די דומה למורס בסוף)רעיון חמוד
שימוש מעשי 0
כי הרבה יותר פשוט יהיה לשלוח פקס@A0533057932 כתב בהמלצה |
[פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:כי הרבה יותר פשוט יהיה לשלוח פקס
לא, כי אתה רוצה לשלוח בצבעוני, אלא אם כן יש לך פקס במחשב (או הדפסה בצבעוני שזזה יחסית יקר)
מלבד זה, יש הרבה יותר אנשים עם מחשב בלי אינטרנט ובלי פקס מאנשים עם פקס -
@A0533057932 כתב בהמלצה |
[פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:כי הרבה יותר פשוט יהיה לשלוח פקס
לא, כי אתה רוצה לשלוח בצבעוני, אלא אם כן יש לך פקס במחשב (או הדפסה בצבעוני שזזה יחסית יקר)
מלבד זה, יש הרבה יותר אנשים עם מחשב בלי אינטרנט ובלי פקס מאנשים עם פקס@צבי-דורש-ציון כתב בהמלצה |
[פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:פקס במחשב
במקרה של שליחה מפקס - לפקס במחשב/פקס מדפסת צבעונית, זה מגיע צבעוני?
-
@MGM-IVR אגב רק כדי להראות שאפשר לשפר את זה עוד הרבה ולהכניס קבצים גם יותר גדולים הנה גרסה שלא מכפילה ומבצעת דחיסה וכן היא שולחת את האותות במהירות יותר נמוכה.
שם המילה "שלום" הומרה לפחות מ-14 שניות שמע.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 # === הגדרות מודם (Turbo Edition) === SAMPLE_RATE = 8000 BAUD_RATE = 64 # העלינו קצת את המהירות (מ-40 ל-64) - עדיין בטוח FREQ_MARK = 1000 FREQ_SPACE = 2000 # הפרדה גדולה יותר לזיהוי מהיר RS_ECC_SYMBOLS = 40 # הגדלנו את התיקון (כי ביטלנו את השילוש) INTERLEAVE_STEP = 30 # פיזור שגיאות # סנכרון SYNC_DURATION = 0.6 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_TURBO.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) # === Encoder === def generate_signal(filename, file_content, output_wav): try: write_log(f"מקודד טורבו: {filename}") orig_size = len(file_content) # 1. דחיסה (ZLIB) - זה החיסכון הגדול! compressed_content = zlib.compress(file_content, level=9) comp_size = len(compressed_content) write_log(f"דחיסה: {orig_size} -> {comp_size} בייטים") ext = os.path.splitext(filename)[1].lower() is_text = ext in TEXT_EXTENSIONS fname_bytes = os.path.basename(filename).encode('utf-8') if len(fname_bytes) > 100: fname_bytes = fname_bytes[:100] # דגל סוג (טקסט/בינארי) כבר פחות חשוב כי הכל דחוס, אבל נשמור type_flag = 1 if is_text else 0 # חישוב CRC על המידע הדחוס crc = zlib.crc32(compressed_content) & 0xffffffff # אריזה: [NameLen] [Name] [Type] [CRC] [CompressedContent] packet = struct.pack('B', len(fname_bytes)) + fname_bytes + struct.pack('B', type_flag) + struct.pack('>I', crc) + compressed_content # 2. הגנה (Reed-Solomon מחוזק) rsc = RSCodec(RS_ECC_SYMBOLS) encoded_data = rsc.encode(packet) # 3. ערבוב (Interleaving) raw_bits = text_to_bits(encoded_data) shuffled_bits, padding = interleave_bits(raw_bits) # 4. כותרת: [Magic] [Length] [Padding] # אנחנו שולחים את הכותרת 3 פעמים (כי היא קצרה וחשובה), אבל את התוכן רק פעם אחת! 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 # 5. יצירת אודיו samples_per_bit = int(SAMPLE_RATE / BAUD_RATE) t_wake = np.arange(int(SAMPLE_RATE * 2.0)) / SAMPLE_RATE # קיצרנו את ה-Wakeup ל-2 שניות 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.7], [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) duration = len(final_audio) / SAMPLE_RATE return True, f"קובץ טורבו נוצר!\nזמן משוער: {duration:.1f} שניות\n(דחיסה: {int((1-comp_size/orig_size)*100)}%)" except Exception as e: return False, str(e) # === Decoder === def decode_signal(input_wav, output_folder): try: with open("LOG_TURBO.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, [800, 2200], 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 else: return False, "Magic Byte לא נמצא" data_start = magic_idx + 8 # 3. Header 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}") except: return False, "שגיאת כותרת" if data_len > 5000000 or data_len == 0: return False, f"אורך לא הגיוני {data_len}" # 4. חילוץ 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) packet = bits_to_bytes(raw_bits) # 5. RS Decode try: rsc = RSCodec(RS_ECC_SYMBOLS) decoded_packet = rsc.decode(packet)[0] # 6. פירוק + פתיחת דחיסה 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 received_crc = struct.unpack('>I', decoded_packet[ptr:ptr+4])[0]; ptr+=4 compressed_content = decoded_packet[ptr:] # בדיקת CRC calc_crc = zlib.crc32(compressed_content) & 0xffffffff if calc_crc != received_crc: return False, "שגיאת CRC (תוכן משובש)" # פתיחת דחיסה (ZLIB) try: final_data = zlib.decompress(compressed_content) write_log("פתיחת דחיסה הצליחה") except Exception as zerr: return False, f"שגיאה בפתיחת הדחיסה: {zerr}" path = os.path.join(output_folder, filename) with open(path, 'wb') as f: f.write(final_data) return True, f"הצלחה! {filename}" except ReedSolomonError: 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 - TURBO 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="צור קובץ (Turbo Compression)", 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_TURBO.txt") if os.path.exists("LOG_TURBO.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="מפענח (Decompress)...", 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()@כבוד-הרב כתב בהמלצה |
[פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:האמת היא שקובץ שמכיל את המילה "שלום" בלבד הומר לקובץ שמע של 31 שניות שזה המון.
@כבוד-הרב כתב בהמלצה |
[פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:שם המילה "שלום" הומרה לפחות מ-14 שניות שמע.
בלתק
הנה
הצלחתי להכפיל את המהירות [באותה טכנולוגיה] ב~1400/700x
עם המון שיפורים נוספים -
@כבוד-הרב כתב בהמלצה |
[פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:האמת היא שקובץ שמכיל את המילה "שלום" בלבד הומר לקובץ שמע של 31 שניות שזה המון.
@כבוד-הרב כתב בהמלצה |
[פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:שם המילה "שלום" הומרה לפחות מ-14 שניות שמע.
בלתק
הנה
הצלחתי להכפיל את המהירות [באותה טכנולוגיה] ב~1400/700x
עם המון שיפורים נוספים@משחזר-מידע כתב בהמלצה |
[פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:[באותה טכנולוגיה]
איך זה אותה טכנולוגיה?
אותה טכנולוגיה זה גם דיבור שהוא הרבה יותר מהיר מהמילה שלום ב 14 שניות
הבעיה היא במגבלות הציוד הקיים -
אני לא מבין גדול בזה
אבל חשבתי על כיוון לייעול משמעותי של הפרויקט: כרגע המערכת מתוכננת כ'מודם אקוסטי' – היא יוצרת צלילים כדי שהם יעברו באוויר. אבל אם אנחנו כבר מחברים את הטלפון למחשב עם כבל AUX, אנחנו יכולים לוותר לגמרי על הניסיון 'להישמע' כמו קול אנושי.הרעיון שלי הוא להשתמש בכבל כנתיב להעברת האות החשמלי (ה'קוד' שמפעיל את הרמקול) ישירות לתוכנה של המחשב השני והאות החשמלי שיעבור זה יהיה האות של הקובץ עצמו לא האות של השמע.
במצב כזה, העברת הנתונים תהיה מהירה הרבה יותר ממתי שאנחנו משמיעים לתוכנה את הקידוד באמצעות הקול אם נשנה את התוכנה כך שתשלח את הנתונים כאותות חשמליים 'טהורים' דרך הכבל:
המהירות תזנק: נוכל להעביר הרבה יותר מידע בכל 'פולס' חשמלי
אשמח לדעת האם דבר זה יעזור והאם זה אפשרי -
בלי קשר לרעיון הזה לפני כמה ימים עלה רעיון קצת יותר ישים ועדיין זה לא אינטנרט עם חסרונותיו, זה להתשמש במסך עם צג כמו של מחשבון,ככה שזה בלתי אפשרי לראות תמונות וסרטים אבל כן אפשרי למיילים העברת מידע וכדומה
-
אני לא מבין גדול בזה
אבל חשבתי על כיוון לייעול משמעותי של הפרויקט: כרגע המערכת מתוכננת כ'מודם אקוסטי' – היא יוצרת צלילים כדי שהם יעברו באוויר. אבל אם אנחנו כבר מחברים את הטלפון למחשב עם כבל AUX, אנחנו יכולים לוותר לגמרי על הניסיון 'להישמע' כמו קול אנושי.הרעיון שלי הוא להשתמש בכבל כנתיב להעברת האות החשמלי (ה'קוד' שמפעיל את הרמקול) ישירות לתוכנה של המחשב השני והאות החשמלי שיעבור זה יהיה האות של הקובץ עצמו לא האות של השמע.
במצב כזה, העברת הנתונים תהיה מהירה הרבה יותר ממתי שאנחנו משמיעים לתוכנה את הקידוד באמצעות הקול אם נשנה את התוכנה כך שתשלח את הנתונים כאותות חשמליים 'טהורים' דרך הכבל:
המהירות תזנק: נוכל להעביר הרבה יותר מידע בכל 'פולס' חשמלי
אשמח לדעת האם דבר זה יעזור והאם זה אפשרי@IID זה בדיוק מה שנעשה כאן
הבעיה היא שזה לא קו נקי - מה שהעברת לא יגיע לצד השני בדיוק כמו ששלחת אותו בגלל המקודד שמעוות אותו ובין היתר גם מסיר צלילים שלא נשמעים קולות אנושיים
האתגר הוא למצוא את המאפיינים שאפשר לשתול בשיחה שוודאות גבוהה יגיעו בשלום לצד השני בצורה שתאפשר זיהוי ברור שלהם
הגעתי להתקדמות די גדולה בזה אבל אני בתקופה קצת עמוסה אז זה בהשהייה עכשיו -
@CSS-0 לא תעלה את הקובץ שמע שקיבלת לקו כל שהוא ותתקשר לקו ותשמיע את זה לתוכנה.
שים לב שעדיף שתמיר קובץ טקסט בן מילה שתים ולא יותר כי אחרת זה יהיה הקלטה ארוכה מאוד וזה מתכון לשגיאות.
זה עכשיו נועד רק כדי להוכיח שזה אפשרי לא באמת לשימוש בפועל לקבצים גדולים וארוכים
אני מקווה שיהיה כאן את האנשים שיעלו את זה לרמה שימושית -
@כבוד-הרב הרעיון הזה היה קיים בעבר לגוגל היה תוסף לכרום לשליחת קישורים בין שני מחשבים באמצעות השמעת צלילים קראו לזה Google Tone
למעשה זה לא מעשי לשליחת קבצים גדולים כי מהירות ההעברה היא איטית מאד בערך 4 שעות ל1 מגה בייט במקרה הטוב@web_master ב google tone שידרו בספקטרום של 10 תדרים (אמנם תדר כפול בכל פעם) ומשך כל סימבול היה בערך 100ms בגלל מגבלות הסביבה
בשידור כמו כאן יהיה אפשר לשדר פי 3 יותר מהר כי אפשר לשדר 16 תדרים בערך (+ שינויים ב LPC) ומשך סימבול של 40ms
ובכל אופן אני לא טוען שזה משהו שיפתור את בעיית חוסר התקשורת ושליחת המסמכים - זה לא אבל בתור פרוייקט מחקרי יש לזה יותר אופקצריך עזרה בשחזור מידע? ייעוץ? egozkokus1@gmail.com
-
@web_master ב google tone שידרו בספקטרום של 10 תדרים (אמנם תדר כפול בכל פעם) ומשך כל סימבול היה בערך 100ms בגלל מגבלות הסביבה
בשידור כמו כאן יהיה אפשר לשדר פי 3 יותר מהר כי אפשר לשדר 16 תדרים בערך (+ שינויים ב LPC) ומשך סימבול של 40ms
ובכל אופן אני לא טוען שזה משהו שיפתור את בעיית חוסר התקשורת ושליחת המסמכים - זה לא אבל בתור פרוייקט מחקרי יש לזה יותר אופק@מתכנת-חובב השאלה אם אין אפשרות אולי לבנות (או שחברה כמו ימות המשיח לדוגמא תבנה) שרת בחברת תקשורת שלא מסנן קולות לא אנושיים?
-
@מתכנת-חובב השאלה אם אין אפשרות אולי לבנות (או שחברה כמו ימות המשיח לדוגמא תבנה) שרת בחברת תקשורת שלא מסנן קולות לא אנושיים?
-
שלום לכולם!
אני רוצה לשתף אתכם בפרויקט מחקר ופיתוח שעבדתי עליו בתקופה האחרונה (הקוד נבנה ע"י gemini-3-pro-preview), שמוכיח שהבלתי אפשרי - אפשרי.
הצלחתי לפתח מודם אקוסטי (Data-over-Sound) שמאפשר להעביר קבצים (טקסט, תמונות, מסמכים) לתוך מחשב מנותק רשת (Offline/Air-Gapped) באמצעות שיחה קולית פשוטה מטלפון כשר! (דרך מערכת טלפונית בימות המשיח וכד')זה נשמע כמו מדע בדיוני או חזרה לשנות ה-80, אבל עם האלגוריתמים הנכונים, זה עובד בצורה מדהימה ב-2026.
למה זה טוב?עד היום, כדי להכניס למחשב מנותק מאינטרנט קובץ הייתם צריכים דיסק-און-קי פיזי.
הפיתוח הזה מאפשר לקבל קבצים דחופים למחשב המנותק ע"י השמעת הקלטה דרך הטלפון (רמקול או כבל AUX).
וכמובן עוד הרבה אפשרוית לפיתוח הלאה שאין להם סוף.
️ מה יש מתחת למכסה המנוע? ("פרוטוקול טיטניום")כדי להתגבר על האיכות הגרועה של קווי הטלפון (דחיסת GSM/G.729) ורעשי הרקע, בניתי פרוטוקול שידור סופר-קשוח שכולל:
- Triple Voting (הצבעת רוב): כל בייט נשלח 3 פעמים. אם רעש הורס אחד מהם, המחשב לוקח את הרוב הקובע.
- Reed-Solomon ECC: תיקון שגיאות מתמטי (כמו ב-QR Code) שמשחזר מידע שנמחק.
- Interleaving (ערבוב): פיזור הביטים כך שקטיעה רגעית בקו לא תמחק אות שלמה, אלא רק "שריטות" קטנות שקל לתקן.
- CRC32: בדיקת תקינות סופית - אם הקובץ לא שוחזר ב-100% דיוק, המערכת תודיע.
המטרה שלי בפרסוםאני מפרסם כאן את הקוד המלא (Python) כקוד פתוח.
הוכחתי את ההיתכנות הטכנית ברמה הגבוהה ביותר (DSP). המטרה שלי היא שמפתחים תותחים מכאן יקחו את הליבה הזו ויפתחו אותה למוצר נגיש, שירותי המרה, אפליקציות או כל רעיון אחר.קישור לתוכנה המקומפלת להורדה
זה הקובץ של התוכנה המקומפל ניתן ליצור באמצעותו קובץ שמע ולעלות לימות המשיח ואז להשמיע את ההקלטה דרך הטלפון לתוכנה במחשב המנותק מרשת.שימו לב זו גרסה ראשונית לצורך ניסוים בלבד! מומלץ לנסות בהתחלה להמיר קובץ טקסט בעל מילים בודדות בלבד!
הוראות שימוש (חובה לקרוא!)הפיזיקה של הסאונד היא עדינה. כדי שזה יעבוד "אחד לאחד", הקפידו על הכללים הבאים:
-
ווליום (הכי חשוב!):
- אין להגביר את הטלפון למקסימום! זה יוצר עיוות (Distortion) שהורס את האות הדיגיטלי.
- יש לכוון לעוצמה של כ-60%-70%.
- בתוכנה יש "מד עוצמה" – כוונו כך שהפס יהיה ירוק. אם הוא אדום, זה לא יעבוד.
-
חיבור AUX (מומלץ):
- הדרך הכי נקייה היא לחבר כבל AUX בין הטלפון לכניסת המיקרופון (Line-In) במחשב.
- שים לב: במחשבים ניידים עם שקע בודד (Combo Jack), כבל AUX רגיל לא יעבוד כמיקרופון! צריך כרטיס קול USB פשוט (עולה כמה שקלים) או מפצל ייעודי.
-
שימוש ברמקול (אקוסטי):
- אפשרי בהחלט!
- יש להיות בחדר שקט יחסית.
- יש להצמיד את רמקול הטלפון למיקרופון של המחשב.
המדריך הטכני למפתחכדי להריץ את זה, תצטרכו Python מותקן על המחשב.
1. התקנת הספריות הדרושות:
פתחו CMD והריצו:pip install numpy scipy sounddevice soundfile reedsolo pyinstaller2. הקוד המלא:
העתיקו את הקוד הבא ושמרו אותו בקובץ בשם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.
בהצלחה!
לא עברתי על כל השרשור, הוא דיי ארוך
חמוד ביותר בהצלחה @כבוד-הרב
(אגב השתעשעתי בזה כילד די הרבה)@כבוד-הרב כתב בהמלצה |
[פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:Triple Voting (הצבעת רוב): כל בייט נשלח 3 פעמים. אם רעש הורס אחד מהם, המחשב לוקח את הרוב הקובע.
אני חושב שתוכל לחסוך את זה אם הקו חזק ואפשר לבדוק את זה על ידי שליחה של טקסט ראשוני מורכב (כמו הריבועים בצדדים של קוד QR) ולאחר מכן המחשב יחזיר תשובה עד כמה זה ברור לו (ייתכן שיש הבדלים בין קווים בצלילים ולזה גם זה יכול להועיל לכוון את המחשב להבין את הצליל הספיציפי של הקו הזה, אולי אין הבדלים, אני לא יודע)
דבר שני אני חושב שאתה יכול לפצל את זה לבלוקים ואם יש שגיאה בבלוק מסויים המחשב ייבקש אותו שוב -
שלום לכולם!
אני רוצה לשתף אתכם בפרויקט מחקר ופיתוח שעבדתי עליו בתקופה האחרונה (הקוד נבנה ע"י gemini-3-pro-preview), שמוכיח שהבלתי אפשרי - אפשרי.
הצלחתי לפתח מודם אקוסטי (Data-over-Sound) שמאפשר להעביר קבצים (טקסט, תמונות, מסמכים) לתוך מחשב מנותק רשת (Offline/Air-Gapped) באמצעות שיחה קולית פשוטה מטלפון כשר! (דרך מערכת טלפונית בימות המשיח וכד')זה נשמע כמו מדע בדיוני או חזרה לשנות ה-80, אבל עם האלגוריתמים הנכונים, זה עובד בצורה מדהימה ב-2026.
למה זה טוב?עד היום, כדי להכניס למחשב מנותק מאינטרנט קובץ הייתם צריכים דיסק-און-קי פיזי.
הפיתוח הזה מאפשר לקבל קבצים דחופים למחשב המנותק ע"י השמעת הקלטה דרך הטלפון (רמקול או כבל AUX).
וכמובן עוד הרבה אפשרוית לפיתוח הלאה שאין להם סוף.️ מה יש מתחת למכסה המנוע? ("פרוטוקול טיטניום")כדי להתגבר על האיכות הגרועה של קווי הטלפון (דחיסת GSM/G.729) ורעשי הרקע, בניתי פרוטוקול שידור סופר-קשוח שכולל:
- Triple Voting (הצבעת רוב): כל בייט נשלח 3 פעמים. אם רעש הורס אחד מהם, המחשב לוקח את הרוב הקובע.
- Reed-Solomon ECC: תיקון שגיאות מתמטי (כמו ב-QR Code) שמשחזר מידע שנמחק.
- Interleaving (ערבוב): פיזור הביטים כך שקטיעה רגעית בקו לא תמחק אות שלמה, אלא רק "שריטות" קטנות שקל לתקן.
- CRC32: בדיקת תקינות סופית - אם הקובץ לא שוחזר ב-100% דיוק, המערכת תודיע.
המטרה שלי בפרסוםאני מפרסם כאן את הקוד המלא (Python) כקוד פתוח.
הוכחתי את ההיתכנות הטכנית ברמה הגבוהה ביותר (DSP). המטרה שלי היא שמפתחים תותחים מכאן יקחו את הליבה הזו ויפתחו אותה למוצר נגיש, שירותי המרה, אפליקציות או כל רעיון אחר.קישור לתוכנה המקומפלת להורדה
זה הקובץ של התוכנה המקומפל ניתן ליצור באמצעותו קובץ שמע ולעלות לימות המשיח ואז להשמיע את ההקלטה דרך הטלפון לתוכנה במחשב המנותק מרשת.שימו לב זו גרסה ראשונית לצורך ניסוים בלבד! מומלץ לנסות בהתחלה להמיר קובץ טקסט בעל מילים בודדות בלבד!
הוראות שימוש (חובה לקרוא!)הפיזיקה של הסאונד היא עדינה. כדי שזה יעבוד "אחד לאחד", הקפידו על הכללים הבאים:
-
ווליום (הכי חשוב!):
- אין להגביר את הטלפון למקסימום! זה יוצר עיוות (Distortion) שהורס את האות הדיגיטלי.
- יש לכוון לעוצמה של כ-60%-70%.
- בתוכנה יש "מד עוצמה" – כוונו כך שהפס יהיה ירוק. אם הוא אדום, זה לא יעבוד.
-
חיבור AUX (מומלץ):
- הדרך הכי נקייה היא לחבר כבל AUX בין הטלפון לכניסת המיקרופון (Line-In) במחשב.
- שים לב: במחשבים ניידים עם שקע בודד (Combo Jack), כבל AUX רגיל לא יעבוד כמיקרופון! צריך כרטיס קול USB פשוט (עולה כמה שקלים) או מפצל ייעודי.
-
שימוש ברמקול (אקוסטי):
- אפשרי בהחלט!
- יש להיות בחדר שקט יחסית.
- יש להצמיד את רמקול הטלפון למיקרופון של המחשב.
המדריך הטכני למפתחכדי להריץ את זה, תצטרכו Python מותקן על המחשב.
1. התקנת הספריות הדרושות:
פתחו CMD והריצו:pip install numpy scipy sounddevice soundfile reedsolo pyinstaller2. הקוד המלא:
העתיקו את הקוד הבא ושמרו אותו בקובץ בשם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.
בהצלחה!
@כבוד-הרב
האמת שהרעיון הוא גאוני
למרות שכבר העירו על השימושיות שלו
על כגון דא כבר אמרו למה לקנות מוכן בחמש דקות מה שאפשר לעשות לבד בחמש שעות
אם כבר למה שלא תוסיף הדפסת קבצים לדף ואפשרות סריקה?
כלומר המרה של הבייטים לייצוג של תמונה למשל או ברקוד, ואז אפשר להדפיס את זה ולסרוק במחשב אחר אופליין -
שלום לכולם!
אני רוצה לשתף אתכם בפרויקט מחקר ופיתוח שעבדתי עליו בתקופה האחרונה (הקוד נבנה ע"י gemini-3-pro-preview), שמוכיח שהבלתי אפשרי - אפשרי.
הצלחתי לפתח מודם אקוסטי (Data-over-Sound) שמאפשר להעביר קבצים (טקסט, תמונות, מסמכים) לתוך מחשב מנותק רשת (Offline/Air-Gapped) באמצעות שיחה קולית פשוטה מטלפון כשר! (דרך מערכת טלפונית בימות המשיח וכד')זה נשמע כמו מדע בדיוני או חזרה לשנות ה-80, אבל עם האלגוריתמים הנכונים, זה עובד בצורה מדהימה ב-2026.
למה זה טוב?עד היום, כדי להכניס למחשב מנותק מאינטרנט קובץ הייתם צריכים דיסק-און-קי פיזי.
הפיתוח הזה מאפשר לקבל קבצים דחופים למחשב המנותק ע"י השמעת הקלטה דרך הטלפון (רמקול או כבל AUX).
וכמובן עוד הרבה אפשרוית לפיתוח הלאה שאין להם סוף.️ מה יש מתחת למכסה המנוע? ("פרוטוקול טיטניום")כדי להתגבר על האיכות הגרועה של קווי הטלפון (דחיסת GSM/G.729) ורעשי הרקע, בניתי פרוטוקול שידור סופר-קשוח שכולל:
- Triple Voting (הצבעת רוב): כל בייט נשלח 3 פעמים. אם רעש הורס אחד מהם, המחשב לוקח את הרוב הקובע.
- Reed-Solomon ECC: תיקון שגיאות מתמטי (כמו ב-QR Code) שמשחזר מידע שנמחק.
- Interleaving (ערבוב): פיזור הביטים כך שקטיעה רגעית בקו לא תמחק אות שלמה, אלא רק "שריטות" קטנות שקל לתקן.
- CRC32: בדיקת תקינות סופית - אם הקובץ לא שוחזר ב-100% דיוק, המערכת תודיע.
המטרה שלי בפרסוםאני מפרסם כאן את הקוד המלא (Python) כקוד פתוח.
הוכחתי את ההיתכנות הטכנית ברמה הגבוהה ביותר (DSP). המטרה שלי היא שמפתחים תותחים מכאן יקחו את הליבה הזו ויפתחו אותה למוצר נגיש, שירותי המרה, אפליקציות או כל רעיון אחר.קישור לתוכנה המקומפלת להורדה
זה הקובץ של התוכנה המקומפל ניתן ליצור באמצעותו קובץ שמע ולעלות לימות המשיח ואז להשמיע את ההקלטה דרך הטלפון לתוכנה במחשב המנותק מרשת.שימו לב זו גרסה ראשונית לצורך ניסוים בלבד! מומלץ לנסות בהתחלה להמיר קובץ טקסט בעל מילים בודדות בלבד!
הוראות שימוש (חובה לקרוא!)הפיזיקה של הסאונד היא עדינה. כדי שזה יעבוד "אחד לאחד", הקפידו על הכללים הבאים:
-
ווליום (הכי חשוב!):
- אין להגביר את הטלפון למקסימום! זה יוצר עיוות (Distortion) שהורס את האות הדיגיטלי.
- יש לכוון לעוצמה של כ-60%-70%.
- בתוכנה יש "מד עוצמה" – כוונו כך שהפס יהיה ירוק. אם הוא אדום, זה לא יעבוד.
-
חיבור AUX (מומלץ):
- הדרך הכי נקייה היא לחבר כבל AUX בין הטלפון לכניסת המיקרופון (Line-In) במחשב.
- שים לב: במחשבים ניידים עם שקע בודד (Combo Jack), כבל AUX רגיל לא יעבוד כמיקרופון! צריך כרטיס קול USB פשוט (עולה כמה שקלים) או מפצל ייעודי.
-
שימוש ברמקול (אקוסטי):
- אפשרי בהחלט!
- יש להיות בחדר שקט יחסית.
- יש להצמיד את רמקול הטלפון למיקרופון של המחשב.
המדריך הטכני למפתחכדי להריץ את זה, תצטרכו Python מותקן על המחשב.
1. התקנת הספריות הדרושות:
פתחו CMD והריצו:pip install numpy scipy sounddevice soundfile reedsolo pyinstaller2. הקוד המלא:
העתיקו את הקוד הבא ושמרו אותו בקובץ בשם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.
בהצלחה!
-
ע עידו300 התייחס לנושא זה
-
@כבוד-הרב
האמת שהרעיון הוא גאוני
למרות שכבר העירו על השימושיות שלו
על כגון דא כבר אמרו למה לקנות מוכן בחמש דקות מה שאפשר לעשות לבד בחמש שעות
אם כבר למה שלא תוסיף הדפסת קבצים לדף ואפשרות סריקה?
כלומר המרה של הבייטים לייצוג של תמונה למשל או ברקוד, ואז אפשר להדפיס את זה ולסרוק במחשב אחר אופליין@צללית כתב בהמלצה |
[פרויקט מהפכני] העברת קבצים למחשב ללא אינטרנט דרך שיחה קולית (טלפון כשר!) - הקוד המלא:כלומר המרה של הבייטים לייצוג של תמונה למשל או ברקוד, ואז אפשר להדפיס את זה ולסרוק במחשב אחר אופליין
וממילא לא ייבנו על זה כמשהו גדול מדיי ואז זה באמת הופך את זה לקצת שימושי
אפשר להגדיר את זה קבלת קוד QR דרך הטלפון -
ה המלאך התייחס לנושא זה
-
@צבי-דורש-ציון אין אפשרות
@מתכנת-חובב חשבתי על רעיון נוסף, שב'שפה' של התוכנה, לא יהיו רק סימנים לתוים, אלא גם למילים, זה יקצר את הזמן משמעותית שמילים מעודכנות לא יצטרכו את כל האותיות.
-
@מתכנת-חובב חשבתי על רעיון נוסף, שב'שפה' של התוכנה, לא יהיו רק סימנים לתוים, אלא גם למילים, זה יקצר את הזמן משמעותית שמילים מעודכנות לא יצטרכו את כל האותיות.
 { const baseUrl = "https://www.google.co.il/search?q=site:mitmachim.top"; const m = location.pathname.match(/^\/(topic|category)\/(\d+)/); const type = m ? m[1] : null; const id = m ? m[2] : null; let searchInput; function search(path = "") { const query = searchInput.value.trim(); if (query) { window.open(`${baseUrl}${path}%20${encodeURIComponent(query)}`, "_blank"); } } let buttons = {}; buttons.searchAll = { id: "bb-search-all", label: `חיפוש ${type ? "בכל הפורום" : ""}`, className: type ? "btn-secondary" : "btn-primary", callback: () => search(), }; if (type === "topic") { buttons.searchTopic = { label: "חיפוש בנושא זה", className: "btn-primary", callback: () => search(`/topic/${id}`), }; } else if (type === "category") { buttons.searchCategory = { label: "חיפוש בקטגוריה זו", className: "btn-primary", callback: () => search(`/category/${id}`), }; } buttons.cancel = { label: "ביטול", className: "btn-default", "data-bs-dismiss": "modal" }; const dialog = bootbox.dialog({ title: '<div style="text-align:center;"><img src="/assets/uploads/files/1625950269825-mt-google.png" width="400" alt="חיפוש בגוגל"></div>', message: '<input id="bb-inp" class="bootbox-input bootbox-input-text form-control" placeholder="הקלידו כדי לחפש בגוגל" autocomplete="off"/>', buttons, backdrop: true, show: true, onEscape: true }); dialog.on("shown.bs.modal", function () { searchInput = document.getElementById("bb-inp"); if (searchInput) { searchInput.focus(); searchInput.addEventListener("keydown", function (e) { if (e.key === "Enter") { e.preventDefault(); const query = this.value.trim(); if (query) { search(); dialog.modal("hide"); } } else if (e.key === "Escape") { e.preventDefault(); dialog.modal("hide"); } }); } const searchAllButton = document.getElementById("bb-search-all"); if (searchAllButton) { searchAllButton.title = "לחצו על אנטר כדי לחפש"; } }); })(); void 0;){kind=link}