The Tinusaur Online Store Opens

Tinusaur Starter

Finally, our online store is up and running.

We received some emails asking if we could offer the boards and the parts for purchasing … so we did it. We have to admit that it took us some time to arrange everything but some of the circumstances were beyond our control.

At the moment we have only one product listed – that’s the Tinusaur Starter.

Go to this tinusaur.storenvy.com/products/6076006-tinusaur-starter link if you’d like to buy it.

Tinusaur Starter Buy at Storenvy

We have put up for sale very small batch of those starter kits as we don’t know what the interest will be. Please note that at the moment we don’t do this as a business and we do not make any profit – the sale only covers our expenses.

More information about the Tinusaur Starter kit is available at the Tinusaur Starter page.

IMPORTANT: This is offered as a kit which means that you have to assemble it yourself.

We chose Storenvy for our shopping site and we think that it was a good choice – it’s easy to setup and use but also provides all the functionality that we need at this stage. You can pay for your orders with PayPal.

 

February: Quick update

Tinusaur Project Milestones

This is quick update for what is happening in the lab.

Tinusaur Proto

And by the way, our project was featured on OSHPark Blog, here’s the link … http://blog.oshpark.com/2014/02/staff-picks-for-the-week-of-2-february-2014/. Very glad to see that people are interested in this project.

As follow up to our first Tutorial 001 we are planing to put another one – Tutorial 002, probably about how to connect a push-button to the board and receive input from it.

Tinusaur Starter: We are making a beginners kit

Tinusaur Starter Kit

To start making things with the Tinusaur you need the board, the parts, a programmer with a cable and couple of LEDs to make your first blinking lights program for ATtiny85 microcontroller.

Tinusaur Starter Kit for Beginners PartsWe’re ordering the PCBs and the parts from the manufacturers and it seems that the total cost for the full package will be 8 to 9 USD. Once we have everything here we’ll run a small test sale to see what’s the interest in the kit. The estimated cost for delivery of the kit to any country in the world is about 2 USD. So the total cost to get it would be 10 to 11 USD – very affordable for everyone.

Here is a list of everything that will be included in the Tinusaur Starter:

Name Description
PCB Tinusaur Board
MCU, Attiny85 Atmel AVR ATtiny85 microcontroller
Socket, DIP-8 DIP-8 socket for MCU
H1, Header Header 2×4, Female
H2, Header Header 2×5, Female
ISP, Header Header 2×5, Male, for ISP
RESET, Button Tactile push button, for RESET
Power, Header Header 1×2, Male, for external power
Battery, Header Header 1×2, Male, for battery power on/off
Battery, Jumper Jumper, 2-pin, for battery power on/off
C1, Capacitor Capacitor 100uF, Low profile 5×5 mm
C2, Capacitor Capacitor 100nF, Small
R1, Resistor Resistor 10K, Small, 1/8W
Battery holder Battery holder for CR2032
Battery 3V Battery 3V, CR2032
LED1 LED, 3mm, red
LED2 LED, 3mm, green
Resistor (LED1) Resistor 330 ohm, Small, 1/8W, for LED
Resistor (LED2) Resistor 330 ohm, Small, 1/8W, for LED
Header (LED1) Header 1×2, Male, for LED
Header (LED2) Header 1×2, Male, for LED
ISP Programmer USB ASP, with 10-pin connector and cable
Packaging Packaging bag, plastic

Check more often Twitter, Facebook, Google+ and The Tinusaur Project site for news about this kit.

Tutorial 001: Blinking LED

Tinusaur Tutorial 001: Blinking LED

UPDATE: New version of this tutorial is available on the Tutorial 001: Blinking LED x1 page.

Tinusaur Tutorial 001: Blinking LED

This is a very simple tutorial on how to make a LED blinking.

Since the Tinusaur board is a very standard ATtiny breakout board this could be applied to almost any such other board.

The code was tested to work with ATtiny13, ATtiny25, ATtiny45, and ATtiny85 but will probably work with other chips too.

We assume that the Tinusaur board is already assembled, successfully; connected through the ISP programmer to the computer; and development environment. It is not the subject of this tutorial how to assemble the board or how to setup a development environment.

The LED should be connected on pin 2 of the ATtiny – this is PB3 – through a resistor, and to the GND.

The LED, marked as D1, is just a standard light-emitting diode.

The resistor, marked as R1,  is 270 to 330 ohm.

The most important fragment of the code is this:

	while (1) {
		PORTB |= (1 << LED_PORT);
		_delay_ms(200);
		PORTB &= ~(1 << LED_PORT);
		_delay_ms(400);
	}

What it does is this:

  1. Start an infinite loop.
  2. Set the LED wire signal to “1” – that will make it to light.
  3. Wait a little – 200 milliseconds.
  4. Clear the LED wire signal to “0” – that will turn it off.
  5. Wait a little -400 milliseconds.
  6. Do it again.

Here is the entire source code:

/**
 * The Tinusaur Project
 *
 * Tutorial 001: Blinking LED
 *
 * file: main.c
 * created: 2014-01-04
 *
 **/

#include <avr/io.h>
#include <util/delay.h>

// ====================================
//                ATtiny
//               25/45/85
//              +--------+
//            --+ o  Vcc +------------
//  LED - PB3 --+        +--
//            --+        +--
//  ------------+ GND    +--
//              +--------+
// ====================================

// Define the I/O port to be used for the LED.
// This a number between 0 and 7 that tells which bit to use.
#define LED_PORT PB3

int main(void) {

	// Set the LED port number as output.
	// The DDRB is the data direction for port B.
	// This ...
	//  - shifts the "1" on left to the desired position and ...
	//  - does bitwise "OR" with the value in the port register.
	DDRB |= (1 << LED_PORT);

	// Start infinite loop.
	// (this is how most programs work)
	while (1) {

		// Set the LED bit to "1" - LED will be "on".
		PORTB |= (1 << LED_PORT);

		// Wait a little.
		// The delay function simply does N-number of "empty" loops.
		_delay_ms(200);

		// Set the LED bit to "0" - LED will be "off".
		PORTB &= ~(1 << LED_PORT);

		// Wait a little.
		_delay_ms(400);

		// Do it again ...
	}

	// Return the mandatory for the "main" function value.
	return (0);
}

Copy the code above to your “main.c” file.

The source code could be also found on Bitbucket at this address: https://bitbucket.org/tinusaur/tutorials/src/1f61873ae382/tut001/src/main.c.

The circuit schematics, even though very simple, was drawn on 123d.circuits.io and it is available at this address: http://123d.circuits.io/circuits/76781.

The Tinusaur Board Designing Principals

In this post are discussed some of principals used while designing this board.

Size and form factor

The goal of making this board is not to have a smaller or the smallest PCB that runs on ATtiny. The goal is to have a board that could be used for prototyping simple projects as well as fitting reasonable small (or large, depending on the view) circuits on an additional shield board.

Headers

There are 2 header – one 2×4 – H1 and another one 2×5 – H2.

The idea is that all the outer pins are GND while all the inner pins are connected directly to the MCU. The longer header H2 has its top-left pin connected to the Vcc like the 2nd-row one on the left. That gives us one more power source wire.

MCU

This board could work with the smaller Atmel AVR ATtiny controllers such as ATtiny 25/45/85, ATtiny13 as well as most of their variations – as long as they are in DIP-8 case.

Programming

The programming is done through the standard 10-pin ISP connector using any compatible AVR ISP programmer. On the diagram below it is marked as PC.

The connector is placed on the board in such a way so it could be chopped off if not needed and make the board little smaller. The programming probe, marked as PP on the diagram below, has holes that could help in the cutting. In case you need to connect the board to a programmer again at later time you can solder some wires to what’s left of the probe.

Board

Technical parameters: 2 layer board of 0.90×1.40 inches (22.96×35.66 mm).

There are 4 mounting holes marked as MH on the diagram below.

Power

During the development the board could be powered through the ISP programmer.

External power source could be connected to the board through a jumper marked as PS on the diagram below.

There is an optional button-cell battery mount on the back of the board, marked as BM on the diagram below. The battery could be switched on and off using the jumper that is marked as BS on the diagram.

Areas

There are 4 areas that a Tinusaur board could be divided to: A1, A2, A3, A4. That is applicable for the actual Tinusaur main board as well as any shield boards one could produce.

A1, the bottom part of the board:

  • this is the area where the RESET button is placed on the main board.
  • for a shield board that area could be used to put some components and produce a simple circuit.

A2, the mid of the board – heads:

  • there are 2 header – one 2×4 and another one 2×5, they are different for a reason.
  • on the main board, between the headers, is placed the MCU.
  • on a shield board, between the headers, could placed a 8-pin chip or other components.

A3, the top part of the board:

  • there are the minimum required components for the MSU to work – 2 capacitors for the power source and one pull-up resistor for the RESET.
  • jumper for external power.
  • jumper to switch on/off battery.

A4, tip of the board:

  • standard ISP programming connector.

Additionally …

A5, the other side of the board:

  • there is optional cell-button battery mount.

Tinusaur Reference Design
Tinusaur Reference Design

Tinusaur Proto v0.1 m2 - Schematics
Tinusaur Proto v0.1 m2 – Schematics

The new prototype PCBs just arrived from OSHPark

Tinusaur PCB

Tinusaur prototype PCBs from OSHPark
Tinusaur prototype PCBs from OSHPark

The new prototype PCBs just arrived from OSHPark – great quality as usual.

I noticed that there are only few things that I may change before call it official: slightly move some components around so they fit better and become easier to solder; add one jumper for switch on/off the optional button cell battery on the bottom of the board; make some pads and holes larger; … and few other things.

The schematics available on 123d.circuits.io website at this address: http://123d.circuits.io/circuits/58269.

Tinusaur prototype schematics
Tinusaur prototype schematics

The board is shared on OSHPark website at this address: http://oshpark.com/shared_projects/bFNU3LQB.

Tinusaur prototype PCB
Tinusaur prototype PCB

Oscilloscope-like Circuit – Preview

This is a oscilloscope-like circuit for the Tinusaur, it is not a real oscilloscope but could be used as a base for one.

It is built on top of the Tinusaur board (Atmel AVR ATiny85) and Nokia 3310/5110 LCD (PCD8544 controller).

There is also simple preamplifier for the electret microphone connected to the ADC of the MCU.

The audio signal source is combination of my DSO Quad (it has built-in signal generator) and a speaker.

Tinusaur powers a tiny vibrating robot

Vibrating robot chassis

Here it is – the first Tinusaur powered robot.

This is a vibrating robot that could turn left, right, and move forward.

I decided to build that after watching a video on YouTube about the Kilobot project from Harvard University. Mine is much simpler and a lot less capable. But hey, that’s the first version only. 🙂

First I made a testing chassis for the vibrating motors. As it is seen in the picture they are wired (connected with a thin copper cable) to a battery – this allowed me to make some experiments before deciding how to put them on the final version of the board. It turned out that they should be in angle. I decided to put them in 90 degrees.

Vibrating robot chassis

So, I made another chassis with the 2 motors positioned in 90 degrees (2 x 40 degrees)

I used a double-sided prototyping board and the motors’ contacts fitted nicely into the holes, no soldering was necessary – I just fixed them to the board with isolated wires.

On the top of the chassis, I tied a shield-like board that connects motors to the MCU board. Later I may need to add some components on that shield board, like a driver for motors, sensors, etc.

The Tinusaur – Prototype Board

For the “brain” of this bug, I used one of the prototype boards of the Tinusaur based on Atmel AVR ATtiny25, coupled with a 2xAAA package for batteries.

At the moment the motors are connected directly to the output pins of the MCU, there are no drivers. It works fine for now but may need to change.

The code for this experimental build is very simple – it just turns on and off 2 output pins on the MCU.

#include <avr/io.h>
#include <util/delay.h>

#define MOTOR_PORT PB3
#define MOTOR_PORT PB4

int main(void)
{
  DDRB |= (1 << MOTOR_PORT);
  DDRB |= (1 << MOTOR_PORT);

  while (1) {
    PORTB |= (1 << MOTOR_PORT);
    PORTB &= ~(1 << MOTOR_PORT);
    _delay_ms(3000);

    PORTB &= ~(1 << MOTOR_PORT);
    PORTB |= (1 << MOTOR_PORT);
    _delay_ms(3000);

    PORTB |= (1 << MOTOR_PORT);
    PORTB |= (1 << MOTOR_PORT);
    _delay_ms(8000);
 }

  return (0);
}

Problems

The 2 vibrating motors, even though I bought them together, do not work the same way. That creates some difficulties controlling the direction of the bot – it turns well in one direction but not that well in the other. There are even bigger problems moving forward.

Tinusaur powered vibrating robot

In the next version, I should definitely make changes in the vibrating motors – use some of those button-like ones and also change their angle. A friend of mine suggested that I should probably play more with the “legs” as they are crucial for the movements with which I agree.

The battery is too big, but the button cell battery is not enough to power the MCU and the motors for a long time, so I should probably think of another power source.

There is a short video on YouTube that shows more photos of how I built this with some footage at the end of the robot moving around.

Any comments and suggestions are really appreciated.

🙂

Tinusaur Proto v0.1 m1 – Prototyping and Design Considerations

I have finally managed to finish the first version of the schematics and PCB‘s and to order the first 3 pieces. This work is based on some previous experiments and designs.

20131108_proto_01sc580x380fx

Schematics

The schematics is nothing special – it is the well known minimal configuration for the ATtiny plus just few addition components – some of them optional.

The required components are the 2 capacitors between Vcc/GND and the 10K resistor on the RESET wire.

There is RESET push-button connected to the micro-controller.

The micro-controller connects to the outside world through 2 headers – H1 an H2. They are in two different sizes for number of rasons: first – to have more connections available for wires, and second – to make sure we won’t mistake H1 and H2.

Next to the headers there is 1×2 connector for external power source.

There is an optional battery for application where built-in power source is needed.

20131108_proto_02sc324x440fx

PCB

The PCB is a fork of my previous work on a simple header board.

There are 4 holes in the corners in case the board should be fixed to another object.

On each side of the IC there are 2-row headers – on 2×4 and the other 2×5.

External power source connector is put along with the H2 header.

The ISP connector is at the top of the board. Between it and the rest of the board there is 1×6 header-like probe – this could be used for testing as well as for easier cutting off the ISP part of the board in case is not (or no longer) needed.

The pads for the optional battery are on the bottom.

The size of the board is approximately 24×36 mm.

The schematics available on 123d.circuits.io website at this address: http://123d.circuits.io/circuits/58269.

The Tinusaur – What is it

Briefly, the Tinusaur is a minimal micro-controller hardware configuration based on Atmel AVR ATtiny family of products and more specifically those with DIP-8 case such as ATtiny25/ATtiny45/ATtiny85, ATtiny13 as well as their variations.

The goal of the Tinusaur project is to have a simple, cheap and accessible quick-start platform for everyone interested in learning and creating things.

There is more information on the About page.