From ef261fb851317a65e6b2764492a0fbb741790857 Mon Sep 17 00:00:00 2001
From: James Devine <devine.jd@gmail.com>
Date: Thu, 25 Jan 2018 21:04:21 +0100
Subject: [PATCH]

---
 gistfile1.txt | 267 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 267 insertions(+)
 create mode 100644 gistfile1.txt

diff --git a/gistfile1.txt b/gistfile1.txt
new file mode 100644
index 0000000..23ce70a
--- /dev/null
+++ b/gistfile1.txt
@@ -0,0 +1,267 @@
+/*
+Description:
+  Development firmware for the CosmicPi V1.5.
+  With this one can set the high voltage and thresholds for the detector on the fly, all while listening to all events.
+  It indicates detections on all three channels - A for one slab, B for the other slab and C for a coincidence event.
+
+Usage:
+  Set sensible default values for:
+    The high voltage: HV_DEFAULT_VAL
+    Both thresholds: Thresh_default_val
+    Wether to use the DAC or the MAX5387 for thershold setting: useDAC
+  Compile and flash to Arduino DUE
+  Connect to the Arduino via serial (NOTE: Baudrate=115200)
+  Follow the interactive menue that prints out on start.
+  Current options are:
+    [1= set both thrsholds, 2= set HV, 3= reset event count]
+  Select one and input a value you want to test.
+  Then reset the counter and do your measurement.
+  Event count and time in ms will be printed on the screen.
+
+Features:
+  Working:
+    Set HV
+    Set Threshold
+    Print out events
+*/
+
+#include <Wire.h>
+
+#define LED1_pin 12  // green and lower one
+#define LED2_pin 11  // red and upper one
+
+#define TRIGOUT 5
+#define STRIGBOUT A0
+#define STRIGAOUT A5
+
+#define MAX5387_PA0_pin A9
+#define MAX5387_PA1_pin A10
+#define MAX5387_PA2_pin A11
+#define ref1_pin A1
+#define ref2_pin A2
+
+const int HV_MAX_VAL = 89;
+const int HV_MIN_VAL = 255;
+const byte HV_DEFAULT_VAL = 129; //note this is for 1.3mm2 Hamamatsu MPPCs, a higher value should be used for 1mm MPPCs
+const int Thresh_default_val = 1160; //this value needs to be picked carefully, if too many events come out the Arduino will crash.
+const bool useDAC = true;
+
+//set up the pins to remap SPI by hand
+const int num_devices = 2;
+const int SS_pin[num_devices] = {14, 15};
+const int SCK_pin = 17;
+const int MOSI_pin = 16;
+
+byte thresh1;
+byte thresh2;
+
+unsigned long timemeasure;
+unsigned long timeoffset;
+
+float instarate;
+
+unsigned long event_count = 0;
+
+extern volatile unsigned long timer0_millis;
+unsigned long new_value=0;
+
+void setup() {
+  //setup analogue writemode
+  analogWriteResolution(12);
+  // setup pins
+  setPinModes();
+  setConstantPins();
+  attachInterrupt(digitalPinToInterrupt(TRIGOUT), [=] () {printTimeAndPin(TRIGOUT, "SiPM_c");}, RISING);
+  attachInterrupt(digitalPinToInterrupt(STRIGAOUT), [=] () {printTimeAndPin(STRIGAOUT, "SiPM_a");}, RISING);
+  attachInterrupt(digitalPinToInterrupt(STRIGBOUT), [=] () {printTimeAndPin(STRIGBOUT, "SiPM_b");}, RISING);
+  // setup serial comm
+  Serial.begin(115200);
+  
+  // setup initial thresholds
+  if (useDAC){
+    Serial.print("Setting thresholds to: ");
+    Serial.println(Thresh_default_val);
+    analogWrite(DAC0, Thresh_default_val);
+    analogWrite(DAC1, Thresh_default_val); 
+  } else {
+    setThreshold(1, Thresh_default_val);
+    setThreshold(2, Thresh_default_val);
+  }
+  
+  // set HV to default
+  Serial.print("Setting HV to: ");
+  Serial.println(HV_DEFAULT_VAL);
+  bitBang(HV_DEFAULT_VAL);
+
+  timeoffset = 0;
+}
+
+void loop() {
+  Serial.println("Input a command!");
+  Serial.println("[1= set both thrsholds, 2= set HV, 3= reset event count]");
+  int cmd = readIntFromSerial();
+  switch(cmd){
+    case 1:
+      {
+        Serial.println("Set a threshold value [1,4096]: ");
+        int value = readIntFromSerial();
+        if (useDAC){
+          Serial.print("Setting both thresholds to: ");
+        Serial.println(value);
+          analogWrite(DAC0, value);
+          analogWrite(DAC1, value); 
+        } else {
+          setThreshold(3, value);
+        }
+        break;
+      }
+    case 2:
+      {
+        Serial.println("Input a voltage value [1=highest,255=lowest]");
+        byte sendValue = (byte) readIntFromSerial();
+        if (sendValue < HV_MAX_VAL){
+          Serial.print("HV Value is too high! Setting HV to:");
+          Serial.println(HV_MAX_VAL);
+          bitBang(HV_MAX_VAL); // Transmit data
+        } else{
+          Serial.print("Setting HV to:");
+          Serial.println(sendValue);
+          bitBang(sendValue); // Transmit data
+        }
+        break;
+      }
+    case 3:
+      event_count = 0;
+      timeoffset = millis();
+      Serial.println("Event counter and timer set to 0!");
+      break;
+  }
+  
+    
+}
+
+
+
+void setPinModes(){
+  // I2C adress pins for the MAX5387
+  pinMode(MAX5387_PA0_pin, OUTPUT);
+  pinMode(MAX5387_PA1_pin, OUTPUT);
+  pinMode(MAX5387_PA2_pin, OUTPUT);
+  // Analoge input pins form the threshold
+  pinMode(ref1_pin, INPUT);
+  pinMode(ref2_pin, INPUT);
+  // status LEDs
+  pinMode(LED1_pin, OUTPUT);
+  pinMode(LED2_pin, OUTPUT);
+  // trigger pins
+  pinMode(TRIGOUT, INPUT);
+  // HV pins
+  digitalWrite(SS, HIGH);  // Start with SS high
+  for (int i=0; i<num_devices; i++){
+    pinMode(SS_pin[i], OUTPUT);
+    digitalWrite(SS_pin[i], HIGH);  
+  }
+  pinMode(SCK_pin, OUTPUT);
+  //pinMode(MISO_pin, INPUT); //this is the avalanche pin, not implemented yet
+  pinMode(MOSI_pin, OUTPUT);
+}
+
+void setConstantPins(){
+  // I2C adress pins for the MAX5387
+  digitalWrite(MAX5387_PA0_pin, LOW);//configure the address of the MAX5387 pot
+  digitalWrite(MAX5387_PA1_pin, LOW);//configure the address of the MAX5387 pot
+  digitalWrite(MAX5387_PA2_pin, LOW);//configure the address of the MAX5387 pot
+}
+
+
+// this function sets the thresholds for the MAX5387
+// 1 is the first channel, 2 the second and 3 sets both at the same time
+void setThreshold(int pot_channel, int value){
+  // do a value check
+  if (value > 255 || value < 1){
+    return;
+  } else {
+    value = byte(value);
+  }
+  
+  Wire.begin();
+  Wire.beginTransmission(byte(0x28)); // transmit to device #112
+  switch(pot_channel){
+    case 1:
+      Serial.print("Setting channel 1 to: ");
+      Serial.println(value);
+      Wire.write(byte(B00010001)); //sets value to the first channel
+      Wire.write(value);
+      thresh1 = value;
+      break;
+    case 2:
+      Serial.print("Setting channel 2 to: ");
+      Serial.println(value);
+      Wire.write(byte(B00010010)); //sets value to the second channel
+      Wire.write(value);
+      thresh2 = value;
+      break;
+    case 3:
+      Serial.print("Setting both channels channel to: ");
+      Serial.println(value);
+      Wire.write(byte(B00010011)); //sets value to both channels
+      Wire.write(value);
+      thresh1 = value;
+      thresh2 = value;
+      break;
+  }
+  
+  Wire.endTransmission();
+}
+
+
+byte bitBang(byte _send)  // This function is what bitbangs the data
+{
+
+  //reception isn't implemented in this version. 
+  //byte _receive = 0;
+  for(int j=0; j<num_devices; j++){
+    digitalWrite(SS_pin[j], LOW);        // SS low 
+    for(int i=0; i<8; i++)  // There are 8 bits in a byte
+    {
+      digitalWrite(MOSI_pin, bitRead(_send, 7-i));    // Set MOSI
+      //delay(1);
+      digitalWrite(SCK_pin, HIGH);                  // SCK high
+      //bitWrite(_receive, i, digitalRead(MISO_pin)); // Capture MISO
+      digitalWrite(SCK_pin, LOW);                   // SCK low
+    //digitalWrite(MOSI_pin, LOW);    // Set MOSI
+      
+    }
+     digitalWrite(SS_pin[j], HIGH);       // SS high again 
+  }
+  //return _receive;        // Return the received data
+}
+
+
+void printTimeAndPin(int pin, String name){
+  // print when and which pin was interrupted
+  event_count++;
+  Serial.print(name);
+  Serial.print(";count=");
+  Serial.print(event_count);
+  Serial.print(";time=");
+  timemeasure=millis();
+  Serial.println(timemeasure-timeoffset);
+  /* This code works out the instant rate and prints it as well. more likely to cause crashes as it's in the interrupt.
+  Serial.print(";time=");
+  timemeasure = millis();
+  Serial.print(timemeasure);
+  Serial.print(";rate=");
+  instarate = ((event_count*1000)/timemeasure);
+  Serial.println(instarate);
+*/
+}
+
+int readIntFromSerial(){
+  int val = Serial.parseInt();
+  while (val == 0){
+    delay(100);
+    val = Serial.parseInt();
+  }
+  return val;
+}
\ No newline at end of file