{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 18 – Volladdierer und Carry-Ripple-Addierer\n",
    "**Informatik 10 – MINT-Zweig | Informatiksysteme**\n",
    "\n",
    "## Lernziel\n",
    "Ich erläutere den Aufbau und die Funktionsweise eines Volladdierers und skizziere und erläutere einen Carry-Ripple-Addierer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- „Für die Eingangswerte … liefert die Schaltung den Ausgangswert …“\n",
    "- „Der Term/die Tabelle repräsentiert die Schaltung, weil …“\n",
    "- „Die Rückkopplung bzw. Gruppierung bewirkt …“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Merksätze\n",
    "\n",
    "- Ein **Volladdierer** addiert **drei Bits**: die beiden zu addierenden Bits `A` und `B` sowie einen **eingehenden Übertrag** `Cin` aus der vorherigen Stelle. Er liefert die **Summe S** und einen **ausgehenden Übertrag** `Cout`.\n",
    "- Ein Volladdierer lässt sich aus **zwei Halbaddierern und einem OR-Gatter** aufbauen:\n",
    "  1. Halbaddierer 1: `A` und `B` → Zwischensumme `S1` und Übertrag `C1`\n",
    "  2. Halbaddierer 2: `S1` und `Cin` → Summe `S` und Übertrag `C2`\n",
    "  3. `Cout = C1 OR C2`\n",
    "- Ein **Carry-Ripple-Addierer** verkettet mehrere Volladdierer: Der `Cout` einer Stelle wird zum `Cin` der nächsthöheren Stelle. So werden mehrstellige Binärzahlen addiert – der Übertrag \"rieselt\" (englisch: *ripple*) von Stelle zu Stelle durch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🖥️ Praxisteil: Volladdierer in CircuitVerse bauen\n",
    "1. Baut **zwei Halbaddierer** wie in DS 17 (je ein XOR- und ein AND-Gatter).\n",
    "2. Verbindet den Summenausgang des ersten Halbaddierers mit einem Eingang des zweiten Halbaddierers, der zweite Eingang ist `Cin`.\n",
    "3. Verknüpft die beiden Übertrags-Ausgänge (`C1`, `C2`) mit einem **OR-Gatter** → das ist `Cout`.\n",
    "4. Testet alle **8** möglichen Belegungen von `A`, `B`, `Cin` und vergleicht mit der Tabelle unten.\n",
    "\n",
    "**Tipp:** In CircuitVerse gibt es unter *Decoders/Adders* auch fertige \"Full Adder\"-Bausteine – baut den Volladdierer aber **zuerst selbst aus Gattern**, um die Funktionsweise zu verstehen, bevor ihr den fertigen Baustein zum Testen nutzt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🐍 Kontrolle mit Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import product\n",
    "\n",
    "def volladdierer(a, b, cin):\n",
    "    s1 = a != b\n",
    "    c1 = a and b\n",
    "    s = s1 != cin\n",
    "    c2 = s1 and cin\n",
    "    cout = c1 or c2\n",
    "    return int(s), int(cout)\n",
    "\n",
    "for a, b, cin in product([0, 1], repeat=3):\n",
    "    s, cout = volladdierer(a, b, cin)\n",
    "    print(f\"A={a} B={b} Cin={cin} -> S={s} Cout={cout}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übung 1 – 4-Bit Carry-Ripple-Addierer\n",
    "Schreibt eine Funktion `carry_ripple_addierer(a_bits, b_bits)`, die zwei 4-Bit-Zahlen (jeweils als Liste von vier Bits, z. B. `[0,1,0,1]` für `0101`) mithilfe eures `volladdierer` **stellenweise von rechts nach links** addiert und das Ergebnis als 5-Bit-Liste (inkl. abschließendem Übertrag) zurückgibt.\n",
    "\n",
    "**Tipp:** Der `Cin` der niedrigsten Stelle ist `0`. Verarbeitet die Listen von hinten (rechts, niedrigstwertiges Bit) nach vorne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Übung 1 - carry_ripple_addierer(a_bits, b_bits)\n",
    "\n",
    "# Test:\n",
    "# print(carry_ripple_addierer([0,1,0,1], [0,0,1,1]))  # 5 + 3 = 8 -> [0,1,0,0,0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ✏️ Zusatzübung – Carry-Ripple-Addierer zusätzlich skizzieren\n",
    "*Hinweis: Der CircuitVerse-Aufbau und eure Python-Implementierung oben erfüllen die Kompetenz „skizzieren und erläutern\" bereits (grafische bzw. sprachliche, aufs Wesentliche reduzierte Darstellung). Diese Papier-Übung ist freiwillig und dient der zusätzlichen Festigung, z. B. für eine Klassenarbeit ohne Rechner.*\n",
    "\n",
    "Skizziert **freiwillig** (auf Papier oder als Beschreibung in dieser Zelle) das **Blockschaltbild** eines 4-Bit-Carry-Ripple-Addierers: vier Volladdierer-Blöcke nebeneinander, mit den Eingängen `A0..A3`, `B0..B3`, den Summenausgängen `S0..S3` sowie den Pfeilen, die zeigen, wie der `Cout` jeder Stelle zum `Cin` der nächsten Stelle wird. Erläutert in 1–2 Sätzen, warum die Bezeichnung \"Ripple\" (rieseln) passend ist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe\n",
    "Baut in CircuitVerse einen **2-Bit Carry-Ripple-Addierer** aus zwei Volladdierern (bzw. einem Halb- und einem Volladdierer für die niedrigste Stelle) und testet ihn mit mehreren Zahlenpaaren."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  },
  "v3_revision": {
   "basis": "MINT-Lehrplan Informatik 10 (2026)",
   "didaktik": "fragend-entwickelnder Kern, kurzer Transfer, flexible Reserve",
   "lerngruppe": "11 SuS"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
