w12101
Ouder en wijzer
hey kan iemand mij helpen ik heb een attiny 2313
ik wil als er spanning op PD0 staat dat PB7 aan gaat
Technokiddy
Zegt die AVR: Dat Pic je toch niet?!
Bert_mc
Suffering from wiseass oneliner blackout
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?
flipflop
"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein
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.
w12101
Ouder en wijzer
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
???????

[Bericht gewijzigd door w12101 op (15%)]
pros
Prosper, yop la boum, c'est le roi du macadam (aldus Maurice Chevalier)
#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%)]
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%)]
pros
Prosper, yop la boum, c'est le roi du macadam (aldus Maurice Chevalier)
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...
w12101
Ouder en wijzer
oke ik heb de pull up extern toegepast maar ik zal intern ook ff proberen
maar het is gelukt super bedankt
buckfast_beekeeper
Van Lambiek wordt goede geuze gemaakt.
w12101
Ouder en wijzer
Op 3 september 2011 20:20:26 schreef buckfast_beekeeper:
@prosIs het niet de pull up van PD0 die moet geactiveerd worden?
volgensmij ook
w12101
Ouder en wijzer
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
pros
Prosper, yop la boum, c'est le roi du macadam (aldus Maurice Chevalier)
Op 3 september 2011 20:35:17 schreef w12101:
kun je inplaats vanif ((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.
w12101
Ouder en wijzer
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%)]
pros
Prosper, yop la boum, c'est le roi du macadam (aldus Maurice Chevalier)
Als je 2 uitgangen nodig hebt, moet je ze allebei als zodanig instellen met DDRx.
Post anders je code eens...
w12101
Ouder en wijzer
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%)]
pros
Prosper, yop la boum, c'est le roi du macadam (aldus Maurice Chevalier)
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
}
}