Eine Sonnenbrille die einen digitalen Hut abbildet, die zusätzlich zu den Gläsern über einen Laserstrahl einen Hut formt. Dieser digitaler Hut formt einen künstlichen schatten über dem gesicht. der vor der Sonne schützt. die sonnenstrahlen werden von dem laser abgefiltert oder „abgeschnitten“.

WENN WIR UNS AM PUNKT X1 TREFFEN BRAUCHEN WIR DIE DEFINITION DER ZEIT NICHT SONDERN NUR Die des Raumes, DENN DIE ERDE BEWEGT SICH KONSTANT IN einem GITTER aus punkten. Wir TREFFEN UNS AM PUNKT X1 im Gitter des Universums, wird ausreichen um den PUNKT zu treffen, denn die erde bewegt sich im gitter. punkt für punkt. WENN WIR UNS AM PUNKT X1 TREFFEN BRAUCHEN WIR DIE DEFINITION DER ZEIT NICHT SONDERN NUR die des Raumes RAUM DENN DIE ERDE BEWEGT SICH KONSTANT IN DEM GITTER. Wir haben zwei Koordinatensysteme: Koordinatensystem der Erde K_erde, Koordinatensystem des Universums K_Univ. WEnn wir einen Treffpunkt an der Erdoberfläche in Relation zum Koordinaten System der Erde vereinbaren und dieser PUnkt mit dem Trefpunkt der erde im Universum zusammentrifft braucht man die Zeit nicht. Mann kann den genauen Treffpunkt bestimmen ohne die Zeitangabe, nur durch die entfernung. Wenn TreffPunkt(Koord_Erde)= TreffPUnkt(Koord_Univers.)>>> dann dort trift man sich dort. Dieser Punkt macht die Zeitangabe überflüssig

Verkehrsampeln die miteinander vernetzt sind und in einem Navigationsgeraet abgebildet werden zusammen mit ihrem Status. Auch die Dauer des ampel Status soll auf dem Navi abgebildet werden. Die fzg wissen über das Navigatomionssystem wann die Ampel rot ist und stoppen automatisch.

Step 1 – Schaltung Raspberry

Step 2 – Zwischenergebnis

#Bibliotheken einbinden

import pymysql
import RPi.GPIO as GPIO
import time
import json
import rel
import websocket

#GPIO Modus (BOARD / BCM)

GPIO.setmode(GPIO.BCM)

#Warnungen ausschalten

GPIO.setwarnings(False)

#GPIO Pin Belegung

ROT = 4
GELB = 17
GRUEN = 27
TASTER = 22

#Richtung der GPIO-Pins festlegen (IN / OUT)

GPIO.setup(ROT, GPIO.OUT) #rot
GPIO.setup(GELB, GPIO.OUT) #gelb
GPIO.setup(GRUEN, GPIO.OUT) #gruen
GPIO.setup(TASTER, GPIO.IN) #Taster

#In die Database verbinden.

connection = pymysql.connect(host=’xxx.xxx.xxx.xxx‘,
user=’tabellenuser‘,
password=’passwort‘,
db=’tabellenname‘,
charset=’utf8mb4′,
cursorclass=pymysql.cursors.DictCursor)
print („connect successful!!“)

#In die DB Tabelle einfügen

def einfuegen(rot,gelb,gruen,taster):

#try:

      cursor=connection.cursor()
      sqlPhase =  "Insert into ispx_Ampel (ROT, GELB, GRUEN, TASTER) values (%s, %s, %s, %s)"
      # sql implementieren und 3 Parameter anweisen
      cursor.execute(sqlPhase,(rot,gelb,gruen,taster))
      connection.commit()

#finally:

      # Die Verbindung schließen (Close connection).
      # connection.close()

#Websockets

def on_error(ws, error):
print(error)

def on_close(ws, close_status_code, close_msg):
print(„### closed ###“)

def on_open(ws):
print(„Opened connection“)

def on_message(ws, message):
#data = json.loads(message)
cursor = connection.cursor()
cursor.execute(„SELECT * FROM ispx_Ampel ORDER BY ID DESC LIMIT 1“)
for row in cursor:
print(row)
umschalten()

if name == „main„:
websocket.enableTrace(True)
ws = websocket.WebSocketApp(„wss://name.domain.com:port“, on_open=on_open, on_message=on_message, on_error=on_error, on_close=on_close)
ws.run_forever(dispatcher=rel) # Set dispatcher to automatic reconnection, 5 second re>
rel.signal(2, rel.abort) # Keyboard Interrupt
rel.dispatch()

#Umschaltung definieren

def umschalten():
#Phase 2
GPIO.output(ROT, True)
GPIO.output(GELB, True)
GPIO.output(GRUEN, False)
einfuegen(1,1,0,0)
event = {
„Rot“: 1,
„Gelb“: 1,
„Gruen“: 0,
„Taster“: 0,
}
ws.send(json.dumps(event))
time.sleep(2)
#Phase 3
GPIO.output(GRUEN, True)
GPIO.output(ROT, False)
GPIO.output(GELB, False)
einfuegen(0,0,1,0)
event = {
„Rot“: 0,
„Gelb“: 0,
„Gruen“: 1,
„Taster“: 0,
}
ws.send(json.dumps(event))
time.sleep(15)
#Phase 4
GPIO.output(GELB, True)

GPIO.output(GRUEN, False)
einfuegen(0,1,0,0)
event = {
„Rot“: 0,
„Gelb“: 1,
„Gruen“: 0,
„Taster“: 0,
}
ws.send(json.dumps(event))
time.sleep(3)
#zurueck zu Phase 1
GPIO.output(ROT, True)
GPIO.output(GELB, False)
einfuegen(1,0,0,0)
event = {
„Rot“: 1,
„Gelb“: 0,
„Gruen“: 0,
„Taster“: 0,
}
ws.send(json.dumps(event))

#Endlosschleife

while True:
#Phase 1
GPIO.output(ROT, True)
GPIO.output(GELB, False)
GPIO.output(GRUEN, False)

#Status des Tasters einlesen
tasterStatus = GPIO.input(TASTER)
if (tasterStatus):
    on_message(ws, "hallo")

umschalten()

Die Welt der Antigesetze: Wir leben im Jahr 2083 in einer Welt in der die vollständige Meinungsfreiheit gilt und völlige Handelsfreiheit erlaubt ist. Im Jahr 2066 hat nach der 7en Weltwirtschaftskrise, die Handlungsglobalisierung begonnen. Im Jahre 2050 wurde den 17 stärksten Ländern der Welt, die allgemeine Währung „PANGO“ beschlossen. Dieses Abkommen wurde „Das Handelsabkommen von Xanthi“ Griechenlands genannt. Die Globale Währung „PANGO“ kam somit für die damals stärksten Länder der Welt zutragen: Griechenland, Türkei, Europa und USA. Mittlerweile gibt es nur ein Land auf der Welt. Die Eurozone hat sich mit den USA verbunden. Später kam China dann schließlich Asien hinzu. Die Globalisierung war am 26.03.2050 geschehen. Der Griechische Premierminister „Pantokratis“ hat die Vereinigung der Pankratischen Union (PU) abgeschlossen. Nach dem Zerfall der Währung „PANGO“ am 11.11.3013 gab es temporär die Abschaffung von Gesetzten, 3069 wurde mit der Einführung von Antigesetzen vereinbart und somit eine neue Ära geschaffen. Antigesetzte, das sind Gesetzte die Straftaten mit Einholung einer Genehmigung zulassen. Anhand des Einkommens eines Menschen ist es erlaubt den Antrag stattzugeben. Zuvor illegale Handlungen können somit legal durchgeführt werden. So kann ein reicher Mensch der über die finanziellen Mittel verfügt zu einer Behörde gehen und einen Antrag auf Vollstreckung stellen in dem er z.B. den Tot eines Menschen „XY“ beantragt. Mit dieser Lizenz bittet er um die Berechtigung das Vorhaben zu erledigen. Die Behörde legt seine Entscheidung im Rahmen eines Preises fest. Der potentielle Vollstrecker zahlt den Vereinbarten Preis und das Vorhaben wird antigesetzlich genehmigt.

Ein kleiner Papierdrucker der im Handy integriert ist.

eine Rechtsanwaltapp die anhand einer Paragraphen KI sie rolle des Rechtsanwalts in einem Gericht übernimm und einen realen Rechtsanwalt ersetzetz.

Ein Gerät baust, das digitale Lieder aus der Cloud analog abspielt, mit einem Retro- oder futuristischen Design.

🔧 Was du brauchst:

Hardware:

• Raspberry Pi (z. B. Modell 4)
• DAC (Digital-Analog-Converter) – z. B. HifiBerry DAC+
• Verstärkerplatine (z. B. PAM8403 oder ähnliches)
• Lautsprecher (kleine Breitbandlautsprecher)
• Gehäuse – Retro oder futuristisch selbst gestalten oder aus einem alten Radio basteln
• Drehknöpfe, Schalter, LEDs für Bedienung
• Netzteil für den Pi und den Verstärker

Software:

• Raspberry Pi OS
• MPD (Music Player Daemon) oder Volumio
• Verbindung zur Cloud (z. B. Spotify, YouTube Music, eigene Nextcloud o.ä.)
• Optional: Python-Skripte für Tasten, Knöpfe, Displaysteuerung

---

🛠️ Schritt-für-Schritt-Anleitung:

1. Raspberry Pi vorbereiten

• Raspberry Pi OS auf SD-Karte installieren
• WLAN einrichten, SSH aktivieren

2. DAC und Lautsprecher anschließen

• HifiBerry DAC+ auf den GPIO-Port stecken
• Lautsprecher über Verstärker an DAC anschließen

3. MPD oder Volumio einrichten

• MPD (Music Player Daemon):
  • Installieren: bashKopierenBearbeitensudo apt install mpd mpc
  • Konfigurieren (/etc/mpd.conf): Audio-Output auf DAC stellen
• ODER:
  • Volumio flashen – das ist ein fertiges Musiksystem mit Webinterface und Spotify-Plugin

4. Cloud-Musik integrieren

• Spotify:
  • Über Volumio Plugin oder librespot (open-source Spotify Connect)
• Eigene MP3s aus Nextcloud/Dropbox synchronisieren (z. B. mit rclone)
• Oder YouTube-Audio mit youtube-dl streamen (rechtliche Nutzung beachten!)

5. Bedienung analog gestalten

• Taster/Knöpfe anschließen an GPIOs
• Python-Skript schreiben, das z. B. bei Knopfdruck mpc next ausführt
• Analoge Anzeigen: z. B. VU-Meter per PWM/Spannung steuern

6. Gehäuse bauen

• Retro: altes Radio ausschlachten, Pi + DAC + Lautsprecher reinbauen
• Futuristisch: mit 3D-Druck oder Acrylplatten + LED-Streifen

---

🧪 Bonus: OLED- oder LCD-Display

• Einbauen, z. B. 128×64 OLED
• Musik-Info anzeigen per Python (mpc current oder Spotify API)
• Holografischer Look mit halbtransparentem Acryl + Hintergrund-LEDs

---

🧰 Beispielskript (Knopf für „Nächster Song“)

pythonKopierenBearbeitenimport RPi.GPIO as GPIO
import subprocess
import time

BUTTON_PIN = 17
GPIO.setmode(GPIO.BCM)
GPIO.setup(BUTTON_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)

while True:
    if GPIO.input(BUTTON_PIN) == GPIO.LOW:
        subprocess.run(["mpc", "next"])
        time.sleep(0.5)

---

📦 Optional: Alles in Docker packen

Damit du dein Setup überall wiederverwenden kannst – inkl. automatischer Updates und Konfiguration.

---

Folgt eine konkrete Bauanleitung mit Schaltplan, Gehäuse-Idee und Code als PDF oder Markdown-Doku zusammenstellen. Sag

Darin enthalten sind:

• Hardware-Liste
• Schaltungsaufbau
• Software-Konfiguration
• Cloud-Integration
• Gehäuseideen (Retro & Futuristisch)
• Beispielcode zur Steuerung

Wenn du auch eine Markdown-Version oder eine detaillierte Zeichnung des Schaltplans brauchst, sag einfach Bescheid!

Du:

Die detaillierte Zeichnung eines Schaltplans

Hier ist der detaillierte Schaltplan für dein Cloud-Musik-Analoggerät:

Er zeigt:

• Den Anschluss des DAC an den Raspberry Pi
• Die Verbindung zum Verstärker und Lautsprecher
• Taster (z. B. für Steuerung)
• OLED-Display über I2C

eine moderne Brille die eine rückwärts Kameras hat und man damit nach hinten schauen kann?

Video

**Werde Maler –
zeichne mit Worten die Welt,
male Bilder aus Licht und Gefühl.
Werde Arzt –
heile die Wunden deiner Seele,
leg sanft die Hände auf dein Innerstes.
Werde Astronaut –
steig empor, berühre die Sterne,
lass deine Gedanken fliegen.
Werde Archäologe –
grabe tief in der Zeit,
finde die Scherben deines Ursprungs.
Werde ein Spatz –
klein, mutig, auf der Suche nach Leben.
Werde ein Marienkäfer –
rot, leise, ein Zeichen des Glücks.
Werde ein kleines Gebäck –
zart, süß, mit dem Duft der Kindheit.
Werde weich,
werde du selbst –
denn im Spiegel der anderen
verlierst du dich.

Bleib in deinem eigenen Garten,
nahe deiner Kraft.
Erkenne, was in dir wächst,
suche dein Wort,
suche dein Wesen.
Werde eins mit deinem Geist.

Feg die Nacht hinweg mit dem Licht des Tages,
reinig deine Seele mit dem Schweiß deiner Mühe.**

Ein Fotoalbum soll sowohl fotos abbilden als auch videos abspielen können. Das Display soll nicht dicker sein als die dicke eines DINA4 Papierblatts.

Ein solches „hybrides“ Fotoalbum, das Fotos und Videos auf einer Papierseite vereint, ist technisch anspruchsvoll, aber mit heutiger Technik realisierbar. Hier ist eine Übersicht, wie du ein solches Album bauen könntest, inklusive einer möglichen Bauanleitung.

---

🔧 Ziel

Ein aufgeklapptes Fotoalbum mit:

• Linker Seite: normale Fotoabzüge.
• Rechter Seite: sehr dünnes Display, das wie Papier wirkt, zur Videowiedergabe (z. B. über Knopfdruck).

---

📦 Materialliste

1. E-Paper Display mit Video-Funktion(selten, siehe Alternativen unten)
   • Alternative 1: OLED-Display (z. B. 3–5 Zoll) mit sehr geringer Bauhöhe (1–2 mm).
   • Alternative 2: TFT-Display mit eingebettetem Videochip (wie bei Videogrußkarten).
2. Microcontroller (z. B. ESP32 oder Raspberry Pi Zero)
   • zum Abspielen von Videos von microSD.
3. Lithium-Polymer-Akku (3.7 V, 500–1000 mAh)
   • wiederaufladbar, flach.
4. Drucktaster oder Näherungssensor
   • um Videos zu starten/pausieren.
5. Lautsprecher (Mini, 1–2 W)
   • für Ton (optional).
6. microSD-Karte
   • zum Speichern der Videos.
7. Verkabelung / Flachbandkabel
   • für die Strom- und Datenleitungen im Albumrücken.
8. Album mit Hohlraum
   • selbst gebaut oder angepasst, mit verstecktem Fach im Rücken für Elektronik.

---

🛠️ Bauanleitung (Vereinfacht)

1. Design vorbereiten

• Skizziere den Aufbau: linke Seite für Fotos, rechte Seite mit Displayöffnung.
• Displaygröße z. B. 2″–4″ (5–10 cm Diagonale) wählen.

2. Elektronik montieren

• Microcontroller, Akku und microSD in den Buchrücken einbauen.
• Display in die rechte Seite der Buchseite einsetzen (muss mit Cutter ausgeschnitten werden).
• Alles mit Flachbandkabeln verbinden (unter Papier oder Karton).

3. Display integrieren

• Display hinter eine transparente, matte Folie oder dünne PVC-Schicht einlassen → wirkt wie Papier.
• Display und Abdeckung dürfen zusammen <3 mm dick sein.

4. Software aufspielen

• Bei ESP32: mit Arduino IDE programmieren.
• Videos als MP4/AVI konvertieren und in Schleife abspielen lassen.

5. Auslöser montieren

• Knopf oder Sensor in Seite integrieren, mit Display verknüpfen → Video startet bei Aufklappen oder Knopfdruck.

6. Aufladen ermöglichen

• Ladebuchse (z. B. USB-C) im Rücken oder rückseitig verstecken.

---

📺 Geeignete Displays

Display-Typ	Vorteile	Nachteile
OLED (1–5″)	Superdünn, hohe Qualität, leicht verfügbar	Höherer Stromverbrauch
TFT mit integriertem Videoplayer (wie Grußkarten-Displays)	Komplettpaket, spielt MP4 direkt ab	Wenig anpassbar
Flexible E-Paper mit Video (z. B. eink + Video)	Extrem dünn, papiertypisch	Teuer, schwer erhältlich

🔍 Tipp: Bei Plattformen wie AliExpress, Amazon, oder Digikey findest du OLED/TFT-Module mit Player-Funktion.

---

🧠 Bonus-Ideen

• Automatischer Start beim Öffnen durch Reed-Schalter + Magnet.
• Touchfläche statt Button.
• Mehrere Seiten mit je einem Display (jeweils nur eine Seite aktiv).

Hier siehst du das konkrete Schaltbild für den Einbau in den Buchrücken deines Video-Fotoalbums:

🔍 Erklärung der Komponenten

• ESP32 oder Raspberry Pi Zero: Steuert das Video, liest von microSD.
• LiPo-Akku: Flacher Akku für die Stromversorgung.
• microSD-Karte: Hält die Videodateien.
• OLED-Display (2–4″): Dient als ultradünner Video-Bildschirm.
• Start-Button: Aktiviert das Abspielen eines Videos.
• Verkabelung: Verbindet alle Elemente unsichtbar unter dem Seitenmaterial oder im Buchrücken.

Anbei:

• eine konkrete Bauteilliste mit Modellvorschlägen
• oder ein einfaches Beispielprogramm (Arduino Code)

CPP

include

include

include

include

include

define TFT_CS 15

define TFT_DC 2

define TFT_RST 4

define SD_CS 5

define BUTTON_PIN 12

Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);

bool playing = false;

void setup() {
pinMode(BUTTON_PIN, INPUT_PULLUP);
Serial.begin(115200);

tft.begin();
tft.fillScreen(ILI9341_BLACK);

if (!SD.begin(SD_CS)) {
tft.setCursor(10, 10);
tft.setTextColor(ILI9341_RED);
tft.setTextSize(2);
tft.print(„SD init failed!“);
while (1);
}
}

void loop() {
if (digitalRead(BUTTON_PIN) == LOW && !playing) {
playing = true;
playVideo();
playing = false;
}
}

void playVideo() {
char filename[32];

for (int i = 1; i <= 100; i++) {
sprintf(filename, „/frame%04d.jpg“, i);
if (!SD.exists(filename)) break;

drawJPEG(filename);
delay(33);  // ~30 fps

}
}

void drawJPEG(const char *filename) {
JpegDec.decodeSdFile(filename);
uint16_t w = JpegDec.width;
uint16_t h = JpegDec.height;

while (JpegDec.read()) {
uint16_t *pImg = JpegDec.pImage;
uint16_t x = JpegDec.x;
uint16_t y = JpegDec.y;
uint16_t sx = JpegDec.MCUx * JpegDec.MCUWidth + x;
uint16_t sy = JpegDec.MCUy * JpegDec.MCUHeight + y;

for (uint16_t i = 0; i < JpegDec.MCUWidth; i++) {
  for (uint16_t j = 0; j < JpegDec.MCUHeight; j++) {
    if ((sx + i) < tft.width() && (sy + j) < tft.height()) {
      uint16_t color = pImg[j * JpegDec.MCUWidth + i];
      tft.drawPixel(sx + i, sy + j, color);
    }
  }
}

}
}
🗂️ Dateien auf SD-Karte
/frame0001.jpg bis /frame0100.jpg (Video-Frames)

Bilder sollten 320×240 px sein (oder passend zum Display)

Wenn du lieber ein Display mit integriertem Videoplayer-Modul verwendest (z. B. von AliExpress: „TFT Video Module MP4 Decoder“), brauchst du nur GND, VCC und PLAY PIN – dann schreibe ich dir gerne dafür den einfacheren Code.