matty/20180430a/20180430a-Server.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `20180430a` - JSON Server - version p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python2.7/dist-packages/matplotlib/__init__.py:1314: UserWarning:  This call to matplotlib.use() has no effect\n",
      "because the backend has already been chosen;\n",
      "matplotlib.use() must be called *before* pylab, matplotlib.pyplot,\n",
      "or matplotlib.backends is imported for the first time.\n",
      "\n",
      "  warnings.warn(_use_error_msg)\n"
     ]
    }
   ],
   "source": [
    "#!/usr/bin/python\n",
    "import spidev\n",
    "import RPi.GPIO as GPIO\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import json\n",
    "import time\n",
    "\n",
    "matplotlib.use('Agg')\n",
    "\n",
    "BigJS0N = {}\n",
    "BigJS0N[\"firmware_md5\"]=\"49ed003fae3a312590fe99a2fa90392c\"\n",
    "BigJS0N[\"firmware_version\"]=\"p\"\n",
    "BigJS0N[\"data\"]=[]\n",
    "BigJS0N[\"registers\"]={}\n",
    "BigJS0N[\"parameters\"]={}\n",
    "\n",
    "def CreateDACCurve(Deb,Fin,CurveType):\n",
    "    n = 200/5\n",
    "    DACValues = []\n",
    "    for k in range(n+1):\n",
    "        if CurveType:\n",
    "            val = int(Deb+1.0*k*(Fin-Deb)/n)\n",
    "        else:\n",
    "            val = int((Fin-Deb)*k**3/n**3+Deb)\n",
    "        DACValues.append(val) \n",
    "    DACValues[-1] = 0\n",
    "    DACValues[-2] = 0\n",
    "    return DACValues,len(DACValues)\n",
    "    \n",
    "    \n",
    "def SetDACCurve(spi,DACValues):\n",
    "    if len(DACValues) < 43: # to correct\n",
    "        for i in range(len(DACValues)):\n",
    "            if (DACValues[i] >= 0) and (DACValues[i] < 1020):\n",
    "                WriteFPGA(spi,16+i,DACValues[i]/4)\n",
    "            else:\n",
    "                 WriteFPGA(spi,16+i,0)\n",
    "            #print 16+i,len(DACValues)\n",
    "    return 0\n",
    "\n",
    "def WriteFPGA(spi,adress,value):\n",
    "    spi.xfer([0xAA] )\n",
    "    spi.xfer([adress] )\n",
    "    spi.xfer([value] )\n",
    "    BigJS0N[\"registers\"][int(adress)]=value\n",
    "    \n",
    "def StartUp():\n",
    "    GPIO.setmode(GPIO.BCM)\n",
    "    PRESET = 25\n",
    "    IO4 = 26\n",
    "    GPIO.setup(PRESET,GPIO.OUT)\n",
    "    GPIO.setup(IO4,GPIO.IN, pull_up_down=GPIO.PUD_DOWN)\n",
    "    print \"Reset 25 - Low 1s\"\n",
    "    GPIO.output(PRESET,GPIO.LOW)\n",
    "    time.sleep(3)\n",
    "    print \"Reset 25 - High 0.2s\"\n",
    "    GPIO.output(PRESET,GPIO.HIGH)\n",
    "    time.sleep(0.2)\n",
    "\n",
    "    spi = spidev.SpiDev()\n",
    "    spi.open(0,1) # CS2 - FPGA, on CE1 = IO4\n",
    "    spi.mode = 0b01\n",
    "    print \"spi.cshigh is \" + str(spi.cshigh)\n",
    "    print \"spi mode is \" + str(spi.mode)\n",
    "    spi.max_speed_hz = 2000000\n",
    "    print \"spi maxspeed is \"+str(spi.max_speed_hz)+\"hz\"\n",
    "    return spi\n",
    "\n",
    "def TestSPI(spi,ncycles):\n",
    "    i = 0\n",
    "    while i < ncycles:\n",
    "        WriteFPGA(spi,0xEB,0x01) # 0: single mode 1 continious mode\n",
    "        time.sleep(0.5)\n",
    "        WriteFPGA(spi,0xEB,0x00) # 0: single mode 1 continious mode\n",
    "        time.sleep(0.5)  \n",
    "        i = i+1\n",
    "\n",
    "def LoopSPI(spi):\n",
    "    while 1:\n",
    "        WriteFPGA(spi,0xEB,0x01) # 0: single mode 1 continious mode\n",
    "        WriteFPGA(spi,0xEB,0x00) # 0: single mode 1 continious mode\n",
    "\n",
    "def LoopAcq(spi):\n",
    "    while 1:\n",
    "        WriteFPGA(spi,0xEB,0x00) # Doing 1 shot \n",
    "        WriteFPGA(spi,0xEF,0x01) # Cleaning memory pointer\n",
    "        WriteFPGA(spi,0xEA,0x01) # Software Trig : As to be clear by software\n",
    "        time.sleep(0.001) # sleep 1ms\n",
    "    \n",
    "def ClearMem(spi):\n",
    "    WriteFPGA(spi,0xEF,0x01) # To access memory\n",
    "\n",
    "def ConfigSPI(spi):\n",
    "    # Setup FPGA values by default\n",
    "    setPon(200,spi)              # Set PulseOn\n",
    "    setPulsesDelay(100,spi)      # Set Lengh between Pon and Poff: 100ns\n",
    "    setPoff(2000,spi)            # Setting Poff 2us\n",
    "    #setDACConstant(20,spi)   # gain at 20mV (2%)\n",
    "    WriteFPGA(spi,0xEC,0x33)\n",
    "    setDeltaAcq(7000,spi)    # 7us\n",
    "    #WriteFPGA(spi,0xEA,0x00) # Software Trig : As to be clear by software\n",
    "    WriteFPGA(spi,0xEB,0x00) # 0: single mode 1 continious mode\n",
    "    WriteFPGA(spi,0xED,0x03) # Frequency of ADC acquisition / sEEADC_freq (3 = 16Msps, 1 = 32, 0 = 64, 2 = 21Msps)\n",
    "    WriteFPGA(spi,0xEE,0xA0) # How many cycles in countinious mode\n",
    "    print \"Config FPGA done!\"\n",
    "\n",
    "def setDACConstant(mV,spi):\n",
    "    if mV > 1000:\n",
    "        mV = 1000\n",
    "    elif mV < 0:\n",
    "        mV = 0   \n",
    "    hmV = mV/4\n",
    "    print \"Gain:\", mV,\" mV -- \",hex(hmV)\n",
    "    WriteFPGA(spi,0xEC,hmV) # Voltage gain control: 0V to 1V\n",
    "    \n",
    "def setPon(POn,spi):\n",
    "    if POn > 2500:\n",
    "        POn = 2500\n",
    "    elif POn < 0:\n",
    "        POn = 0\n",
    "    HPon = POn* 128 / 1000\n",
    "    BigJS0N[\"parameters\"][\"Pon\"] = int(POn)\n",
    "    print \"Pulse width:\", POn,\" ns -- \",hex(HPon)\n",
    "    WriteFPGA(spi,0xE0,HPon) # set sEEPon\n",
    "    \n",
    "def setPulsesDelay(DeltaPP,spi):\n",
    "# Set Lengh between Pon and Poff\n",
    "    if DeltaPP > 2500:\n",
    "        DeltaPP = 2500\n",
    "    elif DeltaPP < 0:\n",
    "        DeltaPP = 0\n",
    "    HPP =DeltaPP * 128 / 1000\n",
    "    #print  hex(HPP)\n",
    "    BigJS0N[\"parameters\"][\"PulsesDelay\"] = int(DeltaPP)\n",
    "    print \"Pulses delay:\", DeltaPP,\" ns -- \",hex(HPP)\n",
    "    WriteFPGA(spi,0xD0,HPP) # set sEEPon\n",
    "\n",
    "def setPoff(sEEPoff,spi):\n",
    "    # Sets the damping length.\n",
    "    POff = sEEPoff * 128 / 1000\n",
    "    #print sEEPoff,POff\n",
    "    POffMSB, POffLSB = 0x00FF&POff/256,0x00FF&POff \n",
    "    print \"Poff:\", sEEPoff,\" ns -- \",hex(POffMSB),hex(POffLSB)\n",
    "    BigJS0N[\"parameters\"][\"Poff\"] = int(sEEPoff)\n",
    "    WriteFPGA(spi,0xE1,POffMSB) # set sEEPon MSB\n",
    "    WriteFPGA(spi,0xE2,POffLSB) # set sEEPon LSB\n",
    "\n",
    "    # Setting Poff to Acq delay sEEDelayACQ\n",
    "def setDeltaAcq(DeltaAcq,spi):\n",
    "    if DeltaAcq > 255*255:\n",
    "        DeltaAcq = 254*254\n",
    "    elif DeltaAcq < 0:\n",
    "        DeltaAcq = 0\n",
    "    hDA = DeltaAcq * 128 / 1000\n",
    "    hDAMSB, hDALSB = hDA/255 , 0x00FF&hDA \n",
    "    print \"Delay between:\",DeltaAcq,\"ns -- \", hex(hDAMSB),hex(hDALSB)\n",
    "    BigJS0N[\"parameters\"][\"DeltaAcq\"] = int(DeltaAcq)\n",
    "    WriteFPGA(spi,0xE3,hDAMSB) # set sEEPon MSB\n",
    "    WriteFPGA(spi,0xE4,hDALSB) # set sEEPon LSB\n",
    "    \n",
    "def SetLengthAcq(LAcqI,spi):\n",
    "    LAcq = LAcqI * 128 / 1000\n",
    "    #print LAcq,hex(LAcq),hex(LAcqI)\n",
    "    BigJS0N[\"parameters\"][\"LengthAcq\"] = int(LAcqI)\n",
    "    LAcqMSB, LAcqLSB = 0x00FF&LAcq/256 , 0x00FF&LAcq\n",
    "    print \"Acquisition length: \", LAcq, \" ns -- \",hex(LAcqMSB),hex(LAcqLSB)\n",
    "    WriteFPGA(spi,0xE5,LAcqMSB) # set sEEPon MSB\n",
    "    WriteFPGA(spi,0xE6,LAcqLSB) # set sEEPon LSB\n",
    "\n",
    "def setPeriodAcq(lEPeriod,spi):\n",
    "    lEPNs = lEPeriod*128/1000 #ns\n",
    "    EPNsMSB, EPNs, EPNsLSB = 0x00FF&lEPNs/(256*256),0x00FF&lEPNs/256,0x0000FF&lEPNs \n",
    "    print \"Period between two acquisitions:\", lEPeriod,\"us --\", hex(EPNsMSB),hex(EPNs),hex(EPNsLSB) \n",
    "    BigJS0N[\"parameters\"][\"PeriodAcq\"] = int(lEPeriod)\n",
    "    WriteFPGA(spi,0xE7,EPNsMSB) # Period of one cycle MSB\n",
    "    WriteFPGA(spi,0xE8,EPNs) # Period of one cycle 15 to 8\n",
    "    WriteFPGA(spi,0xE9,EPNsLSB) # Period of one cycle LSB\n",
    "\n",
    "def setPulseTrain(Pon,Pdelay,Poff,DelayAcq,Acq,spi):\n",
    "    setPon(Pon,spi)\n",
    "    setPulsesDelay(Pdelay+Pon,spi)\n",
    "    setPoff(Poff+Pdelay+Pon,spi)\n",
    "    setDeltaAcq(DelayAcq+Poff+Pdelay+Pon,spi)\n",
    "    SetLengthAcq(Acq+DelayAcq+Poff+Pdelay+Pon,spi)\n",
    "    #SetLengthAcq(Acq,spi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python2.7/dist-packages/ipykernel_launcher.py:54: RuntimeWarning: This channel is already in use, continuing anyway.  Use GPIO.setwarnings(False) to disable warnings.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reset 25 - Low 1s\n",
      "Reset 25 - High 0.2s\n",
      "spi.cshigh is False\n",
      "spi mode is 1\n",
      "spi maxspeed is 2000000hz\n",
      "------\n",
      "Pulse width: 200  ns --  0x19\n",
      "Pulses delay: 100  ns --  0xc\n",
      "Poff: 2000  ns --  0x1 0x0\n",
      "Delay between: 7000 ns --  0x3 0x80\n",
      "Config FPGA done!\n",
      "------\n",
      "Pulse width: 200  ns --  0x19\n",
      "Pulses delay: 295  ns --  0x25\n",
      "Poff: 2295  ns --  0x1 0x25\n",
      "Delay between: 9295 ns --  0x4 0xa5\n",
      "Acquisition length:  17829  ns --  0x45 0xa5\n"
     ]
    }
   ],
   "source": [
    "spi = StartUp()\n",
    "print(\"------\")\n",
    "ConfigSPI(spi)\n",
    "print(\"------\")\n",
    "t1 = 200\n",
    "t2 = 95\n",
    "t3 = 2000\n",
    "t4 = 7000\n",
    "t5 = 130000\n",
    "setPulseTrain(t1,t2,t3,t4,t5,spi)\n",
    "N = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'data': [],\n",
       " 'firmware_md5': '49ed003fae3a312590fe99a2fa90392c',\n",
       " 'firmware_version': 'p',\n",
       " 'parameters': {'DeltaAcq': 9295,\n",
       "  'LengthAcq': 139295,\n",
       "  'Poff': 2295,\n",
       "  'Pon': 200,\n",
       "  'PulsesDelay': 295},\n",
       " 'registers': {208: 37,\n",
       "  224: 25,\n",
       "  225: 1,\n",
       "  226: 37,\n",
       "  227: 4,\n",
       "  228: 165,\n",
       "  229: 69,\n",
       "  230: 165,\n",
       "  235: 0,\n",
       "  236: 51,\n",
       "  237: 3,\n",
       "  238: 160}}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigJS0N\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 25, 50, 75, 100, 125, 150, 175, 200, 225, 250, 275, 300, 325, 350, 375, 400, 425, 450, 475, 500, 525, 550, 575, 600, 625, 650, 675, 700, 725, 750, 775, 800, 825, 850, 875, 900, 925, 950, 0, 0] 41\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Curve = CreateDACCurve(0,1000,True)[0] # Beginning, Ending, Linear (if False, expo)\n",
    "print Curve,len(Curve)\n",
    "#setDACConstant(0x77,spi)\n",
    "SetDACCurve(spi,Curve)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pulse width: 150  ns --  0x13\n",
      "Pulses delay: 210  ns --  0x1a\n",
      "Poff: 810  ns --  0x0 0x67\n",
      "Delay between: 7810 ns --  0x3 0xe7\n",
      "Acquisition length:  17639  ns --  0x44 0xe7\n"
     ]
    }
   ],
   "source": [
    "t1 = 150\n",
    "t2 = 60\n",
    "t3 = 600\n",
    "t4 = 7000\n",
    "t5 = 130000\n",
    "setPulseTrain(t1,t2,t3,t4,t5,spi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#LoopSPI(spi)\n",
    "#LoopAcq(spi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "TestSPI(spi,3) # LED2 clignote 3x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "N=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pulse width: 200  ns --  0x19\n",
      "Pulses delay: 300  ns --  0x26\n",
      "Poff: 2300  ns --  0x1 0x26\n",
      "Delay between: 2310 ns --  0x1 0x27\n",
      "Acquisition length:  25895  ns --  0x65 0x27\n",
      "64 -> 12800 samples\n",
      "121\n",
      "64 -> 12800 samples\n",
      "122\n",
      "64 -> 12800 samples\n",
      "123\n",
      "64 -> 12800 samples\n",
      "124\n",
      "64 -> 12800 samples\n",
      "125\n",
      "64 -> 12800 samples\n",
      "126\n",
      "64 -> 12800 samples\n",
      "127\n",
      "64 -> 12800 samples\n",
      "128\n",
      "64 -> 12800 samples\n",
      "129\n",
      "64 -> 12800 samples\n",
      "130\n",
      "64 -> 12800 samples\n",
      "131\n",
      "64 -> 12800 samples\n",
      "132\n",
      "64 -> 12800 samples\n",
      "133\n",
      "64 -> 12800 samples\n",
      "134\n",
      "64 -> 12800 samples\n",
      "135\n",
      "64 -> 12800 samples\n",
      "136\n",
      "64 -> 12800 samples\n",
      "137\n",
      "64 -> 12800 samples\n",
      "138\n",
      "64 -> 12800 samples\n",
      "139\n",
      "64 -> 12800 samples\n",
      "140\n",
      "64 -> 12800 samples\n",
      "141\n",
      "64 -> 12800 samples\n",
      "142\n",
      "64 -> 12800 samples\n",
      "143\n",
      "64 -> 12800 samples\n",
      "144\n",
      "64 -> 12800 samples\n",
      "145\n",
      "64 -> 12800 samples\n",
      "146\n",
      "64 -> 12800 samples\n",
      "147\n",
      "64 -> 12800 samples\n",
      "148\n",
      "64 -> 12800 samples\n",
      "149\n",
      "64 -> 12800 samples\n",
      "150\n",
      "64 -> 12800 samples\n",
      "151\n",
      "64 -> 12800 samples\n",
      "152\n",
      "64 -> 12800 samples\n",
      "153\n",
      "64 -> 12800 samples\n",
      "154\n",
      "64 -> 12800 samples\n",
      "155\n",
      "64 -> 12800 samples\n",
      "156\n",
      "64 -> 12800 samples\n",
      "157\n",
      "64 -> 12800 samples\n",
      "158\n",
      "64 -> 12800 samples\n",
      "159\n",
      "64 -> 12800 samples\n",
      "160\n",
      "64 -> 12800 samples\n",
      "161\n",
      "64 -> 12800 samples\n",
      "162\n",
      "64 -> 12800 samples\n",
      "163\n",
      "64 -> 12800 samples\n",
      "164\n",
      "64 -> 12800 samples\n",
      "165\n",
      "64 -> 12800 samples\n",
      "166\n",
      "64 -> 12800 samples\n",
      "167\n",
      "64 -> 12800 samples\n",
      "168\n",
      "64 -> 12800 samples\n",
      "169\n",
      "64 -> 12800 samples\n",
      "170\n",
      "64 -> 12800 samples\n",
      "171\n",
      "64 -> 12800 samples\n",
      "172\n",
      "64 -> 12800 samples\n",
      "173\n",
      "64 -> 12800 samples\n",
      "174\n",
      "64 -> 12800 samples\n",
      "175\n",
      "64 -> 12800 samples\n",
      "176\n",
      "64 -> 12800 samples\n",
      "177\n",
      "64 -> 12800 samples\n",
      "178\n",
      "64 -> 12800 samples\n",
      "179\n",
      "64 -> 12800 samples\n",
      "180\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "f = 0x00\n",
    "t1 = 200\n",
    "t2 = 100\n",
    "t3 = 2000\n",
    "t4 = 300-t1-t2+10\n",
    "t5 = 200000\n",
    "Curve = CreateDACCurve(100,400,True)[0]\n",
    "SetDACCurve(spi,Curve)\n",
    "\n",
    "setPulseTrain(t1,t2,t3,t4,t5,spi)\n",
    "LAcq = t5/1000 #ns to us\n",
    "WriteFPGA(spi,0xED,f) # Frequency of ADC acquisition / sEEADC_freq (3 = 16Msps, 1 = 32, 0 = 64, 2 = 21Msps)\n",
    "WriteFPGA(spi,0xEB,0x00) # Doing one line\n",
    "\n",
    "\n",
    "for pp in range(60):\n",
    "\n",
    "    WriteFPGA(spi,0xEF,0x01) # Cleaning memory pointer\n",
    "    WriteFPGA(spi,0xEA,0x01) # Software Trig : As to be clear by software\n",
    "\n",
    "    Fech = int(64/((1+f)))\n",
    "    Nacq = LAcq * Fech\n",
    "    print Fech, \"-> \"+str(Nacq) + ' samples' \n",
    "\n",
    "    A = []\n",
    "    for i in range(2*Nacq+1):\n",
    "        A.append ( spi.xfer([0x00] )[0] )\n",
    "        \n",
    "    a = np.asarray(A).astype(int)\n",
    "    \n",
    "    BigJS0N[\"data\"] = A\n",
    "    BigJS0N[\"target\"] = \"pu90\"\n",
    "    BigJS0N[\"position\"] = pp\n",
    "    \n",
    "    N = N+1\n",
    "    print N\n",
    "    with open('p_serPU90-'+str(N)+\".json\", 'w') as outfile:\n",
    "        json.dump(BigJS0N, outfile)\n",
    "        \n",
    "print \"Done\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Pon', 'PulsesDelay', 'Poff', 'LengthAcq', 'DeltaAcq']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigJS0N[\"parameters\"].keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}