All posts by kauz

Semi-Automatic Spot Welder

Sometimes I feel the need for a spot welder for welding battery tabs. Since soldering batteries can damage their chemistry and commercial spot welders are too expensive, I decided to build my own from scrap. I don’t recommend doing this if you are not confident with electrical stuff since this project ivolves mains voltage and high currents which result in an overall power of around 1000W! You have been warned!





Microwave oven transformers (MOTs) can be obtained for free and have great potential to be used or abused in various projects. One popular use of MOTs is in DIY spot welders. One has to remove the secondary (high voltage) winding and sqeeze in 2-3 turns of heavy gauge copper wire in order to get 1.5-3V @ ca. 400A. There is an infinite amount of information on how to do this online so I won’t cover it too deeply.
I was able to squeeze 2.5 turns onto the core using ca. 8mm thick stranded copper wire. The electrode blocks are made from pure copper (12x12x50mm copper bars) to minimize resistance and sink the heat. The lugs that connect the wire to the blocks can be made from copper sheets or copper pipe. The welding electrodes are 4.5mm solid copper wire with pointed tips. I had to experiment a little with electrode distance and tip geometry. 3-10mm distance and round tip geometry are probably good starting points.





In order to get consistent welds, some parameters have to be controlled with the most important being mechanical force of the electrode to the workpiece and duration of the high current pulse. The idea behind resistance spot welding is that the spots where electrodes touch the workpiece are the areas of highest electrical resistance and therefore they heat up, melt and fuse together. My welder is built in a “series configuration” which means that both electrodes are at the top as opposed to the alternative variant where one is at the top end the other at the bottom. It is important for both welding electrodes to have near-equal mechanical force on the workpiece and therefore both are spring-loaded individually. Two microswitches in series ensure that the same force on every electrode is applied every time. Only when both microswitches are triggered, the welding pulse is applied. Afterwards the system waits for some seconds until the next weld can be performed. Note that the cable tie on the pictures only holds both arms together losely. They are still able to move away from each other for at least 10mm which is sufficient.








An Attiny85 breakout board takes care of pulse timing. The pulse duration can be adjusted with a 5k potentiometer. A TM1637-based 4 digit 7 segment display shows its duration in milliseconds. A solid state relay for AC voltage turns on the MOT for the set duration. The control circuit is powered by a small 5V 1A AC-DC converter of asian origin. All GPIO pins of the Tiny are finally occupied. The Attiny85 was programmed using the Arduino IDE and while the code is primitive, it does its job well:


//Spot welder controller, simple "blocking code using delays
//uses TM1637 4digit LED display board
//D2: data, D1: clock of TM1637
//D0: solid state relay to switch the MOT
//A3: potentiometer (5k to 50k)
//D4: trigger (2 microswitches in series for each welding electrode)


#include <Arduino.h>
#include <TM1637Display.h>

// Module connection pins (Digital Pins)
#define CLK 1
#define DIO 2
#define SSR 0
#define POT A3
#define TRIG 4

#define maxPulseLength 500

int weldingTimer = 400; //in ms
int pauseTimer = 4000;
int addr=0;
TM1637Display display(CLK, DIO);

void setup() {
  display.setBrightness(7);
  pinMode(TRIG, INPUT_PULLUP);
  pinMode(SSR, OUTPUT);
  digitalWrite(SSR,LOW);
  //value = EEPROM.read(addr);
}

void loop() {
  int anVal = analogRead(POT);
  weldingTimer=map(anVal,0,1024,0,maxPulseLength);
  display.showNumberDec(weldingTimer);

  if(digitalRead(TRIG)==LOW){
    digitalWrite(SSR,HIGH);
    delay(weldingTimer);
    digitalWrite(SSR,LOW);
    delay(pauseTimer);
  }
}

This system has plenty of power. It’s probably even over-powered for battery tab welding so make sure to start with small welding pulses of around 20ms and increase until the weld sticks well. With 70ms and an electrode distance of 3mm I managed to burn a hole through an empty coin cell in an attempt to weld a 0.1mm nickel strip to it. Experiment on scrap metal before you proceed to serious business such as 18650 cells.

OpenBCI with Plessey EPIC Electrodes

Conventional electrodes on EMG/EEG/ECG systems require low contact impedance and therefore often skin preparation is needed. Disposable electrodes can become expensive over time and to improve conductivity, with many electrodes gel has to be used, which is annoying. Capacitive electrodes have the advantage of being reusable and due to their etremely low contact impedance they can make biopotential measurements unobtrusive by incorporating them into seats or measuring through clothing.


After coming across commercial capacitive electrodes I was curious how they perform and made a carrier board for the QFN electrodes. The devices require bipolar power supplies from +- 2.4 to 5V so they are compatible with the OpenBCI V3 boards which have +-2.5V. The PS25255 is the type I finally purchased because it is low power and low gain.





The things look very interesting. The actual contact surface has a mirror finish and looks like silicon. Strangely there is a gap between the electrode contact area and the rest of the package. I think this might cause problems because the electrode is designed to be in direct contact with skin and dirt might accumulate inside this gap.
The 4 contacts (VCC, VSS, GND and SIGNAL) are on the bottom side of the QFN package and therefore my approach of mounting them to the PCB is by having plated holes in the pads and soldering from the bottom side. Use sufficient amounts of flux and the solder reflows down to the contacts and you have a perfect connection.





As a connector a 4-pin JST-style connector with 1.25mm pin pitch was used. I mounted it in a right angle to make the sensor flat. Crimping the female connectors using a PA-09 crimping tool was a challenge because they are so tiny.
Finally, I assembled an adapter board to break out the + and – 2.5V of the OpenBCI ‘Cyton’ board (AGND is already broken out on the right angle header) and tried to acquire some ECG. The signal outputs of both electrodes were connected to channel 1 an its gain was lowered to 2x (the PS25255 electrode itself already has a gain of 10). Also the channel has to be disconnected from SRB1 in the channel settings to make it ‘bipolar’.








If placing the electrodes directly on the skin you get quite good results without any skin preparation. I was also easily able to acquire EEG by placing one eclectrode on the forehead and the other one on the neck. Hair distorts the signal too much.





After putting both electrodes into plastic bags I was still able to acquire an ECG signal, but the signal was very sensitive to movement. Attempts to measure through a t-shirt were only successful if strong pressure was applied.
In all my experiments I did not use a drien right leg circuit or the bias output of the OpenBCI. Instead, only the software notch filter was enabled.


As a conclusion, I’d say that this was an interesting experiment, but 20$ per electrode seems a bit much for my hobby grade experiments. The Plessey EPIC electrodes seem to be usable for ECG, but their inability to penetrate hair for multichannel EEG is a little disappointing. It’s hard to tell how long the will last due to their peculiar packeage design. I will try some active electrode designs from the OpenEEG project with the OpenBCI soon, since they are easy to make, cheap and you can attach a comb electrode to it to be able to acquire EEG through hair hopefully more reliably than with passive electrodes.

Raspberry Pi Zero Lipo Fuel Gauge With Safe Shutdown

The Pi Zero (and Zero W) are quite tolerant in respect to their power requirements. They can even be run from a LiFePO4 battery that has a voltage range of 3.6 to 2.5V. LiPo batteries are better-suited as their voltage ranges from 4.2 down to about 3V. When running the boards from the blank cell (it should have protection circuitry!), they last even longer because fewer losses occur since there is no boost converter in the system. In fact, the 5V is only needed for the USB host, although many devices are supposed to work from voltages down to 3V.


Unfortunately, these single board computers lack power management and don’t have shutdown buttons and there are not that many simple and cost-effective solutions for these problems. https://www.tindie.com/products/xorbit/lifepo4weredpi/ is one nice example, but unfortunately not fully open source.
My idea was to combine a MAX17043 LiPo fuel gauge with a pushbutton and a LiPo charging circuit to create a battery and safe shutdown management add-on for the Pi Zero.









The little board occupies only the first 10 pins and uses only GPIO4 and SDA + SCL. Design files for the tiny custom TP4056 charger board can be downloaded as a .zip archive:


TP4056mCH

The Python script the make the thing work is attached below. Add it to rc.local to execute on startup.


#!/usr/bin/python

#Python Script for MAX17043 fuel gauge and safe shutdown button
#in order to execute on startup add the following line to /etc/rc.local
#(sleep 10;python /home/pi/fuelgauge.py) &
#assuming that fuelgauge.py is in /home/pi 
#sleep 10 is probably not necessary

import RPi.GPIO as GPIO
import smbus
import time
import os


#threshold in % below which the pi gets shut down
threshold=15.0
buttonPin=4
# I2C-Adddress of MAX17043
address = 0x36

#registers
VCELL_REGISTER=0x02
SOC_REGISTER=0x04
MODE_REGISTER=0x06
VERSION_REGISTER=0x08
CONFIG_REGISTER=0x0C
COMMAND_REGISTER=0xFE

#  open the bus by creating an instance
MAX17043 = smbus.SMBus(1)

#set up GPIO for shutdown button
GPIO.setmode(GPIO.BCM)
#Using GPIO nr 4
GPIO.setup(buttonPin,GPIO.IN,pull_up_down=GPIO.PUD_UP)

def reset():
    MAX17043.write_byte_data(address, COMMAND_REGISTER, 0x00)
    MAX17043.write_byte_data(address, COMMAND_REGISTER, 0x04)

def quickStart():
    MAX17043.write_byte_data(address, MODE_REGISTER, 0x40)
    MAX17043.write_byte_data(address, MODE_REGISTER, 0x00)

#get state of charge
def getSOC():
    # Konfiguration des MAX17043
    MSB= MAX17043.read_byte_data(address, SOC_REGISTER)
    LSB = MAX17043.read_byte_data(address, SOC_REGISTER)
    percentage= MSB+ LSB/256.0
    #print percentage
    if percentage < threshold:
        os.system("sudo shutdown -h now")


#Arduino map function for convenience
def arduino_map(x, in_min, in_max, out_min, out_max):
    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min

#setup
reset()
quickStart()

# Loop
while True:
    getSOC()
    time.sleep(1.5)
    #shutdown if button is pressed and held
    if (GPIO.input(buttonPin)==0):
        os.system("sudo shutdown -h now")


if __name__ == "__main__":
   main()


Pulse Oximeter Hack

The pulse oximeter is a very useful and affordable medical gadget. It incorporates a quick and easy way of measuring your heart rate as well as calculating the blood oxygen saturation in one go! After having a look inside the Contec CMS50C and CMS50D which are both MSP430-based devices with OLED displays, it quickly became apparent, which one is easier to hack to extract the data.




The CMS50C (the one with the color OLED, available for <15$ on the usual platforms) has a nice line of well accessible and labeled pads, among which is also a UART interface that is streaming all of the useful values such as 7bit photoplethismographic curve data, the "bar graph", the SPO2 and heart rate value, a "beat detection bit" and various diagnostic bits at a sampling rate of 60Hz. An overview over the entire communication protocol can be found here. The serial port settings are a bit unusual: 4800 baud, and EVEN parity, so watch out for that, but other than that it’s a quite clever protocol that is storing all this information in only 5 bytes.



















The most essential connections are GND, TX, RST, the right pin of the trigger pushbutton and Batt. After that you should be able to completely control the thing from a microcontroller and harvest the data.
A code sample for Teensy 3.x is found below:




//sketch for reading the CMS50C pulse oximeter data using a Teensy 3.x

#define TRIG_PULSEOX 3 // has to be pulled to 3.3V to start the CMS50C
#define RST_PULSEOX 15
//vars for pulseOx
char incomingPulseOxbyte;
unsigned int byteCntPulse = 0;
char pulseCurve_PulseOx = 0;
char SPO2;
char HR_PulseOx;
boolean lastBitPulseOx = 0; //the MSB of the heart rate byte is hidden in a different byte - the one that holds the bar graph data
unsigned long pulseOxTrigTmr=0;
unsigned long pulseOxTrigInt=600000; // length of the pulse that triggers the CMS50C
unsigned long pulseOxRstTmr=0;
unsigned long pulseOxRstInt=800000;

boolean triggeredOx = false;
boolean resettedOx = false;

//packet management bytes for the Amarino Android app
char startFlag = 18;
char ack = 19;
char delimiter = 59; //';' in case we use more than 1 channel


void setup() {
  // put your setup code here, to run once:
  Serial1.begin(115200); // Bluetooth port
  Serial3.begin(4800, SERIAL_8E1); // Pulse oximeter CONTEC CMS 50C, annoying fact: it has EVEN PARITY!

   // make the pins outputs:
  pinMode(RST_PULSEOX, OUTPUT);
  pinMode(TRIG_PULSEOX, OUTPUT);
  
  digitalWrite(RST_PULSEOX, HIGH);
  
  
  triggerOx(); //turn on the PulseOx

}

void loop() {

  
  // put your main code here, to run repeatedly:
   //waiting to pull TRIG_PULSEOX LOW again 
  if((micros()-pulseOxTrigTmr)>pulseOxTrigInt && triggeredOx == true){
    digitalWrite(TRIG_PULSEOX, LOW);
    triggeredOx=false;
  }
  

   readPulseOx();

}

void readPulseOx() {
 
  //--------------------Pulse Oximeter data analysis----------------
  if (Serial3.available() > 0) {
    //pulseox data
    incomingPulseOxbyte = Serial3.read();
    if (byteCntPulse == 1) {
      //the second byte contains a 7 bit pulse wave value, Fs=60Hz
      pulseCurve_PulseOx = incomingPulseOxbyte;
      byteCntPulse++;
    } else if (byteCntPulse == 2) {
      //the 0-3rd bits of the third byte is the bar graph value .
      //the 6th bit is bit 7 of the heart rate value!
      if ( bitRead(incomingPulseOxbyte, 6)) {
        //if the heart rate is >= 128, this happens
        lastBitPulseOx = 1;
      } else
        lastBitPulseOx = 0;

      byteCntPulse++; //move on
    } else if (byteCntPulse == 3) {
      //
      if (lastBitPulseOx)
        //if the heart rate is >= 128, this happens
        HR_PulseOx = 128 + incomingPulseOxbyte;
      else
        HR_PulseOx = incomingPulseOxbyte;

      byteCntPulse++;
    } else if (byteCntPulse == 4) {
      //the last byte contains the most important SPO2 value
      SPO2 = incomingPulseOxbyte;
      byteCntPulse = 0; //we're done the data packet has 5 bytes in total
    } else {


      Serial1.print(startFlag);
      Serial1.print("P");
      Serial1.print(delimiter);
      Serial1.print(pulseCurve_PulseOx, DEC); //send the pulse curve value
      Serial1.print(delimiter);
      Serial1.print(HR_PulseOx, DEC); //send the heart rate
      Serial1.print(delimiter);
      Serial1.print(SPO2, DEC); //send SPO2 value!
      Serial1.print(ack);

    }

    //analyze the first byte. it has plenty of information about the data
    //the fourth bit of the first packet byte means "OK signal" if zero, otherwise it stands for "searching too long"
    //the seventh bit of the first byte has to be always set!!!!! (the only byte where this is the case) all other bytes have a bit 7 == 0
    if ( bitRead(incomingPulseOxbyte, 7)) {
      byteCntPulse++;
    }
  }

}

void triggerOx(){
//function to trigger the pulse oximeter button
   digitalWrite(TRIG_PULSEOX,HIGH);
   pulseOxTrigTmr=micros();
   triggeredOx=true;
 }


Better Blood Pressure Monitor Hack

After ordering the cheapest (wrist-type) blood pressure monitor I could find online (around 10$) to see how it performs in comparison to a “regular one”, I got a nice surprise.




I’ve hooked up a logic analyzer to as many testpoints on its PCB as possible and found out that it has a UART interface on board!! How convenient is that?
This ABP hack has proven to be quite impractical after all, although many people have shown interest in this this project and contacted me as it’s quite useful to have access to your blood pressure data and almost no open source blood pressure monitor projects exist.




 
















A sequence of bytes is sent from testpoint “P6” which turns out to be UART TXD @9600 baud 8N1. You can hook up ANY microcontroller to that and harvest the data easily. After a measurement is complete and successful, the device keeps sending the same byte sequence over and over again until powerdown.




This sequence is the one you see on the pictures: 255 – 254 – 008 – x – x – 0 – Syst. RR low byte – Syst. RR high byte – Diast. RR – heart rate.  As you can see the last 4 bytes of the frame is our desired data. For the systolic pressure we seem to require 2 bytes because 255 is apparently not enough. Sad but true 🙂 , then comes the diastolic pressure and finally the heart rate. The frame starts with 3 fixed bytes (255, 254 and 008 in decimal), followed by 2 variable bytes (haven’t figured out what those are for yet) and a zero byte followed by the data.




Throughout the measurement process itself constantly pressure data is streamed via UART. Each data packet begins with a ‘254’ (DEC) byte followed by one “cuff pressure” byte and one byte that represents the pulse oscillation.  Here’s what the data of one measuring cycle looks like if plotted over time:





























2 JST connectors were inserted into the enclosure. The 3 pin one gives you access to GND, the ON/OFF/START button to remotely trigger the device (just has to be pulled to GND) and finally to the TXD pin of the device. The 2 pin one is simply connected to the battery terminals to eliminate the need for batteries and power the thing from an external source.





Just look online for sphyngomanometers of similar appearance if you want to hack one too. This one has “CK” as a logo, but there are models around from different brands that look the same enclosure-wise. The exact model name of this device is “CK-101”




These devices perform reproducible values but you have to make sure to keep your wrist at heart level, as otherwise the values vary extremely. There is also literature that suggests that the wrist-type sphyngomanometers overestimate blood pressure because of distinct anatomical properties of the wrist arteries (https://www.ncbi.nlm.nih.gov/pubmed/15096904).




One application for an automatically triggered wrist sphyngomanometer I can think of is automated sleep measurement because during sleep your wrist is roughly at heart level anyway.

Ebay 500W Wind Generator

Recently I’ve come across this high quality device while looking for a permanent magnet alternator to experiment with.
It’s supposed to be a generator designed particularly for wind turbines and able to deliver 500W. Not bad. Its weight is about 3.5kg. The shaft diameter is 20mm. That’s about all info I could get from the seller.




20161029_100500




The inner shaft diameter is 12mm, the 20mm slotted steel adapter can be taken off. It is sealed off with a plastic “bearing” with a steel spring around it (not visible in the picture). Could be polyethylene or similar to protect it from the elements. The chassis is supposedly cast aluminium at the front and a precision machined Al cover at the back with a chunky rubber ring between back cover and alternator. The alternator itself is a 90mm diameter high quality brushless outrunner motor/alternator by CPM with the entire stator potted in some kind of plastic. The rotor was made from machined steel. After visiting the webpage on the label you get forwarded to http://www.cpmotion.com/ A quick search for the part number was not successful.




20161029_095037




20161029_095149




The injection molded black plastic cover prevents the cables to touch the rotor of the alternator. Nice attention to detail. The black connector on the ribbon cable I have attached myself because I had a 20pin one lying around and 0.1 inch headers are much easier to work with.




20161029_095106



I got the thing from ebay (new and unused!) for less than 50€ and expected a 3phase device because of the three wires coming out of it. Instead it turned out to have a DC output (the yellow and green one is just tied to the chassis). After cranking it up by hand for testing I figured out that some charge was stored across the red and black wire which implied that there’s a capacitor hidden somewhere and that it had to be DC. The fact alone that the manufacturer had chosen red and black should actually be enough of a clue that it’s a DC device. Besides the power cables a 20pin connector with a ribbon cable is poking out of the enclosure as well. Asking the seller for datasheets was not successful. I was only told that it is worth much more than what I payed for it and that it’s from a company that went bankrupt. Visiting the website on the label did not give me a datasheet for this particular device either. The only thing I was able to find out is that the manufacturer (CPM) uses the CAN bus on their other products to control their devices (CAN 2.0A) besides some digital and analog pins on their control interfaces. At least something if we assume that not only the alternator but also the control electronics was designed by them.




So the only thing left is trying to reverse engineer it. After spinning the generator up with a drill you notice a very short pulse of mechanical resistance after a couple of turns. I thought maybe there is some kind of initialization routine happening after power-up. Attaching a 60W H4 automotive light bulb as a load showed that the device is definitely useful to generate DC electricity. The bulb could be brought to full brightness easily. A voltage measurement on different rpm without a load revealed that the voltage can easily go up to 48V.
After removing all screws I tried to open the front part but I couldn’t do it for some reason and therefore I decided to not do potentially irreversible stuff for now.




Instead the next reasonable step would be to crank the alternator up evenly with a drill and measure voltages on some pins. All we know to this point is that it’s likely to find a CAN interface on the header, which means that 2 pins should measure about 2.5V (depending on whether it’s 3.3V or 5V CAN) against some ground reference.
In the picture below you see the results of mapping out the interface.




20161029_094934




Indeed I was able to find -2.5V on the pins irrespective of RPM. Then I reversed polarity of my oscilloscope/multimeter and took the GND pin as a reference for further measurements. In total I was only able to find 2 pins with 2.5V which is another progress. 2 other pins had about 3.3V on them and 3 Pins had variable voltage (0-2V in my tests) depending on the RPM.




My ambition with this device is to try to communicate with it via CAN and try to repurpose its control electronics, as it seems to be well-engineered apparatus all in all. The fact that it has a pulse of resistance at startup makes it possible for this thing to have an internal, probably configurable load inside which might be used as a brake. Also I’m curious to know what kind of data it is capable to spit out. If I were the engineer, I’d probably have it measure power and RPM…let’s see. My approach will be to try to connect an Arduino via MCP2515 to the CAN pins and see whether I get any response.

Homebrew OpenBCI V3 and Ultracortex

I’ve been intrigued by the ADS1299 chip by TI for a long time and after I came across the OpenBCI project and felt that my SMT skills were good enough, I finally decided to give the DIY approach a trial. The documentation is very good and almost complete and everything is open source, so get ready for an exciting blog post.
First off I downloaded Design Spark, which is the PCB editor the OpenBCI designs were made with. I used it to generate gerber files for getting the boards and solder paste stencils manufactured by OSH Park. By now they even have a function for importing Design Spark files.
Anyway, here are the Gerber files for the OpenBCI V3 8bit board. You should be able to place OSH orders using these:
OpenBCI 8bit OSH Park
For OSH Stencils:
OpenBCI 8bit OSH Stencils working
32bit Gerbers:
OpenBCI 32bit
32bit board stencil Gerbers:
OpenBCI 32bit Stencil
Daisy Board Gerbers (the 8bit board stencil partially fits the Daisy board, therefore I didn’t generate stencil Gerbers for that):
OpenBCI_Daisy

Note that there’s a bug on the Daisy PCB, which is described here.
luckily I knew about that issue and fixed it during the “pick and place” process prior to soldering.

I would recommend building the 32bit version right away since it is more capable (writes to SD, can be upgraded to 16 channels, fewer power rails, runs from one lithium cell, no need for 5V+, better microcontroller and last but not least: easier to build since it has fewer parts!).

Most parts were sourced from Digikey and Mouser. The SD card holder I found somewhere on ebay.
Also, I found picking and placing of tiny 0402 parts worked best with my DIY SMD vacuum tool and a thin needle. Especially where the components are densely packed (below the ADS1299) this method was very helpful. Before you begin, make sure to print out the OpenBCI_32bit_BOM and stick the component tapes with gluestick or sticky tape right next to the part indices. That way no parts get lost and you know exactly where each one belongs.

20160613_163743

20160613_164020

I had better results adding a drop a thin flux from a flux pen into the solder paste and mixing it. That way the solder paste is a bit smoother and reflows better. Remember: you can never use too much flux!

20160613_164152

20160613_164534

20160613_170951

The top side goes into the DIY reflow oven

20160613_171929

The bottom side is soldered with a hot air tool, being careful not to overheat the PCB.

20160613_175840

I’ve soldered 1.27mm header pins to the RFduino and female headers to the PCB because the wireless link is the bottleneck of the system. The headers allow to connect a different wireless module such as BT 2.1 or a USB-serial converter, which could be useful when planning to increase the sampling rate or using the system with Android devices.

20160613_185014

Using the PICKIT 3 programmer and MPLAB IPE (you can install ithe IPE without installing the IDE) to flash the Chipkit bootloader (can be found in the OpenBCI Github repository).

20160613_191010

The current draw of the 32bit board is about 60 mA

20160614_105347

My own dongle design:

20160614_105403

20160613_193246

Time to print the headware (“Ultracortex Nova/Supernova”)

The print was done on an Ultimaker 2 clone with the recommended slicer settings and turned out ok. It took about 12 hours and I experienced some problems while printing the first half. Some parts snapped off because the print head collided with plastic that was bending up during cooldown. This happened only during a few layers of the print (approx after one third) because the structure was not stable enough at that stage. I could repair the broken parts by filling the defects with hot glue.  When printing the second half I had an eye on the process and coud prevent that from happening.

20160616_075440

Used old PC tower cables to do the wiring. They were done in twisted pairs. All left electrodes are white and all right electrodes are colour-coded. That way you don’t need that many colors and nevertheless finding the corresponding electrode is easy.

20160617_103454

There are spring sets sold on the usual trading platform that contain the necessary springs to build the electrode inserts. The one below contains the “weak” as well as the “strong” spring for the “dummy inserts”. The weak spring had to be pulled apart a few mm to fit better.

20160701_092408

20160617_110640

20160617_145008

As you can see, I soldered the header of the Daisy board on the bottom side which takes up less space.

20160617_164954

OpenBCI parts <–this zip file contains my snap-on lid design that also covers the Daisy board as well as the earclip electrode design. Both parts can be found on Thingiverse as well:

http://www.thingiverse.com/thing:1635759

http://www.thingiverse.com/thing:1648317

20160620_080217

An 18650 holder with TP4056-based protection and charging circuit was placed on top to have a reliable power supply.

cover_on_daisy1

cover_on_daisy2

What you’re not being told: you have to print the “QUADSTAR” parts of the Ultracortex Nova/Supernova in PLA SOFT or any other elastomer filament. I had to modify my Prusa i3 extruder to prevent the soft 1.75 mm filament from kinking before entering into the bowden tube. This part fixes the issue: http://www.thingiverse.com/thing:1652091

Also I found that I had to turn off retractions because as soon as the filament passes the extruder drivewheel, it gets compressed and shoud not undergo this process twice because then it gets too damaged to be pushed into the bowden tube and extrusion simply stops at that point. Pain.

20160630_094022

Finished Iron Maiden, err…. I mean Ultracortex, wired for the 16 channel standard configuration according to the Processing GUI with as many “comfy inserts” as possible.

20160630_195026

20160630_195049

20160630_201633

One thing I noticed after using the Disposable / Reusable Dry EEG Electrode [TDE-200] was instant corrosion. Not that surprising given that two different metals (stainless steel M2 bolt and Ag/AgCl surface) come in contact. As you can see on the picture below on the left electrode the AgCl layer corroded away to that extent after only one day. As a comparison there’s a fresh electrode on the right. The only solution I see at the moment is to attach the electrodes only if they are needed.

20160701_081452

A slight modification was done to be able to add/remove electrodes more quickly: the electrode cables were soldered directly to the M2 nuts and superglued to the back of the electrode holder, so the nut stays attached to the plastic part even if there is no bolt pressing it down.

20160630_200402

Results:

Rocording with my eyes closed. Note the alpha peak in the FFT plot. As you can see not all channels are working. It’s not that easy getting 16 dry electrodes to work. I’m also having issues with channel 2 for some reason. Maybe there’s a bad solder joint somewhere on the PCB.

20160630_194627

Conclusions:

The OpenBCI V3 32bit + Daisy is a clean design and a good way to get 16 channels of electrophysiological data up and running and a great pplication for the ADS1299. The documentation is definitely good enough to build everything yourself, assuming you have some experience with SMT soldering. The DIY approach is also cheaper. I think you can get away with one third the price for the 32bit board and Daisy module, not including the cost of your labour of course. It’s a challenging project, but for me it was worth the effort. The DIY approach gives you the possibility to modify the design if you need to. I would like to use the potential of the ADS1299 more in the future and for example increase the sampling rate.
When it comes to the headware, my initial fascination faded a little when I discovered that the Ultracortex is quite painful to wear! The comb electrodes are no pleasure on your skin, let me tell you! But they do provide good signal quality almost instantaneously. The corrosion issue is also a significant one. I’m wondering how the signal quality changes as soon as the AgCl layer is gone completely. Maybe there’s a way of re-applying the layer by electrolysis in NaCl solution. This remains subject of further investigation. Other that those insights I find the design of the Ultracortex amazing! It’s a perfect example of great design specifically for 3D printing. Everything fits together perfectly well and looks great! Many thanks to the OpenBCI team for making their great work open source!