Project Logs

Collapse logs

• All soldered up

  Ole Andreas Utstumo • 02/02/2017 at 11:22 • 4 comments

  It wouldn't be a successful migration to a new PCB tool without introducing a new hardware bug, would there? ;) That's why pad[1] of the SERCOM module is connected to RX of the BT module. However, pad[1] cannot be configured as SERCOM TX, only pad[0] and pad[2]. To solve that we could

  a) configure the pin connected to the RX of the bluetooth module as an input (high impedance), configure one of the unused pad[0] pins as the SERCOM TX and run a wire between them.

  b) emulated UART in the firmware like the SoftwareSerial library of Arduino. Since we're only sending data, this could work out all right.

  Going for a would be the quickest solution. However, I'll give b a try, keep the PCB clean and learn something new.

• KiCAD files uploaded to GitHub

  Ole Andreas Utstumo • 01/28/2017 at 20:16 • 0 comments

  I removed the link to the old CircuitMaker project, and uploaded all project files to GitHub.

  Help yourselves:

  https://github.com/Utstumo/Heartbeat-Logger/
  

• PCBs for rev 3 arrive

  Ole Andreas Utstumo • 01/24/2017 at 11:36 • 0 comments

  Looking good! I couldn't resist, I just had to solder some of the components on it :)The bottom ground layer is without any major traces, set aside for the pads and traces for the memory card reader and the BT module where I removed all unnecessary pads, in order to improve the EMC.

  With the 3rd revision still using a discrete components in the analogue front end, the question might beg of why I didn't go for a packaged ECG front end IC. Well, I still wanted this project to be mostly educational, and I believe working with discrete, analogue components like opamps and inamps promotes a broader knowledge in circuit design. I added test points to the PCB now, so that tracking the signal, testing and verifying becomes much easier.

• Fixed, smaller, a bit better

  Ole Andreas Utstumo • 11/22/2016 at 12:13 • 0 comments

  The logger is now redone in KiCad:

  Hardware bugs should be fixed, the bluetooth module can now be soldered directly to the backside of the PCB, there are mounting holes for the enclosure (if the battery allows it) and the whole board shrank in the process. Will be on the way to my mailbox soon.

  3.3V rail distribution is still not too great, but for any major improvement of that, the board should have been 4 layer, which costst a whole lot more.
  

  I did consider other more current efficient modules than the HC-06, but for now I know it works and is readily available at every Chinese silicon corner. It would have been fun to get acquainted with Nordic's nRF5xxx SoCs, though.

• Streaming heartbeats

  Ole Andreas Utstumo • 10/28/2016 at 13:57 • 6 comments

  Giffed above is the Logger streaming data to my Surface via the HC-06 bluetooth module. All the bytes are sent to the virtual COM port and displayed using a processing sketch. It works out really well, in fact. The only issue is that there are no synchronization bytes, and since each sampled value is packaged into two bytes, there's a 50/50 chance of the sketch grabbing the correct byte first when you start it.
  

• Firmware -- State machine

  Ole Andreas Utstumo • 06/01/2016 at 11:43 • 0 comments

  The system operates using a simple state machine.

  The states exist in the code as functions that are called over and over again:

  void die(void);
  void sampling(void);
  void sleep(void);
  void wake(void);

  To easily manage the states, we create a function pointer that can point to the state's function:

  void (*function_pointer)(void);

  To set a new state, all we have to do is to make the function pointer point to another state's function (the & character can be omitted):

  function_pointer = &wake;

  The function pointer is called repeatedly in an everlasting while loop in main, so that it constantly executes the current state:

  	while(1){
  		function_pointer();
  		
  	}

  The state is changed by certain conditions. Take the wake state for example:

  void wake(void){
  	
  	GLED_on();
  	afe_enable();
  	sdcard_enable();
  	ext_enable();
  	tc_enable(&tc_sampler_instance);
  	adc_enable(&adc_instance);
  	
  	if(sdcard_init()){
  
                  function_pointer = sampling;
  
  		buffer_counter = 0;
  		timestamp = 0;
  		buttoncounter = 0;	
  		buffer_current = buffer_a;
  		buffer_last = buffer_b;
  		
  		update_battery_voltage();
  
  		tc_start_counter(&tc_sampler_instance);
  		usart_write_buffer_job(&usart_instance, buffer_current, 2);
  		
  	}else
  		function_pointer = die;
  	
  }

  Here, the next state is set to either sampling or die, depending on the success of the SD card initialization, just as described in the state machine diagram at the top. When the program returns from the function call, the function pointer will be called again, but this time it is pointing to a different state -- et voila!

• Enclosure

  Ole Andreas Utstumo • 05/23/2016 at 13:50 • 0 comments

  I got a simpe enclosure printed for the logger a while ago, thanks to the guys at Moon Wearables.

  The battery is glued to the bottom half..

  ... while the top half has a hole for the push button and a little button that goes in it.

  The button rests on the pushbutton on the PCB, and has edges that keeps it from falling out.
  

  The PCB rests on ridges inside the bottom half and is glued in place. Ridges along the edge of the two halves and a bit of tape make sure that they lock in place. The HC06 bluetooth module is a bit awkwardly placed, I must admit that, but that means there will be room for improvement on the next revision, for example to let the module be soldered directly onto the PCB.

• Firmware out on GitHub

  Ole Andreas Utstumo • 05/12/2016 at 09:23 • 0 comments

  You can find the firmware at the project's GitHub repo:

  https://github.com/Utstumo/Heartbeat-Logger/

  The firmware is written using Atmel Studio 7.0 and ASF.

• Firmware -- Event and interrupt driven sampling & writing

  Ole Andreas Utstumo • 05/03/2016 at 20:07 • 0 comments

  As the SAMD20 doesn't have DMA, I solved the sampling & writing to the SD card by having a timer time the ADC sampling with an event and using an interrupt on the ADC's result ready to store the result in a double FIFO buffer. The sampling frequency is low enough for it to pose no trouble at all. The vital thing is that the interrupt always must be serviced before the next sample is ready to ensure consistent sampling. Here's a flowchart of how it works:

  There are two buffers as below. As one of the buffers fills up, we switch them by assigning a pointer to each of the buffers. Data will always be stored into the same pointer, buffer_current, and data will simultaneously be written to a memory card from the same pointer, buffer_last. It's the buffers being pointed at that will switch place.

  char buffer_a[BUFFER_SIZE];
  char buffer_b[BUFFER_SIZE];
  char *buffer_current;
  char *buffer_last;

  To keep track of the buffer, we also need something to point the current array position:

  uint16_t buffer_counter = 0;

  The ADC ISR is set up in the form as a callback using ASF. When each sample is ready after a conversion has been triggered by the event system, the ADC_Handler callback will be called. The BUFFER_SIZE is set to 512, so it will fit 256 samples.
  

  void ADC_Handler(){
  	
  	//Result is ready, put it in buffer
  	if(buffer_counter < BUFFER_SIZE){
  	
  		uint16_t resultat = REG_ADC_RESULT;
  		
  		//store the result as little endian
  		*(buffer_current + buffer_counter) = resultat;
  		*(buffer_current + buffer_counter + 1) = 0xFF & (resultat>>8);
  		buffer_counter+=2;
  		
  		if(buffer_counter >= BUFFER_SIZE){
  			if(battery_check_counter++ > BATTERY_CHECK_TIMER){
  				update_battery_voltage();
  				battery_check_counter = 0;	
  			}
  			
  
  			flag_buffer_ready = 1;
  			buffer_counter = 0;
  			
  			char * buffer_temp;
  			buffer_temp = buffer_current;
  			buffer_current = buffer_last;
  			buffer_last = buffer_temp;
  						
  		}	
  		
  	}else{
  		
  		//Buffer overflow
  		RLED_on();
                  buffer_counter = 0;
  		
  	}
  		
  	
  }

  Once the buffer is full and have been switched, the flag_buffer_ready is set, and we can handle the writing in main. The function below is constantly being called as long as the logger is in the sample state.

  int8_t write_data(void){
      
      if(flag_buffer_ready){
  
          flag_buffer_ready = 0;   
  
          //write to sd card        
          if(!sdcard_write(buffer_last, BUFFER_SIZE))
              return -1;    
       
          return 1;
      }
      return 0;
  }

  If a new ADC sample is ready, the ADC_Handler will be called whatever the system is doing, including writing to the SD card.

  Here's a tip: By toggling a port pin at a certain point in the code, you can debug the timing of your system by hooking up an oscilloscope:

  Here, the code is toggling a pin at every ADC interrupt (red) and raises another pin while writing to the SD card (blue). Rock steady! I'll post the code on GitHub soon enough.

• Vital signs: Good

  Ole Andreas Utstumo • 05/01/2016 at 12:06 • 0 comments

  It's been quite a lot of debugging, but here you go!
  

  12 bits, precisely about 512 Hz. The sampler is running on the internal 32kHz clock, which does have some tolerance in contrast to crystals.

  Working like a charm. Well, near enough :)

View all 34 project logs