Gyro, accellerometer och kompass i Arduino

Posted on augusti 12, 2012 — 2 kommentarer ↓

IMU står för inertial measurement unit och innebär kort en enhet som känner av riktning, hastighet och gravitationskrafter. De sitter exempelvis i telefoner för att rotera skärmen beroende på i vilken vilken man håller den. De går att köpa från Sparkfun eller om man är sparsam från ebay. De består oftast av chip-kombinationen ITG3205 (gyro), ADXL345 (accellerometer) och HMC5883L (kompass). Att använda varje chip var för sig ger inte speciellt mycket men kombinationen ger desto mer. En video visar detta bättre (dock med en annan IMU):

Det finns tyvärr relativt dålig dokumentation till hur man får igång en IMU i Arduino varför jag här publicerar ett enkelt exempel.

Andra steget till en självbalanserande robot

Posted on juni 23, 2012 — Inga kommentarer ↓

Jag har nu fått tillräckligt många delar för att börja montera roboten.

Jag blev tvungen att borra upp hålen något för att få dem att passa M3.

Accellerometern sätts så nära motoraxeln som möjligt.

Smart grej för att dra åt alla muttrar är att ta en skruvdragare, en bit tejp och därefter snurra den gängade stången. Håll fast muttern med fingrarna och låt borrmaskinen göra jobbet. Annars tar det ett bra tag att få dit alla 24 muttrar.

Såhär ser den ut just nu:

Taggad med: självbalanserande robot

Ytmonterad Arduino Uno med TQFP32 adapter

Posted on juni 19, 2012 — Inga kommentarer ↓

Jag ville testa att löda ytmonterat och köpte mig därför adapter från TQFP32 till vanlig dip att sätta i breadboard.

Skaffa adapter från TQFP32 till dip. Chip att löda fast är i det här fallet en Atmega328P-AUR.

Tänk på att det är lättare att löda med flux:

Såhär ser det ut när man alla ben och headers sitter på plats:

Montera på breadboard och bränn in Arduino Uno bootloader:

Klart. Atmega328P-AUR på en breadboard med Arduino Uno bootloader:

Förbättrad hårdvara för att styra Roomba

Posted on juni 14, 2012 — 2 kommentarer ↓

Förbättrade nyligen hårdvaran för att fjärrstyra min dammsugare över internet. Tidigare använde jag ett helt Arduino Uno-kort vilket är overkill. Bättre och snyggare blir det att göra det direkt på en breadboard. Video när det fungerar (med lite annan hårdvara).

1. Koppla upp Atmega328 på breadboard för att få en Arduino Uno.

2. Dra kablar från varje knapp på fjärrkontrollen.

3. Sätt dit ett gäng transistorer. En för varje knapp du vill fjärrstyra. Kom ihåg att kombinera jord för breadboard och fjärrkontrollen. Jag satte också dit några lysdioder för att lättare se vilket kommando som skickas.

4. Tejpa kablarna så att de sitter på plats.

5. Tejpa fast breadboard på fjärrkontrollen. Detta gör den mer intakt och risken för att kablar lossnar minskar.

6. Koppla in till datorn och konfigurera eventghost till att styra roomba.

Taggad med: arduino, hemautomation, roomba

Första steget till en självbalanserande robot

Posted on juni 9, 2012 — Inga kommentarer ↓

Nu ikväll gjorde jag cad och beställde delar till att göra en egen självbalanserande robot. Kommer att använda Arduino som mikroprocessor och en liten 6 degrees of freedom som tilt-sensor.

Cadden på bilderna är inte helt klar men jag tror att de flesta delar är på sin rätta plats.

Uppdatterar med nya blogginlägg allt eftersom framsteg blir gjorda.

[Uppdatering 2012-06-12] Skruvförband på plats

La till skruvförband till motorfäste, hjul och de stängerna. Uppdaterade bilder:

Taggad med: självbalanserande robot

Standalone Arduino med en Atmega328

Posted on juni 6, 2012 — Inga kommentarer ↓

Att sätta ihop sin egen Arduino på en labbplatta är ingen större konst. Visar här några illustrationer som förklarar hur man gör. Du kan köpa ett arduino-kit från mät.se för att få allt du behöver.

Enklaste konfigurationen som kräver en ftdi-kabel:

Vill man kunna mata denna koppling med ström från ett batteri lägger man bara till en några få komponenter. Finns att köpa här.

Istället för en ftdi-kabel kan man sätta dit en usb-modul såhär. Länk till usb-modul.

Klistermärken till Atmega328P-PU, Atmega328P-PN

Posted on juni 5, 2012 — Inga kommentarer ↓

För att snabbare se vilka portar som är vilka. Skriv ut arket nedan:
Klistermärke Arduino Atmega328

Komponenter finns här:

ATMEGA328-PU
ATMEGA328P-PU (drar lite mindre ström)

Du kan också köpa Atmega med Arduino bootloader och klisterlapp:

För att göra detta själv så är det bara att klippa ut och klistra på:

Taggad med: arduino, atmega

Bränn Arduino bootloader till Atmega328-PU

Posted on juni 4, 2012 — Inga kommentarer ↓

Jag köpte ett gäng nya Atmega328-PU. Eftersom det finns två varianter av detta mikrochip nämligen Atmega328p-pu och Atmega328-pu. P efter 328 innebär ”pico-power” vilket betyder att den drar mindre ström. När man försöker bränna en bootloader ett icke pico-power-chip så får man felmeddelande om ogiltig signatur:

Expected signature for ATMEGA328P is 1E 95 0F Double check chip, or use -F to override this

Snabbaste sättet att lösa detta är att lägga till non-pico-power som en Arduino-typ. Gå till mappen där Arduino IDE är installerat. Öppna filen /hardware/tools/avr/etc/avrdude.conf. Lägg till detta:

#------------------------------------------------------------
# ATmega328
#------------------------------------------------------------

part
    id			= "m328";
    desc		= "ATMEGA328";
    has_debugwire	= yes;
    flash_instr		= 0xB6, 0x01, 0x11;
    eeprom_instr	= 0xBD, 0xF2, 0xBD, 0xE1, 0xBB, 0xCF, 0xB4, 0x00,
			  0xBE, 0x01, 0xB6, 0x01, 0xBC, 0x00, 0xBB, 0xBF,
			  0x99, 0xF9, 0xBB, 0xAF;
    stk500_devcode	= 0x86;
    # avr910_devcode	= 0x;
    signature		= 0x1e 0x95 0x14;
    pagel		= 0xd7;
    bs2			= 0xc2;
    chip_erase_delay	= 9000;
    pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
		 "x x x x x x x x x x x x x x x x";

    chip_erase = "1 0 1 0 1 1 0 0 1 0 0 x x x x x",
		 "x x x x x x x x x x x x x x x x";

    timeout	= 200;
    stabdelay	= 100;
    cmdexedelay	= 25;
    synchloops	= 32;
    bytedelay	= 0;
    pollindex	= 3;
    pollvalue	= 0x53;
    predelay	= 1;
    postdelay	= 1;
    pollmethod	= 1;

    pp_controlstack =
	0x0E, 0x1E, 0x0F, 0x1F, 0x2E, 0x3E, 0x2F, 0x3F,
	0x4E, 0x5E, 0x4F, 0x5F, 0x6E, 0x7E, 0x6F, 0x7F,
	0x66, 0x76, 0x67, 0x77, 0x6A, 0x7A, 0x6B, 0x7B,
	0xBE, 0xFD, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00;
    hventerstabdelay	= 100;
    progmodedelay	= 0;
    latchcycles		= 5;
    togglevtg		= 1;
    poweroffdelay	= 15;
    resetdelayms	= 1;
    resetdelayus	= 0;
    hvleavestabdelay	= 15;
    resetdelay		= 15;
    chiperasepulsewidth	= 0;
    chiperasepolltimeout = 10;
    programfusepulsewidth = 0;
    programfusepolltimeout = 5;
    programlockpulsewidth = 0;
    programlockpolltimeout = 5;

    memory "eeprom"
	paged		= no;
	page_size	= 4;
	size		= 1024;
	min_write_delay = 3600;
	max_write_delay = 3600;
	readback_p1	= 0xff;
	readback_p2	= 0xff;
	read = " 1 0 1 0 0 0 0 0",
	       " 0 0 0 x x x a9 a8",
	       " a7 a6 a5 a4 a3 a2 a1 a0",
	       " o o o o o o o o";

	write = " 1 1 0 0 0 0 0 0",
	      	" 0 0 0 x x x a9 a8",
		" a7 a6 a5 a4 a3 a2 a1 a0",
		" i i i i i i i i";

	loadpage_lo = " 1 1 0 0 0 0 0 1",
		      " 0 0 0 0 0 0 0 0",
		      " 0 0 0 0 0 0 a1 a0",
		      " i i i i i i i i";

	writepage = " 1 1 0 0 0 0 1 0",
		    " 0 0 x x x x a9 a8",
		    " a7 a6 a5 a4 a3 a2 0 0",
		    " x x x x x x x x";

	mode		= 0x41;
	delay		= 20;
	blocksize	= 4;
	readsize	= 256;
    ;

    memory "flash"
	paged		= yes;
	size		= 32768;
	page_size	= 128;
	num_pages	= 256;
	min_write_delay = 4500;
	max_write_delay = 4500;
	readback_p1	= 0xff;
	readback_p2	= 0xff;
	read_lo = " 0 0 1 0 0 0 0 0",
		  " 0 0 a13 a12 a11 a10 a9 a8",
		  " a7 a6 a5 a4 a3 a2 a1 a0",
		  " o o o o o o o o";

	read_hi = " 0 0 1 0 1 0 0 0",
		  " 0 0 a13 a12 a11 a10 a9 a8",
		  " a7 a6 a5 a4 a3 a2 a1 a0",
		  " o o o o o o o o";

	loadpage_lo = " 0 1 0 0 0 0 0 0",
		      " 0 0 0 x x x x x",
		      " x x a5 a4 a3 a2 a1 a0",
		      " i i i i i i i i";

	loadpage_hi = " 0 1 0 0 1 0 0 0",
		      " 0 0 0 x x x x x",
		      " x x a5 a4 a3 a2 a1 a0",
		      " i i i i i i i i";

	writepage = " 0 1 0 0 1 1 0 0",
		    " 0 0 a13 a12 a11 a10 a9 a8",
		    " a7 a6 x x x x x x",
		    " x x x x x x x x";

	mode		= 0x41;
	delay		= 6;
	blocksize	= 128;
	readsize	= 256;

    ;

    memory "lfuse"
	size = 1;
	min_write_delay = 4500;
	max_write_delay = 4500;
	read = "0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0",
	       "x x x x x x x x o o o o o o o o";

	write = "1 0 1 0 1 1 0 0 1 0 1 0 0 0 0 0",
	      	"x x x x x x x x i i i i i i i i";
    ;

    memory "hfuse"
	size = 1;
	min_write_delay = 4500;
	max_write_delay = 4500;
	read = "0 1 0 1 1 0 0 0 0 0 0 0 1 0 0 0",
	       "x x x x x x x x o o o o o o o o";

	write = "1 0 1 0 1 1 0 0 1 0 1 0 1 0 0 0",
	      	"x x x x x x x x i i i i i i i i";
    ;

    memory "efuse"
	size = 1;
	min_write_delay = 4500;
	max_write_delay = 4500;
	read = "0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0",
	       "x x x x x x x x x x x x x o o o";

	write = "1 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0",
	      	"x x x x x x x x x x x x x i i i";
    ;

    memory "lock"
	size = 1;
	min_write_delay = 4500;
	max_write_delay = 4500;
	read = "0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0",
	       "x x x x x x x x x x o o o o o o";

	write = "1 0 1 0 1 1 0 0 1 1 1 x x x x x",
	      	"x x x x x x x x 1 1 i i i i i i";
    ;

    memory "calibration"
	size = 1;
	read = "0 0 1 1 1 0 0 0 0 0 0 x x x x x",
	       "0 0 0 0 0 0 0 0 o o o o o o o o";
    ;

    memory "signature"
	size = 3;
	read = "0 0 1 1 0 0 0 0 0 0 0 x x x x x",
	       "x x x x x x a1 a0 o o o o o o o o";
    ;
;

Hitta därefter filen /hardware/arduino/boards.txt och lägg till:

##############################################################

uno328.name=Arduino Uno w/ ATmega328 (non-P)
uno328.upload.protocol=arduino
uno328.upload.maximum_size=32256
uno328.upload.speed=115200
uno328.bootloader.low_fuses=0xff
uno328.bootloader.high_fuses=0xde
uno328.bootloader.extended_fuses=0x05
uno328.bootloader.path=optiboot
uno328.bootloader.file=optiboot_atmega328.hex
uno328.bootloader.unlock_bits=0x3F
uno328.bootloader.lock_bits=0x0F
uno328.build.mcu=atmega328
uno328.build.f_cpu=16000000L
uno328.build.core=arduino
uno328.build.variant=standard

Därefter ska det från Arduinos IDE se ut såhär:

Komponenter finns här:

ATMEGA328-PU
ATMEGA328P-PU (drar lite mindre ström)

Du kan också köpa Atmega med Arduino bootloader och klisterlapp:

Taggad med: arduino, atmega, bootloader, isp

Gjorde min egen bootloader ISP till Arduino

Posted on juni 2, 2012 — Inga kommentarer ↓

Eftersom jag inte har en egen programmerare för att bränna bootloaders till Atmega-chip valde jag att göra en egen. Såhär blev den:

Eftersom jag använder en dip-socket kan jag lätt programmera massvis av chip efter varandra om jag vill. Det är bara att knäppa loss och stoppa i nästa.

En fördel med att ha en dedikerad programmerare till Arduino är att man inte behöver dra kablar från en officiell Uno varje gång som man vill bootloada en ny Atmega.

Arduinos webbplats har också några egna guider som beskriver mer utförligt: http://arduino.cc/en/Tutorial/ArduinoISP

Komponenter finns här:

ATMEGA328-PU
ATMEGA328P-PU (drar lite mindre ström)

Du kan också köpa Atmega med Arduino bootloader och klisterlapp:

Taggad med: arduino, atmega, bootloader, isp

Kontrollera Roomba från en webbplats med hjälp av Arduino

Posted on mars 13, 2012 — Inga kommentarer ↓

Vem har inte velat dammsuga när man inte är hemma? Den tekniken jag kommer använda är fulhack med att plocka isär fjärrkontrollen till Roomba och koppla in den på en Arduino UNO. För att styra Arduino från datorn via USB använder jag Messenger och låter Eventghost sköta all kommunikation med Serieport-pluginet.

Video:

Hur du gör

1. Skruva isär fjärrkontroll. Löd fast trådar på de knappar som du vill styra.
roomba_hacking_arduino_2

2. Jordad knapp betyder nedtryckt knapp. Jag kopplade ihop jord på Arduino och jord i fjärrkontrollen. Mellan utportarna på Arduino och knapparna satte jag transistorer. En 1:a (5 V) ut från Arduino sätter transistorn i till-läge. Transistorn sluter då mellan den sammankopplade jorden och knappen. Fjärrkontrollen kommer att uppfatta jord på en tryckknapp och luras att tro att det är en knapptryckning. [Uppdatering 2012-06-14] Skrev en förbättrad guide för hårdvara.
roomba_hacking_arduino_1

3. Ladda över kod. Allt är från Messenger till Arduino. Lägger upp en kopia här . Programmet jag kör är väldigt enkelt. Med serieporten skriver man vilken port man vill sätta hög exempelvis ”w d 9 1″ för write digital port 9 on.

4. Konfigurera Eventghost. Lägg till Serieport-plugin. Kommer inte gå igenom detta detaljerat men bilderna här nedan borde förklara tillräckligt:
serial_out_roomba_arduino

serial_out_roomba_2

5. Förklarar inget om webbservern och gui heller eftersom jag gjort ett inlägg om det tidigare.

Taggad med: arduino, hemautomation, roomba