Update: If you need your motor to turn one revolution per hour instead of one minute, download this slightly modified source code instead

The EasyDriver is REALLY simple in operation. Connect 7-30v DC to M+ (and ground to GND), connect a stepper motor to A and B and the motor automatically steps once for each LOW->HIGH transition on STEP. The direction is dependent on the state of DIR (+5v or ground). MS1 and MS2 together defines the step resolution. The driver chip is a Allegro A3967SLB, so the truth table for MS pins can be found in it’s datasheet, page 2.

The breakout board has pull-up resistors on both MS1 and MS2, which puts it in eight-step resolution as standard. To alter MS1 and MS2 you simply pull them to ground individually based on your desired resolution.

I decided to make a few improvements to the requested operation. Via a DIP-switch the user can select the resolution for the EasyDriver while simultaneously altering the steps/minute so it will always make one turn per minute even though the step resolution is changed. There is also an LED to indicate each step. I used a four-way DIP switch, the two remaining switches I used for step direction and to simply turn the steps on or off. The DIR signal is pulled up to +5v by a 10k resistor

My circuit is built on a strip board and is based on an AtTiny25. It’s system clock is driven by a low frequency 32.768kHz watch crystal. It’s important to program the correct fuse bits for low frequency crystal oscillators!

On to the code. I’m using Timer 0 with system clock as clock source in output compare mode. The registers defining when an output compare interrupt hits is altered based on MS1 and MS2 signals on the DIP-switch.

#include
#include
#define F_CPU 8000000UL
#include

#define DIV64 	3
#define DIV8 	2
#define FULL 	!(PINB & (1<#define HALF 	!(PINB & (1<#define QUARTER (PINB & (1<#define EIGHT 	(PINB & (1<
//MS1 pin 7 PB2
//MS2 pin 6 PB1

void step (void)
{
	PORTB ^= (1<}

ISR(TIMER0_COMPA_vect) //Timer/Counter0 Overflow interrupt routine
{

	step();
}

int main (void)
{
	uint8_t previous = 1;
	uint8_t current = (PINB & 36);
	//Port configuration
	DDRB |= (1<	PORTB |= (1<
	//Timer initialization
	TCCR0A |= (1<	TCCR0B = DIV64;	//Timer/Counter0 prescaler
	TIMSK |= (1<	OCR0A = 76;
	/* OCR0A values
	300ms period (ordinary step) =76/div64
	150ms period (half step) 37/div64
	75ms period (quarter step) 18/div64
	37.5ms period (eight step) 76/div8
	*/
	sei(); //Enable interrupts globally

	while(1)
	{
		current = (PINB & 3);

		if (current != previous)
		{
			if 		(FULL) 		{ OCR0A=76; TCCR0B=DIV64; }
			else if (HALF) 		{ OCR0A=37; TCCR0B=DIV64; }
			else if (QUARTER) 	{ OCR0A=18; TCCR0B=DIV64; }
			else if (EIGHT) 	{ OCR0A=76; TCCR0B=DIV8;  }

			previous = current;
		}
	}

	return 0;
}

A final short demonstration, showing the LED indicating step pulses

Click the embedded image to open it in Google’s 3D warehouse and download it for you projects!

Most hobby CNC controllers are connected to your computer via the computers parallel port. One of the most used controller software packages will be running on the computer (Mach 3 being the most used), sending streams of pulses in real time to the controller board. A do-it-all controller board will handle both the pulse streams and convert it to usable motor stepper motor control sequences, often with the option to do full steps, half-steps, 1/4 steps and so on, and also actually implement the motor control circuitry on the same board.

The optical isolation is important for two reasons;
one is protecting the computers parallel port in case of voltage spikes or high currents on it’s signal lines. The 2nd reason is to reduce noise on signal lines, and to remove the high voltage lines and ground plane from the incoming signal traces. Optical isolators come in IC packages and consists of a combined LED and a photo transistor. When you drive the LED current from a different power source than the photo transistor power source, they are totally isolated from each other. But the parallel port does not provide you with a +5v line, and if it did, it would not be able to source enough current for the pull-up resistors the signal line side of the controller. If I’d use the +5v logic source from the motor controller, you would no longer have isolated the two sides of the controller board. This is why I decided to put on a mini-USB connector for a maximum of 500mA current to the pull-up resistor, with an already regulated 5 volts. That should be more than sufficient.

The brain is an Atmega8 microcontroller, which handles both the inputs from the parallel port, and the outputs to the L298 dual H-bridge motor controllers.

The PCB is double sided, and designed within the 10x10cm limit for REAL cheap manufacturing at either seeedstudio.com or iteadstudio.com. I paid around $15 to have mine manufactured, and that got me 10 copies! Unfortunately, I had an issue of two traces which were shorted to the ground plane on two separate PCB copies, but they are easily fixed with a sharp bladed knife or scalpel. Still, great value for money.

When I designed the PCB based on my schematic, some connections were changed to make routing easier, but this only affects some software changes on the Atmega8.

PCB partially soldered

Design files screenshots

For the past weeks I have had this robot to play with. Today I added some additional intelligence to it, and decided to post it here as a finished project.

The controls are based on my previous post on motor control via bluetooth. One extra motor was added to the code, I etched a new PCB for the L298 board so it took up less space, and attached it all to a robot chassis. The chassis is called “Mr. Basic” and is produced by Dagu specifically for the Let’s Make Robots community. You can buy it at dealextreme.com.

Since my last post on bluetooth motor control I have switched to another android application called QkCtrl. This application provides much more flexibility, and I recommend it. The bluetooth SPP module provides a wireless standard UART interface and is very easy to use and to set up. The whole concept is based on sending individual characters to the microcontroller for each key press in QkCtrl, and then interpreting character on the AtTiny2313 to execute different commands. The QkCtrl layout is user-definable, my layout is pictured below together with explanations on which button sends which character.

Forward ‘U’ Starts the motors on a forward direction. Speed is 1/3 at startup.
Backward ‘D’ Starts the motors in a backward direction. Speed is 1/3 at startup.
Left ‘L’ Makes a small turn to the left when motors are running forward/backward
Right ‘R’ Makes a small turn to the right when motors are running forward/backward
Stop ‘C’ Stops both motors
Speed down ‘s’ Decreases motor speed. Affects both motors
Speed up ‘f’ Increases motor speed. Affects both motors
Pirouette L ‘a’ Full speed pirouette to the left
Pirouette R ‘e’ Full speed pirouette to the right
Alarm ‘P’ Activates “burglar” alarm (robot wiggling with sound when motion is detected)
Child safe ‘H’ When robot is ran against a wall, it automatically stop and changes direction
Headlamp ‘l’ Turn headlamp LEDs on and off
Horn ‘h’ Honks the horn for half a second

The next image explains each component of the robot (click to enlarge)
1 Bluetooth SPP modem
2 AtTiny2313 microcontroller
3 PIR motion sensor
4 Ultrasonic distance sensor
5 L298 dual motor control board
6 One of two LED headlamps
7 Buzzer/horn
8 One of two motors
9 Battery for the motors
10 Battery for the controls and logic (regulated to 5v with L7805)
11 On/off switch

A short demo video

The code is a bit messy without any comments, it will be improved and a schematic will be posted.

#include <avr/io.h>
#include <avr/interrupt.h>
#define F_CPU 8000000UL //Defines clock speed
#define USART_BAUDRATE 9600 //Baudrate for serial comm.
#define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)
#include <util/delay.h>

uint16_t distance;
uint8_t count = 0;
uint8_t ovf = 0;
uint8_t alarm = 0;
uint8_t light = 0;
uint8_t speed = 100;
uint8_t pir = 0;
uint8_t distanceSensor = 0;
char rotDir = 'L';
char state;

void forward(void)
{
	state = 'U';
	PORTB |= (1<<PIN1) | (1<<PIN4);
	PORTB &= ~(1<<PIN0) & ~(1<<PIN3);
	OCR0A = speed;
	OCR0B = speed;
}

void backward(void)
{
	state = 'D';
	PORTB |= (1<<PIN0) | (1<<PIN3);
	PORTB &= ~(1<<PIN1) & ~(1<<PIN4);
	OCR0A = speed;
	OCR0B = speed;
}

void rightTurn(void)
{
	PORTB |= (1<<PIN0) | (1<<PIN1);
	_delay_ms(350);
	if (state == 'U') forward();
	else if (state == 'D') backward();
}

void leftTurn(void)
{
	PORTB |= (1<<PIN3) | (1<<PIN4);
	_delay_ms(350);
	if (state == 'U') forward();
	if (state == 'D') backward();
}

void leftPirouette(void)
{
	state = 'a';
	rotDir = 'L';
	//PORTB = 0b00001010;
	PORTB |= (1<<PIN1) | (1<<PIN3);
	PORTB &= ~(1<<PIN0) & ~(1<<PIN4);
	OCR0A = 254;
	OCR0B = 254;
}

void rightPirouette(void)
{
	state = 'e';
	rotDir = 'R';
	//PORTB = 0b00010001;
	PORTB |= (1<<PIN0) | (1<<PIN4);
	PORTB &= ~(1<<PIN3) & ~(1<<PIN1);
	OCR0A = 254;
	OCR0B = 254;
}

void stop(void)
{
	if (state == 'U')
	{
		backward();
		_delay_ms(40);
	}

	else if (state == 'D')
	{
		forward();
		_delay_ms(40);
	}

	state = 'C';
	GIMSK &= ~(1<<INT1);
	PORTB |= (1<<PIN0) | (1<<PIN1) | (1<<PIN3) | (1<<PIN4);
	OCR0A = 0;
	OCR0B = 0;
	_delay_ms(1000);
	GIMSK |= (1<<INT1);
}

void longBeep(void)
{
	PORTD |= (1<<PIN6);
	_delay_ms(500);
	PORTD &= ~(1<<PIN6);
}

void shortBeep(void)
{
	PORTD |= (1<<PIN6);
	_delay_ms(50);
	PORTD &= ~(1<<PIN6);
}

void lights(void)
{
	if (light == 0)
	{
		PORTB |= (1<<PIN5) | (1<<PIN6);
		light = 1;
	}

	else
	{
		PORTB &= ~(1<<PIN5) & ~(1<<PIN6);
		light = 0;
	}
}

void faster(void)
{
	if (OCR0A < 244 && OCR0B < 244)
	{
		speed += 10;
		OCR0A = speed;
		OCR0B = speed;
	}
}

void slower(void)
{
	if (OCR0A > 10 && OCR0B > 10)
	{
		speed -= 10;
		OCR0A = speed;
		OCR0B = speed;
	}
}

ISR(TIMER1_OVF_vect)
{
	ovf = 1;

	if(count == 25)
	{
	 	//Pulse the DYP-ME007 trigger pin
		PORTD |= (1<<PIN4);
		_delay_us(100);
		PORTD &= ~(1<<PIN4);
		count = 0;
	}
	else count++;
}

ISR(INT0_vect)
{
	if(PIND & (1<<PIN2))
	{
		TCNT1 = 0;
		ovf = 0;
	}

	else
	{
		distance = TCNT1;

		if (ovf == 1);
		else if (distance > 15000 && distanceSensor == 1)
		{
			if (alarm == 1)
			{
				alarm = 0;
				forward();
			}
		}

		else if (distance <= 15000 && alarm == 0 && distanceSensor == 1)
		{
			stop();
			longBeep();
			alarm = 1;
			if (rotDir == 'L') leftPirouette();
			else if (rotDir == 'R') rightPirouette();
		}
	}
}

ISR(INT1_vect)
{
	if (state == 'C' && pir == 1)
	{
		shortBeep();
		forward();
		_delay_ms(250);
		shortBeep();
		backward();
		_delay_ms(250);
		shortBeep();
		stop();
	}
}

//Serial com. Interrupt Service Routine (runs each time a byte is received)
ISR(USART_RX_vect)
{
	char ReceivedByte;
	ReceivedByte = UDR; // Retrieves byte from serial port (bluetooth module)
	//UDR = state; // Echoes it back for fun

	switch (ReceivedByte) //Which ASCII character was received?
	{
		case '!':	shortBeep();
					_delay_ms(50);
					shortBeep();
					_delay_ms(50);
					shortBeep();
					break;

		case 'U': 	forward();
					break; //Increase PWM duty cycle

		case 'C': 	stop();
					break; //Break motor by raising both direction inputs, PWM duty cycle 0%

		case 'D': 	backward();
					break; //Decrease PWM duty cycle

		case 'L': 	leftTurn();
					break;

		case 'R': 	rightTurn();
					break;

		case 'a':	leftPirouette();
					break;

		case 'e':	rightPirouette();
					break;

		case 'h':	longBeep();
					break;

		case 'l':	lights();
					break;

		case 'f':	faster();
					break;

		case 's':	slower();
					break;

		case 'P':	if (pir) pir = 0;
					else pir = 1;
					UDR = 'P';
					break;

		case 'H':	if (distanceSensor) distanceSensor = 0;
					else distanceSensor = 1;
					UDR = 'H';
					break;

		default:	UDR = '?';
					break; //Character unknown to my routine, discard character

	}

}

int main(void)
{
	//I/O Initialization
	DDRB |= (1<<PIN0) | (1<<PIN1) | (1<<PIN2) | (1<<PIN3) | (1<<PIN4) | (1<<PIN5) | (1<<PIN6); //DIR1, DIR2 and Enable pins as outputs
	DDRD |= (1<<PIN4) | (1<<PIN5) | (1<<PIN6);
	PORTB=0; //All initialized to 0

	//Timer0 initialization
	TCCR0A |= (1<<COM0A1) | (1<<COM0B1) | (1<<WGM00); //Phase correct PWM mode
	TCCR0B |= /*(1<<WGM02) |*/ (1<<CS00) | (1<<CS01); //div64
	OCR0A = 0; //Initialize PWM duty cycle to 0%
	OCR0B = 0;

	//Timer1 initialization
	TCCR1B |= (1<<CS10); //No prescaling (max count ~8ms)
	TIMSK |= (1<<TOIE1); //overflow interrupt

	//UART
	UCSRB |= (1 << RXEN) | (1 << TXEN); //Enable Tx and Rx
	UCSRC |= (1 << UCSZ0) | (1 << UCSZ1);
	UBRRL = BAUD_PRESCALE;			//Sets
	UBRRH = (BAUD_PRESCALE >> 8);	//baudrate registers
	UCSRB |= (1 << RXCIE); //Enable USART-interrupt

	//External interrupts
	MCUCR |= (1<<ISC10) | (1<<ISC11) | (1<<ISC00); //INT1 rising trig. INT0 logic trig.
	GIMSK |= (1<<INT1) | (1<<INT0); //INT 0 and 1 enabled

	sei(); //Enable global interrupt

	/* This program is completely interrupt driven, so nothing goes on in while loop*/
	while(1); //Never gets out from here!

	return 0; //Never reaches this point!
}

First, here is the list of items used in the experiment
L298 Double DC motor bidirectional speed controller
AVR AtTiny2313V microcontroller
Bluetooth module for wireless serial communication
12V DC motor

About the bluetooth module
I bought this module as I saw it spread out over several chinese online stores, and was interested in seeing how easy it really is to implement it in a project.

Basically it’s a bluetooth replacement for the Rx and Tx wires in standard serial applications. So if you bought two of these you can have two microcontrollers or computers communicate with each other wireless in the same way as you’d set up standard serial communication. Just hook these up at the Rx and Tx pins of your devices and provide 5v logic supply and ground and you’re ready to go. If you’re not satisfied with the standard setup of the module (name: linvor, PIN: 0000, baudrate: 9600) you can change those settings by sending it AT commands serially. For example, AT+PIN1234 will set pin code to 1234. The device responds with PIN1234 OK. To change baudrate you use the AT+BAUDx where x represents the baudrate number described in the manual. #4 is 9600 and #1 is 1200, for starters.

But you don’t need two of these to have fun! As you already know, many devices these days are equipped with bluetooth, best known is your mobile phone. For your mobile phone to send and receive serial commands via bluetooth, the hardware and software of your phone has to support the Serial Port Profile protocol (SPP). Your android device supports SPP, your iPhone does not. Next thing you’ll need is an android application which can send and (optional) receive bytes by SPP. I found the free software called Blue Control in the android market, and this is what I’ve used here. You can also choose to try the QkCtrl Serial BT which is rather expensive, but much more configurable. Remember to pair your phone with the module from the Wireless settings in android before trying to connect to it in the applications.

Click the photo to enlarge, it will show less grainy. To see the whole figure, please see my schematic for the L298 motor controller in my previous post.

I found the wake/power pin on the bluetooth module to be optional. The manual says it should be tied to ground when activated, and tied to Vcc to make it sleep. Maybe there’s a pull-down resistor on the module, because it works when floating the wake/power pin. There’s also a State output pin for a status LED, but there is already a red one on the module, so no need for an extra. The LED will blink at ~5Hz when not paired, and lit in a stable condition when successfully paired with another device AND the serial port is successfully occupied (when connected within the phones bluetooth application, se video).

Programming the AtTiny2313V
For this application we will use two peripherals on the microcontroller
- The Timer 0, for PWM signal to the motor controller
- The UART, for communicating with the bluetooth module (and thus, your mobile phone)

The microcontroller is interrupt driven, and changes to the control pins are only made when a byte is successfully received via the bluetooth serial module. The characters from the different button in the Blue Control application are pre-defined, will be using the up, down, left, right and center button, which are represented by the ASCII characters U, D, L, R and C. All other characters are ignored by the microcontroller. Please see the below source code which has helpful comments.

#include <avr/io.h>
#include <avr/interrupt.h>
#define F_CPU 3686400UL //Defines clock speed
#define USART_BAUDRATE 9600 //Baudrate for serial comm.
#define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)

//Serial com. Interrupt Service Routine (runs each time a byte is received)
ISR(USART_RX_vect)
{
	char ReceivedByte;
	ReceivedByte = UDR; // Retrieves byte from serial port (bluetooth module)
	UDR = ReceivedByte; // Echoes it back for fun

	switch (ReceivedByte) //Which ASCII character was received?
	{
		case 'U': 	if(OCR0A <= 244)
						OCR0A += 10;
					break; //Increase PWM duty cycle

		case 'C': 	PORTB |= 0b11;
					OCR0A = 0;
					break; //Break motor by raising both direction inputs, PWM duty cycle 0%

		case 'D': 	if(OCR0A >= 10)
						OCR0A -= 10;
					break; //Decrease PWM duty cycle

		case 'L': 	PORTB &= ~(1<<PIN0) & ~(1<<PIN1); //clear Dir-pins
					PORTB |= (1<<PIN0);
					break; //Change motor direction to left

		case 'R': 	PORTB &= ~(1<<PIN0) & ~(1<<PIN1); //clear Dir-pins
					PORTB |= (1<<PIN1);
					break; //Change motor direction to left

		default:	break; //Character unknown to my routine, discard character

	}

}

int main(void)
{
	//I/O Initialization
	DDRB |= (1<<PIN0) | (1<<PIN1) | (1<<PIN2); //DIR1, DIR2 and Enable pins as outputs
	PORTB=0; //All initialized to 0

	//Timer0 initialization
	TCCR0A |= (1<<COM0A1) | (1<<WGM00); //Phase correct PWM mode
	TCCR0B |= (1<<CS00) | (1<<CS01); //div64
	OCR0A = 0; //Initialize PWM duty cycle to 0%

	//UART
	UCSRB |= (1 << RXEN) | (1 << TXEN); //Enable Tx and Rx
	UCSRC |= (1 << UCSZ0) | (1 << UCSZ1);
	UBRRL = BAUD_PRESCALE;			//Sets
	UBRRH = (BAUD_PRESCALE >> 8);	//baudrate registers
	UCSRB |= (1 << RXCIE); //Enable USART-interrupt

	sei(); //Enable global interrupt

	/* This program is completely interrupt driven, so nothing goes on in while loop*/
	while(1); //Never gets out from here!

	return 0; //Never reaches this point!
}

Picture by Solarbotics.com, a great resoruce for hobby robotics!

I want to get deeper into the robotics scene, and need some sort of “base” to experiment from. So I bought the AREXX Mr. Basic 4WD robot/car chassis from DealExtreme.com (SKU 45542), and while it still has not arrived, I decided getting busy preparing it a warm welcome.

So, since the robot chassis has two stationary DC motors I wanted to make a TTL level compatible stationary motor driver, so I wouldn’t have to re-invent the wheel(driver) each time a prototype a new idea. This has at least two main advantages
1 – Fewer components on the logic drive circuit, less time prototyping
2 – Lower cost. Motor driver chips are expensive, and one chip per prototype is just unnecessary.

The best choice of chip type for this application is one of the many dual h-bridge driver chips out there. The reasons you should choose an integrated circuit instead of designing your own h-bridge with 8+ FETs is because they need almost no external components and take up less space. This gives you a lower bill of materials, more space left for other circuitry and an even easier design process. And since we’re building this as a module, it doesn’t even restrict the use to your one robot platform, it is really a very handy thing to have at hand!

The most available motor driver chips I have found to be the ones from ST Microelectronics. For applications with motors reaching currents up to 600mA (1.2A 100us peak) ampere, use the L293D. For currents up to 2A (3A 100us peak, 2.5A repetitive(see datasheet)), use the L298, like I did, to play it safe for all future applications.

What I basically did was to follow one of the example schematics in the datasheet and complete it with header pins and terminal block for connections to my microcontrollers, power supplies and motors. See Figure 6 : Bidirectional DC Motor Control on page 6 in the datasheet (current version at this date).

My complete schematic is shown here

One feature that this chip have, and the L293D has not, is the current sense output pins. Those pins are where the motor current is passed through so they need to be grounded. But since ST have been so nice to regulate the voltage on these output pins to 2 volts, you can add a high power, low value, resistor in series with the output and then easily sense the current drawn by the motors by measuring the voltage drop across the sense resistors. This voltage can then be directly read by a microcontroller ADC to get some great operational feedback. Remember to dimension the resistor value and specifications to match your application. If you’re expecting currents up to 3A you could easily reckon the voltage drop across small hobby motors will be big, so a 5W resistor will do in most cases, and 3A/2V=1,5 Ohms so a 2 Ohm 5 watt resistor is fine to play it safe. For smaller applications with less current drawn you just have to make sure to use a high resolution ADC to sense the smaller voltage drops.

In the video below I have connected one channel to my atmel STK500 at which all the momentary tact switches are pulled high when open, then drawn to ground when closed. Thats why the enable pin doesn’t cut the drive circuit until I press it’s connected button. If you like to see a curios cat, just keep watching. Note that in the pictures and on the video I have no current sensing resistors yet since I had none at hand when soldering the board. They will be added!

Functionality
With this instrument you are able to preset two temperatures with two rotary dials. One upper limit, and one lower limit. When the “on”-button is pressed, the rgb led will light up in either of it’s three colors (red, green, blue – RGB). Red light means that ambient temperature is above your upper limit and blue light means that ambient temperature is below lower limit. Green light indicates that you are within both limits. The instrument is only turned on while checking led color, so battery life is ~forever.

The circuit
The main parts of this circuit is the 100K Ohm NTC thermistor and the LM393N dual comparator. A thermistor is a temperature dependent resistor, which resistance increases linearly with its surrounding temperature. The idea is to make three voltage dividers:
1. From potentiometer (pot) 1, and a fixed value resistor (v1)
2. From pot 2, and a fixed value resistor (v2)
3. From a thermistor and a fixed value resistor (v3)

v1 and v2 will increase and decrease depending on which way the pot is turned. Voltage v3 will vary depending on the NTCs surrounding temperature. What we want to do is compare both voltage v1 and v2 to v3. If v1 drops below v3, output on comparator #1 will drop to 0v, and start sinking current for the common anode rgb led “red” pin (from now on called the red cathode). Likewise, if v2 drops below v3, output on comparator #2 drops to 0v and starts sinking current for the blue cathode.

Now, if both comparator outputs are high, we know that we must be in between both set points, and need to sink current on the green cathode on the rgb led. This is solved by making a NAND-gate with two general purpose NPN transistors. A NAND-gate has two inputs and one output. The output is low only when both inputs are high The output is high on all other conditions. To the left you see the schematic of a NAND gate and the transistor equivalent. For the transistor equivalent to work exactly like real NAND-gate you will need an extra pull-up resistor for the output to go high on the correct conditions, but this is not needed in our case here.

Further down you can see the whole schematic. Please note that not all potentiometers nor NTC thermistors are alike, and this circuit is designed to match the values of what I had on hand.

Notes
- Thermistor (lower left corner). Not to be confused with a regular resistor!
- LM393N. DIP 8 package IRL, but pin-outs on schematic is not “comparable” (hah…).
- R7, the LED series resistor. This is the common series resistor for all cathodes, I’m allowing this because only one color is to be lit at the same time.
- R12, R13 (upper left corner). Pull-up resistors on the comparator outputs are needed for the comparator to be able to switch between Vcc and GND.
- R8-R11 (at the transistors). Biasing- and base resistors to keep transistor base voltages at the right level, and to ensure a fully switched off transistor when comparator outputs are low.
- SW1 (top). In my circuit this is a momentary switch, you can use whatever, but remember that this instrument does not need to be switched on while in use or while taking measurements. The thermistor resistance will increase and decrease by temperature even though no voltage is applied.

Here is another two pictures of the insides of the instrument and a demo video.