├── processing_plot
    ├── sketch.properties
    └── processing_plot.pde
├── hardware
    └── c12666ma_breakout.PDF
├── LICENSE
├── README.md
└── arduino_csv_example
    └── arduino_csv_example.ino


/processing_plot/sketch.properties:
--------------------------------------------------------------------------------
1 | mode.id=processing.mode.java.JavaMode
2 | mode=Java
3 | 


--------------------------------------------------------------------------------
/hardware/c12666ma_breakout.PDF:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/groupgets/c12666ma/HEAD/hardware/c12666ma_breakout.PDF


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015, Pure Engineering
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 | 
 7 | * Redistributions of source code must retain the above copyright notice, this
 8 |   list of conditions and the following disclaimer.
 9 | 
10 | * Redistributions in binary form must reproduce the above copyright notice,
11 |   this list of conditions and the following disclaimer in the documentation
12 |   and/or other materials provided with the distribution.
13 | 
14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
18 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | 
25 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # c12666ma
 2 | For More Information pleave visit this project site
 3 | https://groupgets.com/manufacturers/hamamatsu-photonics/products/c12666ma-micro-spectrometer
 4 | 
 5 | Quick How-TO
 6 | 
 7 | Checkout the code I have posed here:
 8 | https://github.com/groupgets/c12666ma
 9 | 
10 | Also get yourself an arduino uno if you don't have one already. 
11 | http://www.mouser.com/ProductDetail/Arduino/A000066/?qs=BC3YYPaifMrIue9b%252bHtKQg%3D%3D&kpid=630043477&gclid=CPb12-2phMYCFQeKaQodqpYA8w
12 | 
13 | next download the arduino environment. 
14 | http://www.arduino.cc/en/Main/Software
15 | 
16 | And for visulization you can use processing 
17 | https://processing.org/download/?processing
18 | 
19 | 
20 | put the spectrometer into the breakout board. 
21 | alight the breakout board so the 5V and 3.3V and GND pins line up. EOS will be unconnected in the center. 
22 | Download the code onto the arduino. 
23 | you will have to modify the processing script to open the correct serial port. 
24 | 
25 | Please if there are any improvements of fixes please submit a push request and it should be accepted. Thanks! 
26 | 
27 | Important Note
28 | ============
29 | GroupGets does not provide coding, firmware, or software support of any kind and will not respond to related requests. All software and firmware provided by GroupGets are offered solely as examples or potential starting points. These repositories may be outdated and are not guaranteed to function as intended.
30 | 
31 | We do not accept returns or offer replacements due to issues related to software, firmware, or code compatibility.
32 | 
33 | The software is provided "AS IS", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings in the software.
34 | 


--------------------------------------------------------------------------------
/processing_plot/processing_plot.pde:
--------------------------------------------------------------------------------
  1 | import processing.serial.*;
  2 | 
  3 | Serial myPort; 
  4 | String val;    
  5 | int[] data; 
  6 | double[] summed;
  7 | int draw_sum=0;
  8 | 
  9 | double find_max(double[] input)
 10 | {
 11 |   double max = 0;
 12 |   for (int i = 0; i < input.length; i++) 
 13 |   {
 14 |     if (input[i] > max)
 15 |     {
 16 |       max = input[i];
 17 |     }            
 18 |   }
 19 |   return max;
 20 | }
 21 | 
 22 | void plotdata()
 23 | {
 24 | 
 25 |   double summed_max = (find_max(summed))/512;
 26 | 
 27 |   background(0); 
 28 | 
 29 |   if (draw_sum !=0)
 30 |   {
 31 |     for (int i=0; i<summed.length-1; i++)
 32 |     {
 33 |       line(i, 0, i, 512-(int)(summed[i]/summed_max));
 34 |     }
 35 |   } else
 36 |   {
 37 | 
 38 |     for (int i=0; i<data.length-1; i++)
 39 |     {
 40 |       line(i, 0, i, 512-data[i]);
 41 |     }
 42 |   }
 43 |   stroke(255);
 44 | }
 45 | 
 46 | 
 47 | void setup() 
 48 | {
 49 |   println(Serial.list());
 50 |   String portName = Serial.list()[0]; //This is the index into the serial list, if you only have one serial device the index is 0
 51 |   myPort = new Serial(this, portName, 115200);
 52 | 
 53 |   summed = new double[255];
 54 | 
 55 |   for (int i = 0; i < 255; i++) 
 56 |   {
 57 |     summed[i] = 0;
 58 |   }
 59 | 
 60 |   size(255, 512);
 61 | }
 62 | 
 63 | void draw()
 64 | {
 65 |   if ( myPort.available() > 0) 
 66 |   {  
 67 |     val = myPort.readStringUntil('\n');         // read it and store it in val
 68 |     if (val != null)
 69 |     {
 70 |       data = int(split(val, ',')); 
 71 | 
 72 |       for (int i = 0; i < data.length; i++) 
 73 |       {
 74 |         if (i<summed.length)
 75 |         {
 76 |           summed[i] +=  data[i];
 77 |         }
 78 |         //print(data[i]);
 79 |         // print(' ');
 80 |       }
 81 |       //  println( ' ');
 82 |       plotdata();
 83 |     }
 84 |   }
 85 | }
 86 | 
 87 | void keyPressed() {
 88 | 
 89 |   if (key == 'c' ) 
 90 |   {
 91 |     for (int i = 0; i < summed.length; i++) 
 92 |     {
 93 |       summed[i] = 0;
 94 |     }
 95 |   } 
 96 |   else if (key == 't' ) 
 97 |   {
 98 |     if(draw_sum==1)
 99 |     {
100 |       draw_sum = 0;
101 |     }
102 |     else
103 |     {
104 |       draw_sum = 1;
105 |     }
106 |   } 
107 |   else 
108 |   {
109 |   }
110 | }
111 | 
112 | 


--------------------------------------------------------------------------------
/arduino_csv_example/arduino_csv_example.ino:
--------------------------------------------------------------------------------
  1 |  
  2 | // This code is a modified from the original sketch from Peter Jansen
  3 | // https://github.com/tricorderproject/arducordermini
  4 | // This code removes the external ADC and uses the internal ADC instead. 
  5 | // also this code just prints the output to csv output to the terminal. 
  6 | 
  7 | #define SPEC_GAIN        A0
  8 | //#define SPEC_EOS         NA
  9 | #define SPEC_ST          A1
 10 | #define SPEC_CLK         A2
 11 | #define SPEC_VIDEO       A3
 12 | #define WHITE_LED        A4
 13 | #define LASER_404        A5
 14 | 
 15 | #define SPEC_CHANNELS    256
 16 | uint16_t data[SPEC_CHANNELS];
 17 | 
 18 | void setup() {
 19 | 
 20 |   //pinMode(SPEC_EOS, INPUT);
 21 |   pinMode(SPEC_GAIN, OUTPUT);
 22 |   pinMode(SPEC_ST, OUTPUT);
 23 |   pinMode(SPEC_CLK, OUTPUT);
 24 | 
 25 |   pinMode(WHITE_LED, OUTPUT);
 26 |   pinMode(LASER_404, OUTPUT);
 27 |   digitalWrite(WHITE_LED, LOW);
 28 |   digitalWrite(LASER_404, LOW);
 29 |   
 30 |   
 31 |   //digitalWrite(WHITE_LED, HIGH);
 32 |   //digitalWrite(LASER_404, HIGH);
 33 | 
 34 |   digitalWrite(SPEC_GAIN, HIGH);
 35 |   digitalWrite(SPEC_ST, HIGH);
 36 |   digitalWrite(SPEC_CLK, HIGH);
 37 |   digitalWrite(SPEC_GAIN, HIGH); //LOW Gain
 38 |   //digitalWrite(SPEC_GAIN, LOW); //High Gain
 39 | 
 40 |   //Serial.begin(9600);
 41 |   Serial.begin(115200);
 42 | }
 43 | 
 44 | void readSpectrometer()
 45 | {
 46 |   //int delay_time = 35;     // delay per half clock (in microseconds).  This ultimately conrols the integration time.
 47 |   int delay_time = 1;     // delay per half clock (in microseconds).  This ultimately conrols the integration time.
 48 |   int idx = 0;
 49 |   int read_time = 35;      // Amount of time that the analogRead() procedure takes (in microseconds) (different micros will have different times) 
 50 |   int intTime = 100; 
 51 |   int accumulateMode = false;
 52 |   int i;
 53 | 
 54 |   // Step 1: start leading clock pulses
 55 |   for (int i = 0; i < SPEC_CHANNELS; i++) {
 56 |     digitalWrite(SPEC_CLK, LOW);
 57 |     delayMicroseconds(delay_time);
 58 |     digitalWrite(SPEC_CLK, HIGH);
 59 |     delayMicroseconds(delay_time);
 60 |   }
 61 | 
 62 |   // Step 2: Send start pulse to signal start of integration/light collection
 63 |   digitalWrite(SPEC_CLK, LOW);
 64 |   delayMicroseconds(delay_time);
 65 |   digitalWrite(SPEC_CLK, HIGH);
 66 |   digitalWrite(SPEC_ST, LOW);
 67 |   delayMicroseconds(delay_time);
 68 |   digitalWrite(SPEC_CLK, LOW);
 69 |   delayMicroseconds(delay_time);
 70 |   digitalWrite(SPEC_CLK, HIGH);
 71 |   digitalWrite(SPEC_ST, HIGH);
 72 |   delayMicroseconds(delay_time);
 73 | 
 74 |   // Step 3: Integration time -- sample for a period of time determined by the intTime parameter
 75 |   int blockTime = delay_time * 8;
 76 |   long int numIntegrationBlocks = ((long)intTime * (long)1000) / (long)blockTime;
 77 |   for (int i = 0; i < numIntegrationBlocks; i++) {
 78 |     // Four clocks per pixel
 79 |     // First block of 2 clocks -- measurement
 80 |     digitalWrite(SPEC_CLK, LOW);
 81 |     delayMicroseconds(delay_time);
 82 |     digitalWrite(SPEC_CLK, HIGH);
 83 |     delayMicroseconds(delay_time);
 84 |     digitalWrite(SPEC_CLK, LOW);
 85 |     delayMicroseconds(delay_time);
 86 |     digitalWrite(SPEC_CLK, HIGH);
 87 |     delayMicroseconds(delay_time);
 88 | 
 89 |     digitalWrite(SPEC_CLK, LOW);
 90 |     delayMicroseconds(delay_time);
 91 |     digitalWrite(SPEC_CLK, HIGH);
 92 |     delayMicroseconds(delay_time);
 93 |     digitalWrite(SPEC_CLK, LOW);
 94 |     delayMicroseconds(delay_time);
 95 |     digitalWrite(SPEC_CLK, HIGH);
 96 |     delayMicroseconds(delay_time);
 97 |   }
 98 | 
 99 | 
100 |   // Step 4: Send start pulse to signal end of integration/light collection
101 |   digitalWrite(SPEC_CLK, LOW);
102 |   delayMicroseconds(delay_time);
103 |   digitalWrite(SPEC_CLK, HIGH);
104 |   digitalWrite(SPEC_ST, LOW);
105 |   delayMicroseconds(delay_time);
106 |   digitalWrite(SPEC_CLK, LOW);
107 |   delayMicroseconds(delay_time);
108 |   digitalWrite(SPEC_CLK, HIGH);
109 |   digitalWrite(SPEC_ST, HIGH);
110 |   delayMicroseconds(delay_time);
111 | 
112 |   // Step 5: Read Data 2 (this is the actual read, since the spectrometer has now sampled data)
113 |   idx = 0;
114 |   for (int i = 0; i < SPEC_CHANNELS; i++) {
115 |     // Four clocks per pixel
116 |     // First block of 2 clocks -- measurement
117 |     digitalWrite(SPEC_CLK, LOW);
118 |     delayMicroseconds(delay_time);
119 |     digitalWrite(SPEC_CLK, HIGH);
120 |     delayMicroseconds(delay_time);
121 |     digitalWrite(SPEC_CLK, LOW);
122 | 
123 |     // Analog value is valid on low transition
124 |     if (accumulateMode == false) {
125 |       data[idx] = analogRead(SPEC_VIDEO);
126 |     } else {
127 |       data[idx] += analogRead(SPEC_VIDEO);
128 |     }
129 |     idx += 1;
130 |     if (delay_time > read_time) delayMicroseconds(delay_time - read_time);   // Read takes about 135uSec
131 | 
132 |     digitalWrite(SPEC_CLK, HIGH);
133 |     delayMicroseconds(delay_time);
134 | 
135 |     // Second block of 2 clocks -- idle
136 |     digitalWrite(SPEC_CLK, LOW);
137 |     delayMicroseconds(delay_time);
138 |     digitalWrite(SPEC_CLK, HIGH);
139 |     delayMicroseconds(delay_time);
140 |     digitalWrite(SPEC_CLK, LOW);
141 |     delayMicroseconds(delay_time);
142 |     digitalWrite(SPEC_CLK, HIGH);
143 |     delayMicroseconds(delay_time);
144 |   }
145 | 
146 |   // Step 6: trailing clock pulses
147 |   for (int i = 0; i < SPEC_CHANNELS; i++) {
148 |     digitalWrite(SPEC_CLK, LOW);
149 |     delayMicroseconds(delay_time);
150 |     digitalWrite(SPEC_CLK, HIGH);
151 |     delayMicroseconds(delay_time);
152 |   }
153 | }
154 | 
155 | void print_data()
156 | {
157 |   for (int i = 0; i < SPEC_CHANNELS; i++) 
158 |   {
159 |     Serial.print(data[i]);
160 |     Serial.print(',');
161 |   }
162 |   Serial.print("\n");
163 | }
164 | 
165 | void loop() 
166 | {
167 | //  digitalWrite(LASER_404, HIGH);
168 | //  readSpectrometer();
169 | //  digitalWrite(LASER_404, LOW);
170 | //  print_data();
171 | //  delay(10);
172 |   
173 | //  digitalWrite(WHITE_LED, HIGH);
174 | //  readSpectrometer();
175 | //  digitalWrite(WHITE_LED, LOW);
176 | //  print_data();
177 | //  delay(10);
178 |   
179 |   readSpectrometer();
180 |   print_data();
181 |   delay(10);   
182 | }
183 | 


--------------------------------------------------------------------------------