matty/20180516a/20180516a-Server.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `20180516a` - JSON Server - version un0_e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "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\"]=\"fa6a7560ade6d6b1149b6e78e0de051f\"\n",
    "BigJS0N[\"firmware_version\"]=\"e_un0\"\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 = 23 ## Reset for the FPGA\n",
    "    IO4 = 26 ## 26 is the output connected to \n",
    "    \n",
    "    CS_FLASH = 7\n",
    "    GPIO.setup(CS_FLASH,GPIO.OUT)  \n",
    "    GPIO.output(CS_FLASH,GPIO.LOW)\n",
    "    \n",
    "    GPIO.setup(PRESET,GPIO.OUT)\n",
    "    GPIO.setup(IO4,GPIO.IN, pull_up_down=GPIO.PUD_DOWN)\n",
    "    print \"Reset GPIO 23 - Low 1s\"\n",
    "    GPIO.output(PRESET,GPIO.LOW)\n",
    "    time.sleep(3)\n",
    "    print \"Reset GPIO 23 - High 0.2s\"\n",
    "    GPIO.output(PRESET,GPIO.HIGH)\n",
    "    time.sleep(0.2)\n",
    "\n",
    "    spi = spidev.SpiDev()\n",
    "    spi.open(0,0) # 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) # 33 acquisitions\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": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python2.7/dist-packages/ipykernel_launcher.py:56: RuntimeWarning: This channel is already in use, continuing anyway.  Use GPIO.setwarnings(False) to disable warnings.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reset GPIO 23 - Low 1s\n",
      "Reset GPIO 23 - 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": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TestSPI(spi,3) # LED2 clignote 3x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'data': [],\n",
       " 'firmware_md5': 'fa6a7560ade6d6b1149b6e78e0de051f',\n",
       " 'firmware_version': 'e_un0',\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": 5,
     "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "N=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pulse width: 70  ns --  0x8\n",
      "Pulses delay: 170  ns --  0x15\n",
      "Poff: 2170  ns --  0x1 0x15\n",
      "Delay between: 2310 ns --  0x1 0x27\n",
      "Acquisition length:  25895  ns --  0x65 0x27\n",
      "Lines number: 1\n",
      "64 -> 12800 samples\n",
      "6\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "spi.max_speed_hz = 2000000\n",
    "BigJS0N[\"N\"] = N\n",
    "BigJS0N[\"V\"]=\"25\"\n",
    "f = 0x00\n",
    "t1 = 70\n",
    "t2 = 100\n",
    "t3 = 2000\n",
    "t4 = 300-t1-t2+10\n",
    "t5 = 200000\n",
    "\n",
    "Curve = CreateDACCurve(200,600,True)[0]\n",
    "SetDACCurve(spi,Curve)\n",
    "\n",
    "BigJS0N[\"experiment\"]={}\n",
    "BigJS0N[\"experiment\"][\"id\"] = \"20180516a\"\n",
    "BigJS0N[\"experiment\"][\"description\"]=\"Classical experiment with calibration piezo\"\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",
    "\n",
    "WriteFPGA(spi,0xEB,0x00) # Doing one line if 0, several if 1\n",
    "WriteFPGA(spi,0xEC,0x03) # Doing 1 lines\n",
    "\n",
    "if BigJS0N[\"registers\"][235]: # means it's set to 1, ie that's multiples lines\n",
    "    NLines = BigJS0N[\"registers\"][236]\n",
    "else:\n",
    "    NLines = 1\n",
    "    BigJS0N[\"registers\"][236] = 1\n",
    "\n",
    "print \"Lines number: \"+str(NLines)\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 * NLines\n",
    "\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[\"experiment\"][\"target\"] = \"calibration rig\"\n",
    "BigJS0N[\"experiment\"][\"position\"] = \"0\"\n",
    "\n",
    "\n",
    "print N\n",
    "with open(BigJS0N[\"experiment\"][\"id\"]+'-'+str(N)+\".json\", 'w') as outfile:\n",
    "    json.dump(BigJS0N, outfile)\n",
    "N = N+1        \n",
    "print \"Done\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Pon', 'PulsesDelay', 'Poff', 'LengthAcq', 'DeltaAcq']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigJS0N[\"parameters\"].keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[200,\n",
       " 210,\n",
       " 220,\n",
       " 230,\n",
       " 240,\n",
       " 250,\n",
       " 260,\n",
       " 270,\n",
       " 280,\n",
       " 290,\n",
       " 300,\n",
       " 310,\n",
       " 320,\n",
       " 330,\n",
       " 340,\n",
       " 350,\n",
       " 360,\n",
       " 370,\n",
       " 380,\n",
       " 390,\n",
       " 400,\n",
       " 410,\n",
       " 420,\n",
       " 430,\n",
       " 440,\n",
       " 450,\n",
       " 460,\n",
       " 470,\n",
       " 480,\n",
       " 490,\n",
       " 500,\n",
       " 510,\n",
       " 520,\n",
       " 530,\n",
       " 540,\n",
       " 550,\n",
       " 560,\n",
       " 570,\n",
       " 580,\n",
       " 0,\n",
       " 0]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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
}