logic gate.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TODO: \n",
    "* Quine-McCluskey Tabular Method\n",
    "* add -> <=> and other  \n",
    "* make |__|--|__|--| waveform "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, False, True, False, True, False, True, True]\n",
      "[False, True, False, True, False, True, False, False]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[True, True, True, True, True, True, True, True]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Logic:\n",
    "    def __init__(self, in_count, out_count, ty='GATE'):\n",
    "        self.in_count = in_count\n",
    "        self.out_count = out_count\n",
    "        self.type = ty\n",
    "    def name(self):\n",
    "        return self.__class__.__name__\n",
    "    \n",
    "    @staticmethod\n",
    "    def block_diagram(ip, op):\n",
    "        m = min(ip, op)\n",
    "        diff = abs(ip - op)\n",
    "\n",
    "        print(\"    +-----------+    \")\n",
    "        print(\"    |   Block   |    \")\n",
    "        print(\"    |  Diagram  |    \")\n",
    "        for i in range(m):\n",
    "            print(\"--->|           |--->\")\n",
    "        for i in range(diff):\n",
    "            if ip < op:\n",
    "                print(\"    |           |--->\")\n",
    "            else:\n",
    "                print(\"--->|           |    \")\n",
    "        print(\"    |           |    \")\n",
    "        print(\"    |           |    \")\n",
    "        print(\"    +-----------+    \")\n",
    "    \n",
    "    @staticmethod\n",
    "    def binary(n, logic=2):\n",
    "        val = []\n",
    "        n=n\n",
    "        c=0\n",
    "        k=0\n",
    "        for c in range(logic-1, -1, -1):\n",
    "            k = n >> c\n",
    "            if (k & 1):\n",
    "                val.append(1)\n",
    "            else:\n",
    "                val.append(0)\n",
    "        return val\n",
    "    \n",
    "    @staticmethod\n",
    "    def input_gen(in_count):\n",
    "        input_table = []\n",
    "        for i in range(2**in_count):\n",
    "            input_table.append(Logic.binary(i, logic=in_count))\n",
    "        return input_table\n",
    "    \n",
    "    @staticmethod\n",
    "    def truth_table(gate, input_table):\n",
    "        output_table = []\n",
    "        for i in input_table:\n",
    "            if gate.in_count == 1:\n",
    "                try:\n",
    "                    res = gate.operator(i[0])\n",
    "                except:\n",
    "                    res = gate.operator(i)\n",
    "            else:\n",
    "                res = i[0]\n",
    "                for j in i[1:]:\n",
    "                    res = gate.operator(res,j)\n",
    "            \n",
    "            output_table.append(res)\n",
    "\n",
    "        return output_table\n",
    "    \n",
    "    def output(self, ip_list):\n",
    "        if self.in_count == 1:\n",
    "            res = self.operator(ip_list[0])\n",
    "        else:\n",
    "            res = ip_list[0]\n",
    "            for j in ip_list[1:]:\n",
    "                res = self.operator(res,j)\n",
    "\n",
    "        return res\n",
    "\n",
    "class AND(Logic):\n",
    "    def __init__(self, in_count):\n",
    "        super().__init__(in_count, 1)\n",
    "\n",
    "    def operator(self, a, b):\n",
    "        return bool(a and b)\n",
    "    \n",
    "    \n",
    "class OR(Logic):\n",
    "    def __init__(self, in_count):\n",
    "        super().__init__(in_count, 1)\n",
    "\n",
    "    def operator(self, a, b):\n",
    "        return bool(a or b)\n",
    "    \n",
    "    \n",
    "class NOT(Logic):\n",
    "    def __init__(self,):\n",
    "        super().__init__(1, 1)\n",
    "\n",
    "    def operator(self, a):\n",
    "        return bool(not a)\n",
    "\n",
    "\n",
    "\n",
    "class NAND(Logic):\n",
    "    def __init__(self, in_count):\n",
    "        super().__init__(in_count, 1)\n",
    "\n",
    "    def operator(self, a, b):\n",
    "        return bool(not(a and b))\n",
    "    \n",
    "class NOR(Logic):\n",
    "    def __init__(self, in_count):\n",
    "        super().__init__(in_count, 1)\n",
    "\n",
    "    def operator(self, a, b):\n",
    "        return bool(not(a or b))\n",
    "    \n",
    "class XOR(Logic):\n",
    "    def __init__(self, in_count):\n",
    "        super().__init__(in_count, 1)\n",
    "\n",
    "    def operator(self, a, b):\n",
    "        return bool(((not a) and b) or (a and (not b)))\n",
    "    \n",
    "class XNOR(Logic):\n",
    "    def __init__(self, in_count):\n",
    "        super().__init__(in_count, 1)\n",
    "\n",
    "    def operator(self, a, b):\n",
    "        return bool(not(((not a) and b) or (a and (not b))))\n",
    "    \n",
    "class TRUE(Logic):\n",
    "    def __init__(self,):\n",
    "        super().__init__(1, 1, ty='INPUT')\n",
    "\n",
    "    def operator(self, a=1):\n",
    "        return True\n",
    "    \n",
    "class FALSE(Logic):\n",
    "    def __init__(self,):\n",
    "        super().__init__(1, 1, ty='INPUT')\n",
    "\n",
    "    def operator(self, a=0):\n",
    "        return False\n",
    "    \n",
    "class LED(Logic):\n",
    "    def __init__(self,):\n",
    "        super().__init__(1, 1, ty='OUTPUT')\n",
    "        \n",
    "    def operator(self, a):\n",
    "        return bool(a)\n",
    "    \n",
    "    \n",
    "op1 = Logic.truth_table(NAND(3), Logic.input_gen(3))\n",
    "op2 = Logic.truth_table(NOT(), Logic.truth_table(NAND(3), Logic.input_gen(3)))\n",
    "print(op1)\n",
    "print(op2)\n",
    "Logic.truth_table(XOR(2), zip(op1, op2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "class Circuit:\n",
    "    def __init__(self, label, gate):\n",
    "        self.dot_code = ''\n",
    "        self.label = label\n",
    "        self.gate = gate\n",
    "        self.logic_output = []\n",
    "        self.logic_input = []\n",
    "    \n",
    "\n",
    "    def tree(self, depth=0):\n",
    "        for logic_gate in self.logic_input:\n",
    "            logic_gate.tree(depth=depth+1)\n",
    "        \n",
    "        for op in self.logic_output:\n",
    "            print(self.label + '->'+op.label )\n",
    "    def output(self):\n",
    "#         print(self.gate.name())\n",
    "        chield_op = []\n",
    "        if self.gate.type == 'INPUT':\n",
    "            return self.gate.operator()\n",
    "        if self.logic_input ==[]:\n",
    "            raise ValueError(\"Input missing\")\n",
    "        for logic_gate in self.logic_input:\n",
    "            chield_op.append(logic_gate.output())\n",
    "        return self.gate.output(chield_op)\n",
    "    \n",
    "    def inlink(self, gate, logic_input):\n",
    "        self.dot_code = self.dot_code + '\\n' + gate.label+'[label=\"'+gate.gate.name()+'('+gate.label+')\", shape=box]'\n",
    "        self.dot_code = self.dot_code + '\\n' + logic_input.label+'[label=\"'+logic_input.gate.name()+'('+gate.label+')\", shape=box]'\n",
    "        self.dot_code = self.dot_code + '\\n' + logic_input.label+'->'+gate.label\n",
    "        gate.logic_input.append(logic_input)\n",
    "        logic_input.logic_output.append(gate)\n",
    "\n",
    "logic1 = Circuit('IN1', TRUE())\n",
    "logic2 = Circuit('IN2', TRUE())\n",
    "logic_and = Circuit('C', AND(2))\n",
    "logic_xor = Circuit('D', XOR(2))\n",
    "logic_xor1 = Circuit('E', XOR(2))\n",
    "logic_xor2 = Circuit('F', XOR(2))\n",
    "logic_xor3 = Circuit('G', XOR(2))\n",
    "logic_xor4 = Circuit('H', XOR(2))\n",
    "logic_led = Circuit('LED', LED())\n",
    "\n",
    "logic_led.inlink(logic_and, logic1)\n",
    "logic_led.inlink(logic_and, logic2)\n",
    "logic_led.inlink(logic_xor, logic2)\n",
    "logic_led.inlink(logic_xor1, logic_and)\n",
    "logic_led.inlink(logic_xor3, logic_xor2)\n",
    "logic_led.inlink(logic_xor3, logic_xor)\n",
    "logic_led.inlink(logic_xor2, logic1)\n",
    "logic_led.inlink(logic_xor1, logic2)\n",
    "logic_led.inlink(logic_xor2, logic_and)\n",
    "logic_led.inlink(logic_xor, logic_xor1)\n",
    "logic_led.inlink(logic_led, logic_xor)\n",
    "logic_led.inlink(logic_led, logic_xor3)\n",
    "\n",
    "# logic_led.tree()\n",
    "\n",
    "print(logic_led.output())\n",
    "\n",
    "code = \"digraph {\" + logic_led.dot_code + '\\n}'\n",
    "\n",
    "f = open(\"tmp\", 'w+')\n",
    "f.write(code)\n",
    "f.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os\n",
    "os.system(\"dot -Tpng tmp > output.png\")\n",
    "\n",
    "from IPython.display import display, Image\n",
    "display(Image(filename='output.png'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    +-----------+    \n",
      "    |   Block   |    \n",
      "    |  Diagram  |    \n",
      "--->|           |--->\n",
      "--->|           |--->\n",
      "--->|           |--->\n",
      "--->|           |--->\n",
      "--->|           |--->\n",
      "    |           |--->\n",
      "    |           |--->\n",
      "    |           |--->\n",
      "    |           |--->\n",
      "    |           |--->\n",
      "    |           |    \n",
      "    |           |    \n",
      "    +-----------+    \n"
     ]
    }
   ],
   "source": [
    "Logic.block_diagram(5,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}