OWOWOD – One Wire / One Way Output for Debugging the Tinusaur (Part 2)

Posted on by Neven Boyanov

In my previous post “OWOWOD – One Wire / One Way Output for Debugging the Tinusaur (Part 1)” I wrote how to get a proper reference signal from a serial communication using USB-to-Serial TTL converter.

The Tinusaur Board

The next steps are to generate the same signal but programmatically using the ATtiny85.

And this is what I did …

I used an ATtiny85 board, the Tinusaur – as you may have guessed already, connected with USBasp programmer to the computer.

The PB0 is used as output but any other available port could be used. That could be done by changing the OWOWOD_PORT in the source code below.

The output is connected to the second digital channel of my DSO Quad oscilloscope.

Here is a fragment of the code that generates the output signal …

#define OWOWOD_PORT	PB0	// OWOWOD Port

inline void owowod_init(void) {
	DDRB |= (1 << OWOWOD_PORT);	// Set port as output
	PORTB |= (1 << OWOWOD_PORT);	// Set to HIGH
}

#define OWOWOD_DELAY	23	// Delay for each bit

inline void owowod_delay(void) {
	for (uint8_t i = OWOWOD_DELAY; i != 0; i--) {
		asm volatile ("nop\n\t");
	}
}

void owowod_print_char(uint8_t c) {
	PORTB &= ~(1 << OWOWOD_PORT);	// Set to LOW
	owowod_delay();
	for (uint8_t i = 0; i < 8; i++)
	{
		if (c & 1) {
			PORTB |= (1 << OWOWOD_PORT);	// Set to HIGH
		} else {
			PORTB &= ~(1 << OWOWOD_PORT);	// Set to LOW
		}
		owowod_delay();
		c = (c >> 1);
	}
	PORTB |= (1 << OWOWOD_PORT);	// Set to HIGH
	owowod_delay();
}

int main(void)
{
	owowod_init();
	while (1) {
		owowod_print_char(0x55); // "U"
	}
	return (0);
}

The owowod_init() function sets the port as output and its level to high which is the default for the serial communication.

The owowod_delay() function is a custom delay function that should produce a delay that is equivalent of 1 bit of serial data. This is just an empty loop that I experimentally determined how long it should be.

The owowod_print_char(uint8_t) function outputs one byte of data in serial – starting from the least significant bit of that byte.

To run the test I first started the COMStressTest program and let it output the “U” character (ASCII code in HEX 0x55) indefinitely.

IMPORTANT: All the tests were done with the default settings for the serial COM port which are 9600 bps, 8 bits of data, no parity check and 1 stop bit. This is sometimes denoted as 9600 / 8-N-1 configuration.

Then I ran the C program on the ATtiny.

The graphic on the oscilloscope looked like this …

Serial Debugging Oscilloscope

To get the two signals the same took of course some time to figure out what the timings (the delay between bits) should be.

I am now another step further.

The next step will be to write a simple debugging library for printing strings and numbers.

PREVIOUS PART: OWOWOD – One Wire / One Way Output for Debugging the Tinusaur (Part 1)

NEXT PART: OWOWOD – One Wire / One Way Output for Debugging the Tinusaur (Part 3)

All the OWOWOD source code is available at https://bitbucket.org/tinusaur/owowod/src.

OWOWOD – One Wire / One Way Output for Debugging the Tinusaur (Part 1)

Posted on by Neven Boyanov

I always wanted to be able to write something like this in my code

 debugging_print(&quot;working, x=%i&quot;, x);

… have that running on the micro-controller and see the debugging output on my computer.

The Problem

Unfortunately that is not easy – in fact not possible with the standard tools used to work with the ATtiny85. The problem is this: (1) those micro-controllers have too few I/O ports; and (2) most of the programmers (the one I’m using is USBasp) do not offer that kind of communication between the micro-controller and the computer, i.e. there is no 2-way communication.

There are many solutions to that problem and while looking on Internet I found this article http://www.ernstc.dk/arduino/tinycom.html that points to some of them:

Since the purpose of The Tinusaur Project is learning I decided to write my own.

USB to Serial TTL
USB to Serial TTL Converter

To do that I needed:

The USB-to-Serial TTL is a device that when connected to the USB port of the computer will look to the operating system like a Serial COM Port. Writing data to that COM port will result in transferring that data through the converter and out to the output pin called TxD – in serial form. It work similarly when receiving data from an external source of signal connected to the RxD pin.

I connected the PB0 of the ATtiny85 to the RxD of the USB-to-Serial TTL and did some experiments. Soon I realized that the timing of the signals was critical for this to work and I needed better way to compose the serial data.

Reference Character Generator

First thing – a serial data character generator that I can use as reference – and what could be better than an original USB-to-Serial converter.

I also needed a software that will generate sequence of test characters that I would use as a test signal. First I though of writing a simple Java program that will send the data to the COM port but then I found an application on Internet that does that already – COMStressTest from AGG Software at http://www.aggsoft.com/com-port-stress-test.htm.

COM Stress Test

I specified my testing data in the “Data source” tab as an external file.

The best testing sequence in this case would be string of “U” characters. This is because the generated signal will consist of equal LOW and HI intervals known also as square wave signal.

 ASCII &quot;U&quot; = 0x55 = 01010101

To look more precisely at the signal form and parameters I used an oscilloscope – mine is DSO Quad from Seeedstudio at http://www.seeedstudio.com/depot/DSO-Quad-4-Channel-Digital-Storage-Oscilloscope-p-736.html.

The signal should look like this …

Oscilloscope Serial Signal

That’s all for now.

The next step will be to write some code for the ATtiny that will generate the same sequence – all “U” character and try to make it exactly the same as the reference one.

IMPORTANT: All the tests were done with the default settings for the serial COM port which are 9600 bps, 8 bits of data, no parity check and 1 stop bit. This is sometimes denoted as 9600 / 8-N-1 configuration.

NEXT PART: OWOWOD – One Wire / One Way Output for Debugging the Tinusaur (Part 2)

 

All the OWOWOD source code is available at https://bitbucket.org/tinusaur/owowod/src.