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

[CSS 0]

@כבוד-הרב זה לא מחובר לשום קו כל שהוא כדי שהוא לשלוח קבצים דרכו

[כבוד הרב]

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

[CSS 0]

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

[כבוד הרב]

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

[CSS 0]

@כבוד-הרב זה יהיה טוב עם זה יהיה מחובר לקו של ה"מנהל" הוא יוכל לעלות לקו דברים, והמשתמשים יוכלו להפעיל אצליהם במחשב שרת שיוריד למחשב את מה שהמנהל העלה
אבל זה ידרוש אינטרנט
כדי להפעיל שרת ngrok

[כבוד הרב]

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

[MGM IVR]

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

יצא לך בטסטים לבדוק כמה לוקח קובץ של 1 מגה להעביר?

[כבוד הרב]

@MGM-IVR האמת היא שקובץ שמכיל את המילה "שלום" בלבד הומר לקובץ שמע של 31 שניות שזה המון.
אבל חלק ממה שגורם לזה זה זה שהוא מכפיל כל צליל כפול 3 כדי לעשות השוואה אבל לדעתי אפשר לשפר את זה שלא יצתרכו את זה אלא זה יעשה את זה בצורה חכמה הרבה יותר וכן יותר לדחוס את זה
ובשביל זה אני מחכה לתותחים כאן
מצו"ב הקובץ המומר של המילה "שלום"
1.wav

[כבוד הרב]

@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()

[MAKRO]

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

[כבוד הרב]

@MAKRO אהבתי!

Spoiler

אבל אני לא יודע אם שמעת אבל יש אנשים כאן בארץ שלא מחוברים לרשת והם גם צרכים כאלה דברים

[MGM IVR]

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

מצו"ב הקובץ המומר של המילה "שלום"
1.wav

מזכיר מאוד פקס

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

שם המילה "שלום" הומרה לפחות מ-14 שניות שמע.

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

[מוח קודח]

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

[phpman]

זה באמת משהו חמוד אבל זה כל כך ריאלי יותר מכמה מילים בודדות (שאת זה אפשר לומר לו להקליד לבד)
(בהתיעצות עם צ׳אט ג׳י פי טי )
קובץ של 100kb - טופס פשוט יקח כ24 שעות רצופות
ומי מדבר על איזה עלון כמו שמישהו הציע שזה באיזור ה1MB יקח בערך כ-10 ימים של שיחה רצופה
אגב צ׳אט ג׳י פי טי הציע שתי כיוונים מעט שונים

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

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

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

[מתכנת חובב]

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

[צדיק תמים]

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

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

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

[מתכנת חובב]

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

[שמעון פרידנן]

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

[מתכנת חובב]

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

[AVIVI]

@כבוד-הרב מטורף!
פשוט אין מילים

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

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

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

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

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