Der nächste Neue + Problem :)

Artur

Neues Mitglied
28. Feb. 2012
4
0
0
Sprachen
Hallo mein Name ist Artur,
ich bin 23 Jahre alt und studiere Elektrotechnik mit Fachrichtung Energietechnik. Bis vor kurzem hatte ich mit µC sehr wenig bis gar nichts zu tun. Ich möchte aber gerne mal über den Tellerrand schauen und beschäftige mich intensiv mit dem Thema. Auf ein Board habe ich verzichtet und dafür mir nur einen USB zu ISP Adapter (mySmartUSBlight) gekauft. Aufbauen tue ich alles auf einem Steckbrett. Als Lern-µC habe ich ein AtMega8, welchen ich in AVR Studio 5 programmiere. Paar kleinere Testprogramme laufen schon. Jetzt ist es an der Zeit mich mit dem Thema ADC zu beschäftigen. Leider hab ich da gleich ein Problem, was ich noch nicht lösen konnte.

Folgender Aufbau:
An PC0 kann ich die Spannung mit Hilfe eines Pots zwischen 0V und 5V variieren. An den PC5-PC1 habe ich LED's angeschlossen um zu überprüfen, ob überhaupt etwas passiert. Wenn ich die Spannungsversorgung zuschalte, erhalte ich auch den Binärcode, welchen ich an den LED's sehen kann. Leider ändert sich nichts, wenn ich am Poti drehe um eine andere Spannung an PC0 anzulegen.

Hier mein Code, ich freue mich über jede Unterstützung.
Code:
/

#include <avr/io.h>
#include <avr/interrupt.h>

void ADCL_auf_PORTC(char Pin_C,char Pin_ADCL);

int main(void)
{
ADMUX |= (0<<REFS1)|(1<<REFS0); //Interne Referenzspannung Vcc
ADMUX |= (0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0); // ADC Kanal 0 PC0
ADMUX |= (0<<ADLAR); //  8 Niederwertigsten Bits werden in ADCL abgelegt

ADCSRA |= (1<<ADEN); // ADC Enable
ADCSRA |= (0<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); // ADC Prescaler = 8
ADCSRA |= (0<<ADIE); // ADC Interrupt Disable
ADCSRA |= (0<<ADFR); // ADC Free Running Disable

DDRC |= (1<<5)|(1<<4)|(1<<3)|(1<<2)|(1<<1)|(0<<0); // PC5 - PC1 = Ausgänge PC0 = Eingang


    while(1)
    {	
		ADCSRA |= (1<<ADSC); // Start der ADC
		while(ADCSRA & (1<<ADSC));
		ADCL_auf_PORTC(0,1); // PORTC.1 = ADCL.0 
		ADCL_auf_PORTC(1,2); // PORTC.2 = ADCL.1 
		ADCL_auf_PORTC(2,3); // PORTC.3 = ADCL.2 
		ADCL_auf_PORTC(3,4); // PORTC.4 = ADCL.3 
		ADCL_auf_PORTC(4,5); // PORTC.5 = ADCL.4 
		ADCSRA &= ~(1<<ADSC); 
					
    }
	
} 


void ADCL_auf_PORTC(char Pin_ADCL,char Pin_C)  // PORTC.PIN_C= ADCL.PIN_ADCL 
{ 
	if (((ADCL>>Pin_ADCL)&1)==1)
        {
			PORTC |= (1<<Pin_C);
			
        }
		else
		{
			PORTC &= ~(1<< Pin_C);
		}			
}
 
Hi Artur,

herzlich willkommen im Forum :flowers:

An AREF kann ich die Spannung mit Hilfe eines Pots zwischen 0V und 5V variieren. An den PC5-PC1 habe ich LED's angeschlossen um zu überprüfen, ob überhaupt etwas passiert. Wenn ich die Spannungsversorgung zuschalte, erhalte ich auch den Binärcode, welchen ich an den LED's sehen kann. Leider ändert sich nichts, wenn ich am Poti drehe um eine andere Spannung an AREF anzulegen.
Der ARef ist der Anschluß für die Referenzspannung. Du mußt die ADC-Eingänge für das Poti nehmen.

Wenn du dein Poti am ARef anschließt dann ist das als wenn du versuchst mit einem Zentimetermaß aus Gummi das du dauernd langziehst und stauchst (das Poti) eine Länge zu messen. Sieh dir mal das Blockschaltbild im großen Datenblatt des ATmega8 vom ADC an. Dann wird einiges klarer.

Gruß
Dino
 
Hallo Dino und danke für deine Antwort,
war ein echt blöder Tippfehler. Hab das beim zweiten mal durchlesen es auch gemerkt. PC0 ist mein Eingang wo eine Analoge Spannung an gelegt wird :) Irgendwas wird wandelt er von Analog zu Digital um nur leider 1 mal (sieht zumindestens so aus). Wenn ich am Poti drehe ändert sich aber leider das Bitmuster nicht.

Gruß
 
Hi Artur,

erst mal viel Spass hier =),


hast du beabsichtigt den Single Conversion Mode ausgewählt ? Naja prinzipiell geht dieser ja auch :).

Hast du den Code wo abgeschrieben / aus dem Internet oder hast du ihn "nach deinem denken" gemacht.

Weil was mir zuerst auffällt,
Code:
ADMUX |= (0<<REFS1)|(1<<REFS0); //Interne Referenzspannung Vcc ADMUX |= (0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0); // ADC Kanal 0 PC0 ADMUX |= (0<<ADLAR); //  8 Niederwertigsten Bits werden in ADCL abgelegt

mach mal die erste Zeile zu einem
Code:
ADMUX [B]=[/B] (0<<REFS1)|(1<<REFS0); //Interne Referenzspannung Vcc

Weil wenn anfangs hier schon mal ein Wert drin steht .. überschreibst du ihn hiermit sicher auf den Wert den du willst (die anderen dann bitte wie du es hast Verodern :).

Dann würde ich dir Empfehlen, alles was in ein Register gehört auch in eine Zeile zu schreiben (da der Compiler dir sonst jedes mal das Register neu laden muss es verodern muss und dann wieder zurück schreiben ..)
_________

Dann nutzt du ja den normalen 10 Bit ADC (du hast ja ADLAR auf 0) somit ist es Rechts Adjusted.

Bei den Atmels musst du erst ADCL und dann ADCH lesen, wenn du dies nicht machst wird ADCL nicht mehr Upgedatet ;)... deswegen würde ich dir Empfehlen lies einfach ADC. (Achtung der wert ist halt 10Bit :).)
Wenn du nur einen 8 Bit wert haben möchtest, dann Setze ADLAR auf 1 :) Achtung : wenn du dies machst Lies nur noch ADCH ! ^^ (ich denke das wird dein Problem sein.)

When ADCL is read, the ADC Data Register is not updated until ADCH is read. Consequently, if
the result is left adjusted and no more than 8-bit precision is required, it is sufficient to read
ADCH. Otherwise, ADCL must be read first, then ADCH.

The ADLAR bit in ADMUX, and the MUXn bits in ADMUX affect the way the result is read from
the registers. If ADLAR is set, the result is left adjusted. If ADLAR is cleared (default), the result
is right adjusted.


_________

Nun noch ein Punkt.
Code:
ADCSRA &= ~(1<<ADSC);
Das kannst du zwar schreiben, aber deine CPU sagt "mir ist das egal was du da machst" ;) ->
ADSC will read as one as long as a conversion is in progress. When the conversion is complete,
it returns to zero. Writing zero to this bit has no effect.

_________

Code:
void ADCL_auf_PORTC(char Pin_ADCL,char Pin_C)  // PORTC.PIN_C= ADCL.PIN_ADCL  {  	if (((ADCL>>Pin_ADCL)&1)==1)         { 			PORTC |= (1<<Pin_C); 			         } 		else 		{ 			PORTC &= ~(1<< Pin_C); 		}			 }

hiermit möchtest du doch den ADC wert irgendwie auf deinen PortC 1-5 bekommen oder ?
Es geht natürlich auch wie du das geschrieben hast :)

Du kannst das auch ganz einfach machen
Code:
PORTC = ((PINC & 0xC1) | ( (ADC/(uint16_t)32) << 1));
So ich hab das ganze nun nur schnell runtergetippt und hoffe es passt. Was ich dmait vorhabe kurz noch Erklärt ...

PORTC <- da willst du das haben
(PINC & 0xC1) <- das ist Teil eins hiermit Nullst du erst mal die Bits, die an deinen LEDs hängen.
| <- das Verodert das ganze dann mit Teil zwei
( (ADC/(uint16_t)32) << 1) <- hier Teilst du erst den 10 Bit wert (1024) geteilt durch 32 (könntest du auch mit Schieben machen aber der Compiler übernimmt das für dich), da auf PC0 aber was anderes Liegt musst du das Byte nun nocheinmal nach Links schieben damit es zwischen PC5 und PC1 zum liegen kommt. Ja so sollte das Klappen :) das (uint16_t) ist ein sogenannter Cast, damit sagst du "die 32 die da kommt ist eine 16 Bit Variable", ist in diesem Fall nicht 100%ig nötig, aber schöner ist es.. :)



Ich Empfehle dir bei der Programmierung das Datenblatt als kleine "Bibel" :)

Ich hoffe ich konnte dir hiermit helfen,

Gruß,
Manuel
 
Hallo Manuel,
Danke!
Es funktioniert wie gewünscht. Der Fehler lag echt darin, dass ADCL nicht mehr aktualiesiert wurde. Jetzt Lese ich einfach ADC aus, damit habe ich keine Probleme.

Code:
PORTC = ((PINC & 0xC1) | ( (ADC/(uint16_t)32) << 1));
Damit geht es wunderbar, nur habe ich da eine Fragen.
Warum teilst du ADC durch 32? Damit die Spannungsstufen größer werden? Wenn ich deinen Code verwende ändert sich jedes Bit um ca. 0,13875V (Multimeter). Wenn ich nach meinem Code es programmiere bzw. das /32 weglasse komme ich auf eine Stufenbreite von 0,005V. Sollte ich nicht eigentlich 5V/255=0,0196V erhalten. Dies bekomme ich doch, wenn ich das 10 Bit Register um 2 nach links schifte bzw. durch 4 Teile.

Code:
PORTC = ((PINC & 0xC1) | ( (ADC/(uint16_t)4) << 1));

Hast du den Code wo abgeschrieben / aus dem Internet oder hast du ihn "nach deinem denken" gemacht.
Großteils habe ich den nach meinem denken geschrieben :). Ofter mal paar Ideen "geklaut", aber naja am Anfang geht es nicht anders :)


hast du beabsichtigt den Single Conversion Mode ausgewählt ? Naja prinzipiell geht dieser ja auch .
Ja, ist ja in der While Schleife da brauchte ich nichtden Free Runnning Mode.

Weil was mir zuerst auffällt,
Code:

ADMUX |= (0<<REFS1)|(1<<REFS0); //Interne Referenzspannung Vcc ADMUX |= (0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0); // ADC Kanal 0 PC0 ADMUX |= (0<<ADLAR); // 8 Niederwertigsten Bits werden in ADCL abgelegt

mach mal die erste Zeile zu einem
Habe ich für mich der Übersichtshalber gemacht. Ist es denn so belastend für den µC. Wird das nicht nur einmal ausgeführt?
Hier nochmal mein verbesserter CODE
Code:
#include <avr/io.h>


int main(void)
{
	
ADMUX  = (0<<REFS1)|(1<<REFS0); //Interne Referenzspannung Vcc
ADMUX |= (0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0); // ADC Kanal 0 PC0
ADMUX |= (0<<ADLAR); //  8 Niederwertigsten Bits werden in ACD abgelegt

ADCSRA |= (1<<ADEN); // ADC Enable
ADCSRA |= (0<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); // ADC Prescaler = 8
ADCSRA |= (0<<ADIE); // ADC Interrupt Disable
ADCSRA |= (0<<ADFR); // ADC Free Running Disable

DDRC |= (1<<PC5)|(1<<PC4)|(1<<PC3)|(1<<PC2)|(1<<PC1)|(0<<PC0); // PC5 - PC1 = Ausgänge PC0 = Eingang


    while(1)
	{	ADCSRA |= (1<<ADSC); // Start der ADC
		while(ADCSRA & (1<<ADSC)); // Wartet bis Wandlung fertig ist

		
		PORTC = ((PINC & 0xC1) | ( ADC/((uint16_t)4) << 1)); // PINC wird verundet damit im Bereich PC5-PC1 keine 1 mehr vorliegt. 
											  // Dieses wird anschließend mit ADC/4 verodert. 4 ist eine 16Bit Variable		
						
        }
	
}

Danke nochmal :D
 
Hi Artur,

noch kurz zu dem "ob das mehr Code wird"

also ich muss sagen das Beispiel ist ohne Optimizer...

Dein Beispiel :
Code:
10:       ADMUX  = (0<<REFS1)|(1<<REFS0); //Interne Referenzspannung Vcc
+0000002C:   E2E7        LDI       R30,0x27       Load immediate
+0000002D:   E0F0        LDI       R31,0x00       Load immediate
+0000002E:   E480        LDI       R24,0x40       Load immediate
+0000002F:   8380        STD       Z+0,R24        Store indirect with displacement
11:       ADMUX |= (0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0); // ADC Kanal 0 PC0
+00000030:   E2A7        LDI       R26,0x27       Load immediate
+00000031:   E0B0        LDI       R27,0x00       Load immediate
+00000032:   E2E7        LDI       R30,0x27       Load immediate
+00000033:   E0F0        LDI       R31,0x00       Load immediate
+00000034:   8180        LDD       R24,Z+0        Load indirect with displacement
+00000035:   938C        ST        X,R24          Store indirect
12:       ADMUX |= (0<<ADLAR); //  8 Niederwertigsten Bits werden in ACD abgelegt
+00000036:   E2A7        LDI       R26,0x27       Load immediate
+00000037:   E0B0        LDI       R27,0x00       Load immediate
+00000038:   E2E7        LDI       R30,0x27       Load immediate
+00000039:   E0F0        LDI       R31,0x00       Load immediate
+0000003A:   8180        LDD       R24,Z+0        Load indirect with displacement
+0000003B:   938C        ST        X,R24          Store indirect
14:       ADCSRA |= (1<<ADEN); // ADC Enable
+0000003C:   E2A6        LDI       R26,0x26       Load immediate
+0000003D:   E0B0        LDI       R27,0x00       Load immediate
+0000003E:   E2E6        LDI       R30,0x26       Load immediate
+0000003F:   E0F0        LDI       R31,0x00       Load immediate
+00000040:   8180        LDD       R24,Z+0        Load indirect with displacement
+00000041:   6880        ORI       R24,0x80       Logical OR with immediate
+00000042:   938C        ST        X,R24          Store indirect
15:       ADCSRA |= (0<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); // ADC Prescaler = 8
+00000043:   E2A6        LDI       R26,0x26       Load immediate
+00000044:   E0B0        LDI       R27,0x00       Load immediate
+00000045:   E2E6        LDI       R30,0x26       Load immediate
+00000046:   E0F0        LDI       R31,0x00       Load immediate
+00000047:   8180        LDD       R24,Z+0        Load indirect with displacement
+00000048:   6083        ORI       R24,0x03       Logical OR with immediate
+00000049:   938C        ST        X,R24          Store indirect
16:       ADCSRA |= (0<<ADIE); // ADC Interrupt Disable
+0000004A:   E2A6        LDI       R26,0x26       Load immediate
+0000004B:   E0B0        LDI       R27,0x00       Load immediate
+0000004C:   E2E6        LDI       R30,0x26       Load immediate
+0000004D:   E0F0        LDI       R31,0x00       Load immediate
+0000004E:   8180        LDD       R24,Z+0        Load indirect with displacement
+0000004F:   938C        ST        X,R24          Store indirect
17:       ADCSRA |= (0<<ADFR); // ADC Free Running Disable
+00000050:   E2A6        LDI       R26,0x26       Load immediate
+00000051:   E0B0        LDI       R27,0x00       Load immediate
+00000052:   E2E6        LDI       R30,0x26       Load immediate
+00000053:   E0F0        LDI       R31,0x00       Load immediate
+00000054:   8180        LDD       R24,Z+0        Load indirect with displacement
+00000055:   938C        ST        X,R24          Store indirect

Mein Beispiel :
Code:
20:       ADMUX  = (0<<REFS1)|(1<<REFS0) | (0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0) | (0<<ADLAR); //Interne Referenzspannung Vcc
+00000056:   E2E7        LDI       R30,0x27       Load immediate
+00000057:   E0F0        LDI       R31,0x00       Load immediate
+00000058:   E480        LDI       R24,0x40       Load immediate
+00000059:   8380        STD       Z+0,R24        Store indirect with displacement
21:       ADCSRA = (1<<ADEN) | (0<<ADPS2)|(1<<ADPS1)|(1<<ADPS0) | (0<<ADIE) | (0<<ADFR);
+0000005A:   E2E6        LDI       R30,0x26       Load immediate
+0000005B:   E0F0        LDI       R31,0x00       Load immediate
+0000005C:   E883        LDI       R24,0x83       Load immediate
+0000005D:   8380        STD       Z+0,R24        Store indirect with displacement

Also das hinter den + sind die Adressen und dann der ASM Code .. also das Zeigt schon, dass es etwas Mehr ist *Gg*

ist auch klar ...

Wenn du ein

Register = Wert; machst ... schreibt er den Wert einfach in das Register.

wenn du

Register |= Wert; machst ... liest er erst das Register, Verodert deinen Wert damit und schreib es in das Register zurück.


Wenn du das nun 3 mal untereinander machst, passiert das eben 3 mal ;), ich kenne zur Zeit keinen AVR Compiler der so "Schlau" wäre und das ummodeln würde, darf er eigentlich auch nicht, da es Register gibt die du so nur Freischalten kannst ...

Natürlich ist das nicht Kriegsentscheidend für kleine Programme,

jedoch wenn man sich eine saubere Art angewöhnt und vorallem weiß was mann macht, hilft es für spätere Dinge ...
___________

Das schieben nach Links wäre eine Multiplikation ;) Rechtsshift ist eine Division :).
___________

Das durch 32 hab ich ganz einfach aus dem Grund gemacht, der AD Wandler liefert dir wenn du eine Referenz von 2,56V hast bei 2,56V 1024 Bit Auflösung.

Somit also 2,5mV / Digit.

So wenn du nun 5V an deinem ADC hast ... ist das nicht so ganz gut. Atmel sagt nur, dass die ADC Spannung nicht größer als die REF Spannung sein sollte... (Sagen aber nicht was passiert.)

Ich bin einfach mal davon ausgegangen, dass du mit deinem Poti nur eine Spannung von bis zu 2.5V bekommen kannst :), da du nur 5 LEDs hast .. hab ich die 10 Bit einfach auf die 5 LEDs aufgeteilt und 5 Bit daraus gemacht -> Deswegen / 32. (ist wie 5x nach rechts Schieben).

Wenn nun ~2.5V anliegen bekommst du normal 1024 Digit. So wenn du jetzt / 32 Teilst ... hast du eben alles auf deine 5 Bit reduziert ... wenn du nur / 4 teilst ... hast du 256 (2^8) also 8 Bit ... Du hast jedoch nur PC1 bis PC5 wenn ich das richtig gelesen hatte ?!? Also überschreibst du oben alles ;) was nicth gut ist ...

Ich vermute du hast aber ein Poti wo du 0 - 5 V an den ADC bringst ... und deswegen kommt es dir Feiner vor .. weil ab 2.56V du am Poti bis 5 V drehen kannst ohne dass du eine Änderung siehst ;) also das nochmal abprüfen.

_______

Auch wenns nur ne Kleinigkeit ist ..

Code:
DDRC |= (1<<PC5)|(1<<PC4)|(1<<PC3)|(1<<PC2)|(1<<PC1)|(0<<PC0); // PC5 - PC1 = Ausgänge PC0 = Eingang
du schiebst die 0 zwar hin ... aber wenn da schon eine 1 War .. bekommst du aus einem Oder dennoch eine 1 ;) .Die 0 da hin schieben bringt dir also nichts. Deswegen lieber bei sowas ein = nehmen und kein |= .. :)

Gruß,
Manuel
 
Hallo bluelight_electronic,
vielen Dank für die Aufklärung. Bei mir ist (0<<REFS1)|(1<<REFS0). Daher wird als Referenzspannung AVcc genommen (bei mir 5V). Somit erhalte ich eine Auflösung von U= 0,0196 V/Digit. Hoffe es stimmt was ich sage :). Was meine neusten Multimetermessungen auch bestätigen.

Habe den Code nochmal bisschen aufgefrischt. Viellicht hilft er anderen in den ADC Einstieg.
Auf einem Atmega8 funktioniert er einwandfrei.

Code:
/************************************************************************/
/* Kleiner ADC Test auf meinem ATMega8                                  */
/************************************************************************/

#include <avr/io.h>


int main(void)
{
unsigned char ADCL_dummy; 
	

/*************************************************************************************************************************/
/* REFS1 und REFS0 entscheiden welche Referenzspannung benutzt wird. Hier interne Referenz bzw. die am AVcc anliegt.     */
/*************************************************************************************************************************/
/* Über MUX3-MUX0 kann man entscheiden welcher ADC verwendet wird. In dem Beispiel ist es ADC0 am PIN PC0.               */
/*************************************************************************************************************************/
/* ADLAR=0 => Die zwei höchstwertigen Bits werden in ADCH und die acht niederwertigsten in ADCL abgelegt.                */
/* ADLAR=0 => Über das Register ADC kann man die kompletten 10 Bit lesen.                                                */
/* ADLAR=1 => Die acht höchstwertigen Bits werden in ADCH und die zwei niederwertigsten in ADCL abgelegt                 */
/* ADLAR=1 => Über das Register ADCH kann man eine 8 Bit Auflösung benutzen.											 */
/*************************************************************************************************************************/
/* WICHTIG! Wenn man nur das Register ADCH benutzen will, muss man ADCL davor einmal gelesen haben. Falls das nicht      */
/* geschieht wird ADCL nicht mehr aktualisiert		                                                                     */
/*************************************************************************************************************************/

ADMUX = (0<<REFS1)|(1<<REFS0)|(0<<MUX3)|(0<<MUX2)|(0<<MUX1)|(0<<MUX0)|(1<<ADLAR);


/* **************************************************************************************************************************/
/* ADEN - ADC Enable																									    */
/* ADSC - Start Conversion - Startet einmalige Wandlung. Wird nach Wandlung von der Hardware auf 0 gesetzt				    */
/* ADFR - Free Running - ADC startet erneut, wenn eine Wandlung fertig ist.												    */
/* ADIF - Interrupt Flag - Wird gesetzt, wenn ein Wandlung beendet ist. Wird durch die Hardware nach dem Interrupt gelöscht.*/
/* ADIE - Interrupt Enable - Schaltet Interrupts frei.																		*/
/* ADPS2-ADPS0 - Prescaler - 0 1 1 -> 8																					    */
/****************************************************************************************************************************/

ADCSRA = (1<<ADEN)|(1<<ADSC)|(0<<ADFR)|(0<<ADIF)|(0<<ADIE)|(0<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); 


DDRC = (1<<PC5)|(1<<PC4)|(1<<PC3)|(1<<PC2)|(1<<PC1)|(0<<PC0); // PC5 - PC1 = Ausgänge PC0 = Eingang

    while(1)
	{	
		ADCSRA |= (1<<ADSC); // Startet einmalige Wandlung.
		while (ADCSRA & (1<<ADSC)); // Wartet bis Wandlung fertig ist.
		ADCL_dummy=ADCL;	 // ADCL wird vor ADCH gelesen damit ADCH aktualisiert wird.
		
		/*****************************************************************************************************************************/
		/* PINC wird verundet damit im Bereich PC5-PC1 keine 1 mehr vorliegt.													     */
		/* ADCH wird um eins nach links geschiftet da auf PC0 der ADC0 liegt. So bringe ich die 5 niederwertigsten Bits              */
		/* auf die 5 Ausgänge PC1-PC5.																								 */
		/* Falls man das 10 Bit Register ADC nutzen will, könnte man auch schreiben										     		 */
		/* PORTC = ((PINC & 0xC1) | ( ADC/((uint16_t)4) << 1));																		 */
		/* Dann muss aber ADLAR=0 gesetzt werden.                                                                                    */
		/*****************************************************************************************************************************/
		
		PORTC = ((PINC & 0xC1) | ( ADCH << 1)); 
    }
	
}

Gruß
 
Hi Artur,

hehe naja die Auflösung ist ganz einfach zu Berechnen.

Du hast 5V als Ref. Spannung okey ^^ sry das hatte ich übersehen (in irgend einem Stand war es doch mal die Interne?!?) ^^, du bist was ich gesehen habe mittlerweile ja auf einen 8 Bit ADC gegangen.

Das einzigst unschöne ist noch du schiebst nun ein 8 Bit register (ADCH) auf deinen Port raus wo du aber nur 5 Bit anzeigen möchtest. PC6 & PC7 überschreibst du obwohl es ja eigentlich nicht deine LEDs sind.

Aber so sieht es sonst nach einem schönen Beispiel aus :).

Das mit der
 

Über uns

  • Makerconnect ist ein Forum, welches wir ausschließlich für einen Gedankenaustausch und als Diskussionsplattform für Interessierte bereitstellen, welche sich privat, durch das Studium oder beruflich mit Mikrocontroller- und Kleinstrechnersystemen beschäftigen wollen oder müssen ;-)
  • Dirk
  • Du bist noch kein Mitglied in unserer freundlichen Community? Werde Teil von uns und registriere dich in unserem Forum.
  •  Registriere dich

User Menu

 Kaffeezeit

  • Wir arbeiten hart daran sicherzustellen, dass unser Forum permanent online und schnell erreichbar ist, unsere Forensoftware auf dem aktuellsten Stand ist und der Server regelmäßig gewartet wird. Auch die Themen Datensicherheit und Datenschutz sind uns wichtig und hier sind wir auch ständig aktiv. Alles in allem, sorgen wir uns darum, dass alles Drumherum stimmt :-)

    Dir gefällt das Forum und unsere Arbeit und du möchtest uns unterstützen? Unterstütze uns durch deine Premium-Mitgliedschaft!
    Wir freuen uns auch über eine Spende für unsere Kaffeekasse :-)
    Vielen Dank! :ciao:


     Spende uns! (Paypal)