Hjelp til å starte med programerbare kretser

[Nedward]

Jeg har i lengre tid vært interisert i å lære litt om programerbare kretser (AVR). Men problemet er at jeg ikke helt vet hvor jeg skal starte.

 

Det jeg har fått med meg er at jeg trenger er:

 

- En "brenner"/programerer (en "dings" for å overføre programmet til kretsen)

- En compiler

- En IC (do'h )

 

Men jeg vet ikke hva som er et greit "kit" for en nybegynner/hobbyist. Det eneste jeg vet er at jeg tenkte jeg skulle starte med litt mindre / enkle brikker. F.eks. ATtiny15.

 

Min fåreløpige plan er å få til en PWM-regulator på sikt, så jeg er vel egentlig ute etter en brikke som er egnet til det, og litt allround bruk (for opplæring).

 

Jeg har også vært innom avrfreaks.net og kikket litt, men jeg må si at jeg fortsatt er like dum når det gjelder AVR.

 

Edit: Kanskje jeg skulle legge til det utstyret jeg har sett meg ut.

 

ATiny15

Programerer/brenner

 

Hvilken compiler jeg skal bruke aner jeg ikke. Men jeg har kikket litt rundt, og kommet fram til at denne ser grei ut til formålet mitt.

Endret 12. november 2007 av Dj_eLmO

[Dr_VingTor]

Krets: ATtiny2313; litt mer stasj å leke seg med, og fremdeles ikke for stor ( kan aldri bli for stor...)

 

Programmer: Last ned AVR Studio fra atmel.com og WinAVR fra et eller annet sted. Du kan nå bruke AVR studio til å skrive C kode og simulere den (noe som er veldig kjekt)

 

Brenner: finnes et hav av de, men om du ikke vil kjøpe en kan du bygge en STK200 kompatibel brenner, vet ikke om den er støttet i AVR studio lengre, men du kan da bruke avr-dude som følger med WinAVR.

 

WinAVR inneholder det av kompilere og ting du trenger, jeg bruker avr-gcc.

[Nedward]

Takk for hjelpen. Du satta meg virkelig igang der.

Det eneste jeg sliter litt med er å bestemme meg for hvilken brikke og programer jeg skal bruke.

 

AVR Studio støtter ikke STK200, men det støtter STK500 (som ikke støtter ATtiny2313). Men det finner jeg vel best ut av selv.

 

Nå gjennstår det bare å lære seg såpass med C# at jeg klarer å lage en funksjonabel PWM-kontroller.

 

Hvordan er det forresten å bruke BASIC til å programere med? Jeg har sett at det er noen kompilere som er for BASIC, er det slik at det bare er enkelte kretser som man kan bruke BASIC på? Eller vil komplimatoren komplimere slik at alle kretsene kan programeres med BASIC?

Endret 13. november 2007 av Dj_eLmO

[Dr_VingTor]

Har ingen erfaring med BASIC, men vil anbefale C/C++ da det er det folk flest bruker og det er dermed lettest å få hjelp da. Selvfølgelig er det en del som vil bruke andre språk siden de kan de fra før og derfor foretrekker de, men om du ikke kan noen spesielt godt fra før vil jeg anbefale C.

 

Selv har jeg en STK500 og det er til god hjelp i utvikling av kode, så om du har råd kan det jo noe å tenkte på. Prisen kan variere mye, så det kan lønne seg å sjekke litt rundt om (elfa, farnell, digikey..., eller andre kontakter som kan skaffe den billig)

STK600 kommer også snart, så om du har tenkt å holde på mye med mikrokontrollere fra atmel i fremtiden kan jo den være aktuell, men den blir en del dyrere.

 

Ellers har jeg (hadde) en AVR Dragon, men spenningsregulatoren på den slapp ut den magiske hvite røyken i helga, så må skaffe en ny spenningsregulatoren for å gjennopplive den... (skal visstnok være ganske mange som har drept dragen sin...)

Synes den er litt sånn halvveis, men JTAG ICE mkII er bare for dyr... håper noen lager en klone av den snart som er billigere.

 

Ellers så laga jeg for noen uker siden en kode for å kontrollere en servo (slik som i RC biler o.l.) som benytter seg av PWM.

 

 

/******************************************************************************
* RC servo control
*
* by VingTor - vingtor krølla frenus dot no
*
* rev 1.0
*
*******************************************************************************
* MCU: ATmega8515
*
* Resorces used:
* Usage:
*
******************************************************************************/

/*** DEFINE ***/
#ifndef F_CPU
#define F_CPU 8000000 /* Hz */
#endif /* F_CPU */

#ifndef RC_settings
#define RC_settings
#define RC_output_port PORTE
#define RC_ddr DDRE
#define RC_input_pin PINE0
#define RC_input_port PINE
#define RC_timer_prescale 64
#define RC_timer_updatetime ((1000000 * RC_timer_prescale) / F_CPU)
#endif /* RC_settings */

#define debug

/*** INCLUDE ***/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

/*** VARIABLES ***/

/*** sub-rutines ***/

#ifdef debug

int main(void)
{	
DDRB = 0xFF;	//Port B as output for debuging
PORTB = 0xFF;

DDRD = 0x00;	//buttons aas input
PORTD = 0xFF;

//usart init, if you want to send debug info to terminal
UBRRH = 0;
UBRRL = 12;	//38400kbps @ 8MHz
UCSRB = ((1<<RXEN)|(1<<TXEN));
UCSRC = ((1<<URSEL)|(3<<UCSZ0));


// enable interrupts
//sei();				

//set up pwm on timer/counter 1 (16 bit)
TCCR1A|=(0<<COM1A0)|(0<<COM1A1)|(0<<COM1B0)|(1<<COM1B1)|
           (0<<FOC1A)|(0<<FOC1B)|(1<<WGM11)|(0<<WGM10);

TCCR1B|=(0<<ICNC1)|(0<<ICES1)|(1<<WGM13)|(1<<WGM12)|
           (0<<CS12)|(1<<CS11)|(0<<CS10);
ICR1 = 20000; //4E20
TCNT1 = 0x0000;
OCR1B = 2000;
OCR1A = 0xFFFF;
TIMSK &= 0x00;


DDRE |= 0x04;	//OC1B output

   while(1)
   {
	if(UCSRA&0x80)
		UDR = UDR;

	//PORTB = 0x00;
	//_delay_ms(1);
	//PORTB = 0xFF;
	//_delay_ms(1);

	while(bit_is_clear(PIND, 0))
	{
		//increase duty cycle
		OCR1B+=1;
		_delay_ms(1);
		//loop_until_bit_is_set(PIND, 0);
	}
	while(bit_is_clear(PIND, 2)) 
	{
		//decease duty cycle
		OCR1B-=1;
		_delay_ms(1);
		//loop_until_bit_is_set(PIND, 2);
    }
}
}

#endif /* debug */

 

 

 

koden er bare skrevet for å få det til å virke (første gang jeg bruker PWM, så var i grunn for å lære hvordan den hardware delen av kontrolleren virker) og er ikke ferdig enda, så i et fullstendig system ville den vært laget sub-rutiner for oppsett o.l. slik at koden kan gjennbrukes i andre prosjekter.

 

PS: ikke bry deg så mye om de define RC... tingene i koden, jeg har ikke brukt det, men har planer om å bruke det en gang i tiden når jeg jobber videre med koden

Endret 13. november 2007 av Dr_VingTor

[lceman™]

Jeg har drevet og lekt litt med Sumobot, og de benytter BASIC stamp-kontrollere.

Helt ålreit å drive med PWM i BASIC, veldig enkelt og lettforståelig.

 

Sånn helt offtopic, så har jeg akkurat anskaffet en Commodore 128, og er pent nødt til å lære meg BASIc igjen nå.