hey kan iemand mij helpen ik heb een attiny 2313
ik wil als er spanning op PD0 staat dat PB7 aan gaat
http://www.uploadarchief.net/files/download/attiny2313_01.gif

Als dit het enigste is wat er moet gebeuren waarom zou je dan een microcontroller gebruiken?

gewoon om uit te proberen

Wat is eigenlijk je vraag? Hoe je dat ding moet programmeren? Of hoe je het als draadje kan misbruiken? Wat weet je er al van af?

assembly of C? of iets anders nog?

Soldeer een draadje tusen PD0 en PB7, ben je ook klaar.

Met andere woorden, beetje rare vraag vind je niet? Welke taal, moet het in? Waarmee programmeer je het?

Als je doel is om AVR's te leren programmeren, kijk eens in de onderstaande link.

Aanvulling op de tekst daar:

-Om de software naar de AVR te sturen gebruikt men AVRDUDE. AVRDUDE kun je gebruiken icm Awesome, een grafische interface voor dit programma, vind ik zelf handiger.

-Hier programmeren ze een andere AVR, dus het kan dat je de poorten die ze gebruiken niet hebt of dat ze anders heten.

http://expand.xs4all.nl/avr/circuit1.html

ik wil het in c programeren
de software heb ik al ik heb ook een programmer en ik weet hoe die werkt
dus
moet ik dan iets van

// als PD0 is hoog 
???????
//dan PB7 aan
???????

http://www.uploadarchief.net/files/download/schema12101.gif

[Bericht gewijzigd door w12101 op (15%)]


#include <avr/io.h>


int main(void)
{
    PORTB |= (1 << PB7);			// Pull-up PB7 activeren <<<<<
    DDRB |= (1 << PB7);				// PB7 als uitgang schakelen
    
    while (1) {
	if ((PIND & (1 << PIND0)) == 0) {	// PD0 laag?
	    PORTB &= ~(1 << PB7);		// Dan PB7 laag
	} else {				// In het andere geval
	    PORTB |= (1 << PB7);		// PB7 hoog
	}
    }
}

Dat zou het moeten doen...

[Regel code toegevoegd]

[Bericht gewijzigd door pros op (11%)]

bedankt ik ga het proberen

Ik zou wel even een avr gcc tutorial opzoeken op internet. Dat kun je de meeste basisdingen zo leren

Edit:
Die schakelaar gaat zo trouwens niet werken. Als je hem sluit gaat de pin naar de 0, maar als je hem opent is er niks dat hem weer naar de 5v trekt. Daarvoor moet je een zogenoemde pullup toevoegen. Een weerstand tussen de plus en pd0.
1kohm oid is prima (luistert niet so nauw)

[Bericht gewijzigd door timberleek op (59%)]

Of misschien eerst een C tutorial.

Ja dat is zo'n beetje hetzelfde, maar de gcc is echt toegespitst op gebruik in de avr.

Op 3 september 2011 19:36:40 schreef timberleek:
maar als je hem opent is er niks dat hem weer naar de 5v trekt.

Goed opgemerkt. Heb de code aangepast, zodat de interne pull-up actief is.

Algemeen: als de TS meteen iets wil zien werken, al is het nog zo eenvoudig, is daar niets op tegen. Als het hem blijft boeien komt hij vanzelf wel op een (avr-gc)c-tutorial uit...

oke ik heb de pull up extern toegepast maar ik zal intern ook ff proberen
maar het is gelukt super bedankt

@pros

Is het niet de pull up van PD0 die moet geactiveerd worden?

Op 3 september 2011 20:20:26 schreef buckfast_beekeeper:
@pros

Is het niet de pull up van PD0 die moet geactiveerd worden?

volgensmij ook

Op 3 september 2011 19:04:19 schreef pros:


#include <avr/io.h>


int main(void)
{
    PORTB |= (1 << PB7);			// Pull-up PB7 activeren <<<<<
    DDRB |= (1 << PB7);				// PB7 als uitgang schakelen
    
    while (1) {
	if ((PIND & (1 << PIND0)) == 0) {	// PD0 laag?
	    PORTB &= ~(1 << PB7);		// Dan PB7 laag
	} else {				// In het andere geval
	    PORTB |= (1 << PB7);		// PB7 hoog
	}
    }
}

Dat zou het moeten doen...

[Regel code toegevoegd]

kun je inplaats van

if ((PIND & (1 << PIND0)) == 0) {

ook dit gebruiken

if PORTB &= ~(1 << PD0); 

Je moet inderdaad de pullups van poort d hebben. Poortb hoeft immers niet omhoog getrokken te worden.

Ik heb overigens begrepen dat de interne pullups redelijk zwak zijn. Dat kan een bron van storing zijn, maar ik weet niet of het echt zo is

Op 3 september 2011 20:35:17 schreef w12101:
kun je inplaats van

if ((PIND & (1 << PIND0)) == 0) {

ook dit gebruiken

if PORTB &= ~(1 << PD0); 

Nee, dat kan je niet. PIND en PORTD zijn verschillende registers.
PIND is een ingangsregister. Daarmee kan je kan je nagaan welke pinnen hoog danwel laag zijn.
PORTD is een uitgangsregister. Als een pin, middens DDRD, als uitgang is geconfigureerd, maak je die pin hoog of laag. Is de pin een ingang, dan schakel je de interne pull-up aan of uit door naar PORTD te schrijven.

En ook dit nog: wanneer een pin als uitgang schakelt, en je maakt zijn plaats in PIND hoog, dan keer je de uitgang om. Hoog wordt laag of andersom.

Wat wèl kan, is PIND0 vervangen door PD0. Of zelfs door 0.

oke maar hoe doe ik dait al ik dit met tweeoutputs wil doen
want ik heb het geprobeerd maar het werd niks

[Bericht gewijzigd door w12101 op (28%)]

Als je 2 uitgangen nodig hebt, moet je ze allebei als zodanig instellen met DDRx.
Post anders je code eens...

Op 3 september 2011 21:39:11 schreef pros:
Als je 2 uitgangen nodig hebt, moet je ze allebei als zodanig instellen met DDRx.
Post anders je code eens...

wat ik nu had was

#include <avr/io.h>
 
 
int main(void)
{
    PORTB |= (1 << PB7) | PORTB |= (1 << PB6);			// Pull-up PB7 activeren <<<<<
    DDRB  |= (1 << PB7) | DDRB |= (1 << PB6);				// PB7 als uitgang schakelen
 
    while (1) {
	if ((PIND & (1 << PD0)) == 0) {	// PD0 laag?
	    PORTB &= ~(1 << PB7);		// Dan PB7 laag
	} else {				// In het andere geval
	    PORTB |= (1 << PB7);		// PB7 hoog
	}

    while (1) {
	if ((PIND & (1 << PD1)) == 0) {	// PD0 laag?
	    PORTB &= ~(1 << PB6);		// Dan PB7 laag
	} else {				// In het andere geval
	    PORTB |= (1 << PB6);		// PB7 hoog
    }

  }
}
 

ik vermoed dat je de input direct aan de output wilt hangen.
dat kan niet op die manier.

PIND & (1<<PIND0) == 0 is hetzelfde als:
PIND & (00000001) == 0
door te 'and-en' met 1 sluit je alle bits uit behalve pin0. iets & 0 is immers nul.
dit wordt vaak gebruikt om alleen bepaalde bits te lezen of te beinvloeden.

als PIND nu 1111 1110 zou zijn, dan zou het ongelijk zijn aan nul (logisch)
maar je wilt alleen weten wat pin 0 is. dus als je alle andere dingen met 0 'and' blijft alleen bit 0 over. de rest wordt dan nul, ongeacht wat het was.
dan zijn de enige 2 mogelijkheden nog 1 en 0.

(1<<PIND0) betekend alleen maar:
neem een 1 en schuif die 'PIND0' plaatsen naar links. de compiler weet hoeveel plaatsen dat zijn.
je zou ook kunnen zeggen (1<<3), dat geeft 1000 oftewel een decimale 8.

maar PIND0 en PD0 bevatten niet de waarde van de werkelijke pin, het is alleen een andere naam voor de 'plaats' in het rijtje, dan kun je de code leesbaar houden.

if PORTB &= ~(1<< PD0)
zal altijd waar zijn. je stopt namelijke en waarde in poortb (&= is een assignment operator). aangezien die actie wel goed zal verlopen kun je er van op aan gaan dat dat waar is.

PORTB &= ~(1 << PD0) 'and' eigenlijk de inhoud van poort b met de waarde rechts en stopt de uitkomst weer in poortb.

maar ~(1<<PD0) is altijd hetzelfde, namelijk not(0000 0001) oftewel 1111 1110.

je zou wel dit kunnen doen:

PORTB |= (PIND << 7)

nu neem je alle waardes van pinD en schuift die 7 plaatsen op. alle onbelangrijke waardes vallen dus automatisch af (verder dan bit7 kun je niet in dit register).
stel dat PIND 01000101 zou zijn, dan zou je alleen die laatste 1 willen doorsluizen, dat gebeurt ook.
namelijk, na 7 keer opschuiven krijg je:
0100010 1000 0000. en dat or je met poortb. en dan wordt de juiste bit hoog. en doordat je or-ed worden de andere bits niet beinvloed

als je een andere bit zou willen hebben kan er wat extra nodig zijn.
stel dat je de waarde van pind4 op poortb6 wilt hebben kan het niet zoals hierboven. je hebt nu immers niet de luxe dat je alle 'overbodige' info weg kan schuiven.
maar zo kan het dan wel:

PORTB |= ((PIND && 0x10) << 2)

door te and-en met 0x10 (0001 0000) hou je alleen de info van pin4 over die je 2 plekken opschuift (pin6) en or-ed met poortb

edit:

en even jouw code:
allereerst, de pullups van poortB
die regel kun je wel weghalen, pullups zijn alleen mogelijk bij ingangen. nu maak je de pinnen meteen hoog. immers maak je uitputs aan (DDRB) en maak je bits in poortb hoog (dus de output)

en je kan het korter opschrijven:
DDRB |= (1 << PB7)|(1 << PB6);

de compiler maakt gewoon 2 losse getallen aan en or-ed die met elkaar. daarna or-ed hij ze met DDRB.

overigens heb je 2x dezelfde code onder elkaar staan, maar hij komt nooit in die 2e while lus.
while(1) is een oneindige lus.

[Bericht gewijzigd door timberleek op (11%)]

Ik moet hoognodig eens leren, wat zorgvuldiger te zijn als ik code post... :-)


#include <avr/io.h>

int main(void)
{
    PORTD |= (1 << PD0) | (1 << PD1);		// Pull-up PD0 en PD1 activeren
    DDRB  |= (1 << PB7) | (1 << PB6);		// PB7 en PB6 als uitgang schakelen
 
    while (1) {
	if ((PIND & (1 << PD0)) == 0) {		// PD0 laag?
	    PORTB &= ~(1 << PB7);		// Dan PB7 laag
	} else {				// In het andere geval
	    PORTB |= (1 << PB7);		// PB7 hoog
	}
 
	if ((PIND & (1 << PD1)) == 0) {		// PD1 laag?
	    PORTB &= ~(1 << PB6);		// Dan PB6 laag
	} else {				// In het andere geval
	    PORTB |= (1 << PB6);		// PB6 hoog
  }
}