A/D-Wanlung, Potis, Programmeinbindung

[Markus L. (snerpy22)]

Hallo!

Also ich hab als Aufgabe eine A/D-Wandlung vorzuführen und den dafür 
vorgesehenen Programmquellcode zu schreiben bekommen. D.h. ich muss 
meine zwei vorhandenen Potis einsetzen und man muss etwas sehen. Die 
ganze Wandlung muss in einem Programm eingebunden sein, es ist recht 
egal, was es macht. Ich habe hier einen Ablaufplan einer Wandlung vor 
mir liegen und weiß auch wie man z.B. Bits liest, setzt oder löscht. 
Jedoch habe ich keine Vorstellung, wie ich es in ein Programm verpacken 
soll bzw. wie ich anfangen soll. Könnt ihr mir da paar Tipps geben? Wäre 
euch sehr dankbar! Hab den Kurs in der Schule freiwillig dazugewählt, 
finde ihn aber nicht gerade leicht, deshalb hoffe ich, dass ihr mir es 
nicht übel nehmt!

[Hubert G. (hubertg)]

Jetzt wissen alle genau was du möchtest. Kennen den A/D-Wandler, das 
Ausgabemedium usw.
Ab 17.00 sind nämlich alle Glaskugeln schon gereinigt und für morgen 
vorbereitet.

[Markus L. (snerpy22)]

Ich möcht ja keinen fertigen Code, sondern einfach nur ein 
Programmbeispiel, also wie man die Potis in irgendein Programm einfügen 
kann. Wenn das nicht reicht, such ich gleich alle Daten und schreib sie 
auf.

[Karl H. (kbuchegg)]

Markus L. schrieb:
> Ich möcht ja keinen fertigen Code, sondern einfach nur ein
> Programmbeispiel, also wie man die Potis in irgendein Programm einfügen
> kann. Wenn das nicht reicht, such ich gleich alle Daten und schreib sie
> auf.

Es reicht schon mal, wenn du verrätst, welche AD Wandler, bzw. welchen 
µC du überhaupt verwendest.
Es gibt da draussen nämlich mehr als nur einen Typ von Prozessor.

[troll (Gast)]

Ach ja...

1. Datenblatt des µP
(wenn AVR:)
2. http://www.mikrocontroller.net/articles/AVR-Tutorial
3. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
4. 
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe
hth

[Oliver S. (oliverso)]

Bitte sehr:

int main(void)
{
   while(1)
   {
      int p1 = liesPoti(1);
      int p2 = liesPoti(2);
      displayLCD(p1);
      displayLCD(p2);
   }

}

Die Funktionen musst du dir halt selber schreiben...

Oliver

[Markus L. (snerpy22)]

http://www.elektor.de/products/kits-modules/modules/090907-91-first-step-board.1283430.lynkx

Das ist der Microcontroller

[troll (Gast)]

Ein 8051er von Atmel, das ist ja schon mal was. Erste Anlaufstelle 
bleibt das Datenblatt von dem Käfer, Sektion ADC-Converter.

[Karl H. (kbuchegg)]

Markus L. schrieb:
> 
http://www.elektor.de/products/kits-modules/modules/090907-91-first-step-board.1283430.lynkx
>
> Das ist der Microcontroller


Auf diesem Artikel gibt es eine Verlinkung zu einem anderen Artikel über 
dieses Board. Dort ist von Gratis-Demo Software die Rede. Nur will ich 
mich nicht bei Elektor registrieren um die mal durchzusehen :-)

Ist denn bei diesem Demos keine Demo für den ADC dabei?
Da gibts doch sicher auch ein Demo, welches den ADC in Aktion vorführt, 
nachdem sie das in der Board-Beschreibung schon so rausstellen, dass da 
2 Potis für den ADC mit am Board sind.

[Hubert G. (hubertg)]

Wow, mir ist zwar klar das 8051er speziell im Industriebereich noch 
immer sehr aktuell sind, aber den Preis für das Board!!
Wenn ich mir dagegen den Preis für einen Arduino Mega2560 anschaue.

[Markus L. (snerpy22)]

Hab mir die oben beschriebene Datei heruntergeladen und sie geöffnet:

Dort gibts einen Ordner namens "Demo-Software" und dann eine Datei mit 
"AD_Wandler"

Das ist dort enthalten: http://pastebin.com/mDqDFJ04

[Karl H. (kbuchegg)]

Markus L. schrieb:
> Hab mir die oben beschriebene Datei heruntergeladen und sie geöffnet:
>
> Dort gibts einen Ordner namens "Demo-Software" und dann eine Datei mit
> "AD_Wandler"
>
> Das ist dort enthalten: http://pastebin.com/mDqDFJ04

Du darfst ruhig Code auch hier posten :-)

[Karl H. (kbuchegg)]

Na, sieht doch gut aus!
Was brauchst du denn noch!

/*     Programm:            Betrieb des ON-Chip A/D-Wandlers und Darstellung    */
/*                          der Wandlungsergebnisse auf HyperTerm!              


....

/*  Die Funktion void seri_init(void) initialisiert die ser. Schnittstelle des  */
/*  CC03ers bei einer Taktfrequenz von 11,0592MHz mit nachfolgenden Schnitt-    */
/*  stellen Parametern: 9600 Bd, 1 Stopp-Bit, keine Parität, asynchr. Betrieb!  */

Programm in den µC übertragen.
Die serielle Schnittstelle verkabeln (so das nicht längst geschehen 
ist), Hyperterminal am PC starten, auf die Übertragungsparameter 
einstellen und mal schauen was sich tut.

Was willst du denn noch mehr? Ist doch eh alles da, was du brauchst.

[Markus L. (snerpy22)]

Also ich hab hier wie oben beschrieben noch ein Blatt

Auf jeden Fall hab ich vor mir einen Ablauf:

1. A/D-Wandler initialisieren
 - SFR 'ADCF' beschreiben
 - SFR 'ADCON' beschreiben

2. A/D-Wandlung starten
 - SFR 'ADCON' beschreiben
3. Warten bis Wandlung fertig
 - Abfragen des Fertig-Bits
4. Löschen des Fertig-Bits
5. Wandlungwerts auslesen
 - SFR 'ADDH' und ggf. 'ADDL'.

Was das jetzt genau mit dem Code ein Post über mit zu tun hat, weiß ich 
nicht so recht.

Zu 1. z.B.: ADCF=ADCF|8;

Oder allgemein Bit setzen: wert=wert|b;

[troll (Gast)]

Markus L. schrieb:
> Was das jetzt genau mit dem Code ein Post über mit zu tun hat, weiß ich
> nicht so recht.
Das dürfte so ziemlich das sein was du suchst...

Kannst du überhaupt C? Hast du den geposteten Code mal angeguckt und 
verstanden?

[Karl H. (kbuchegg)]

Markus L. schrieb:


> Was das jetzt genau mit dem Code ein Post über mit zu tun hat, weiß ich
> nicht so recht.


Nicht?

Also wenn ich mir den Code da oben so ansehe, dann finde ich dort alle 
von dir aufgezählten Teile wieder. Und das ganz in einem fertigen 
Programm, welches nur darauf wartet mal ausgetestet zu werden, ehe man 
dann beginnt es so umzuarbeiten, wie du dir das vorstellst.

[Markus L. (snerpy22)]

troll schrieb:
> Markus L. schrieb:
>> Was das jetzt genau mit dem Code ein Post über mit zu tun hat, weiß ich
>> nicht so recht.
> Das dürfte so ziemlich das sein was du suchst...
>
> Kannst du überhaupt C? Hast du den geposteten Code mal angeguckt und
> verstanden?

Wenn du so fragst: Nein. Ich verstehe schon einiges, aber ich sehe 
ehrlichgesagt nicht das, was ich sehen sollte. Und wenn ich den Code 
kopiere und testen möchte, wird mir ein Error angezeigt.

[troll (Gast)]

Markus L. schrieb:
> Wenn du so fragst: Nein.
Das ist nicht gut...

> Und wenn ich den Code
> kopiere und testen möchte, wird mir ein Error angezeigt.
Der da wäre?

[Karl H. (kbuchegg)]

> 1. A/D-Wandler initialisieren
>  - SFR 'ADCF' beschreiben
>  - SFR 'ADCON' beschreiben

Aus dem Code

void main(void)
  {
    ....

    ADCF = 0xc0;                                        // Port P1.6 und P1.7 als Analogeingang!
    ADCON = 0x20;                                       // ON-Chip A/D-Wandler eingeschaltet!
    ....
    while

Jep, abhgehakt. Punkt 1 ist da

> 2. A/D-Wandlung starten
>  - SFR 'ADCON' beschreiben

unsigned int mw_erf10(unsigned char kanal)
  {      
...
    ADCON = (ADCON & 0xe8);                 // Kanalauswahl und Wandlungsende-Bit rücksetzen!
    ADCON = (ADCON | (0x08+kanal));         // Kanalauswahl und Start der einmaligen Wandlung!
...

Jep, abgehakt. Punkt 2 ist da

> 3. Warten bis Wandlung fertig
>  - Abfragen des Fertig-Bits

unsigned int mw_erf10(unsigned char kanal)
  {      
 ...

    while((ADCON & 0x10) == 0);             // Warte bis A/D-Wandlung beendet ist!
....

Noch ein Jep. Punkt 3 ist vorhanden

> 4. Löschen des Fertig-Bits
Ist laut Kommentar im Punkt 2 schon mitgemacht worden.

> 5. Wandlungwerts auslesen
>  - SFR 'ADDH' und ggf. 'ADDL'.

unsigned int mw_erf10(unsigned char kanal)
  {
...

    erg = ((ADDH << 2) + (ADDL & 0x03));    // Ergebnisregister auslesen u. zusammenbauen!
    return(erg);
  }
...

Auch vorhanden.

Alles da, was auf deiner Liste steht.

[Karl H. (kbuchegg)]

> aber ich sehe ehrlichgesagt nicht das, was ich sehen sollte.

Das ist aber schlecht. Denn noch deutlicher kann man es kaum mehr 
präsentieren.

[Markus L. (snerpy22)]

Okay, bloß stimmen Sachen wie "(unsigned char kanal)" oder "
    erg = ((ADDH << 2) + (ADDL & 0x03));" gar nicht mit meinen 
Unterlagen überein und sowas verstehe ich auch z.B. gar nicht.

Sonst ist mir klar, was da passiert (ist ja auch nicht schwer bei den 
Kommentaren daneben 8o)

[troll (Gast)]

Markus L. schrieb:
> sowas verstehe ich auch z.B. gar nicht.
Dann zurück zum Start ähh C-Buch... Wenn du die Grundlagen nicht 
beherrscht bringt es nichts weiter zu machen.

Guck dir die Sachen in Ruhe an:

>     erg = ((ADDH << 2) + (ADDL & 0x03));

1. Es ist eine Zuweisung.
2. Das Ziel ist erg
3. Es wird eine Summe zugewiesen.
4. Der erste Summand ist ADDH um 2 Stellen nach links geschoben 
(entspricht Multiplikation mit 4)
5. Der zweite Summand ist ADDL UND 0x03, das bedeutet es werden nur die 
zwei untersten Bits betrachetet.

Ganz einfach :-)

[Markus L. (snerpy22)]

Ich lache gerade etwas, sowas hatte ich nie!

Ich dachte an sowas:

1. A/D-Wandler initialisieren
 - SFR 'ADCF' beschreiben
 - SFR 'ADCON' beschreiben

=> ADCF=ADCF|8

Oder zu 3

=> while (ADCON&16=0)
{

}

[Karl H. (kbuchegg)]

Markus L. schrieb:
> Ich lache gerade etwas, sowas hatte ich nie!

Tja. Viele Wege führen nach Rom.


> while (ADCON&16=0)

Das ist eine Zuweisung und kein Vergleich!
Und was könnte wohl der Vorteil sein, wenn man anstelle von 16 die 
gleichwertige Hexadezimalzahl 0x10 schreibt?

(denn im Original steht GENAU das gleiche, was auch du erwartet hast. 
Nur ist die Zahl in einem anderen Zahlensystem. Nicht Dezimal sondern 
Hexadezimal. Aber 0x10 IST 16. Oder Binär 0b00010000)

[Markus L. (snerpy22)]

Sorry, das wusst ich nicht. Es ist einfach so, dass wir unser Program 
vorstellen müssen und der Lehrer uns bestimmte Vorlagen gab in Sachen 
Bits lesen, setzen und löschen. Den Ablauf verstehe ich schon, ich bin 
halt unfähig den Code zu schreiben, geschweige denn es in ein Programm 
einzubinden.

1. Wenn Sie mit dem ON-Chip-A/D-Wandler des CC03ers arbeiten, müssen Sie 
IMMER als Erstes festlegen, welche Pings vom Port P1 als analoge 
Eingänge dienen sollen, d.h. Sie müssen IMMER als Erstes das SFR 'ADCF' 
beschreiben. Beachten Sie, dass ADCF ist nur als Ganzes beschreibar und 
nicht bitadressiert ist.

=> ADCF=ADCF|8;

Als nächstes kommt das Steuer-SFR 'ADCON' an die Reihe: hier wird der 
gewünsche zu wandelnde Kanal ausgewählt und der A/D-Wandler 
eingeschaltet. Des PSIDLE-Mode benutzen wir hier nicht und nicht benutze 
Bits (im SFR mit 'X' gekennzeichnet) werden auf logisch 0 gesetzt. Die 
Wandlung soll noch NICHT gestartet werden

=> ADCON=ADCON|8;

[Markus L. (snerpy22)]

Also ich hab mal was versucht und das hier hergezaubert..

Ist da überhaupt irgendwas richtig?

http://pastebin.com/u0KETSRM

[Jobst M. (jobstens-de)]

Markus L. schrieb:
> Also ich hab mal was versucht und das hier hergezaubert..

Dann füge es doch auch bitte hier an! ;-)

Welche Sprache programmiert Ihr denn? Wenn Ihr Euch nur mit Assembler 
befasst, dann ist es klar, daß Du nichts von dem Beispielprogramm 
verstehst.


Gruß

Jobst

[Markus L. (snerpy22)]

#include <stdio.h>                      // Standard Ein-/Ausgabefunktionen
#include <at89C51cc03.h>                // CC03er-Grundregister


void initSerial(void)   
{
    SCON = 0x52;    //  9600 Baud, 8 Datenbit, 1 Stopp-Bit, asynchroner Betrieb,
    TMOD |=0x20;    //  keine Parit?tspr?fung.
    TH1  = 0xfd;    //  
    TR1  = 1;       //  Datenuebertragungs-Parameter ?bernehmen
    TI   = 1;       //  nichts uebertragen
}

void main(void)

{

  initSerial();

  ADCF = 0xc0;                                       
  ADCON = 0x20;  

  while(1)

    {
       ADCON = (ADCON | 8);   
       while((ADCON & 16) == 0);
         {
         } 
       ADCON=ADCON&(255-16);
       if(16&b>0)
        {
        }
}

Hab mich an den obigen Posts gehalten und an meine Unterlagen 
(versucht).

Achja: Wir hatten die Grundlage von C, mehr nicht. So richtig einfache 
Befehle. Das von oben sieht nach längerem Hinsehen auch nicht mega 
schwer aus, aber sowas hatten wir halt einfach nicht..

[Markus L. (snerpy22)]

Falls man nicht puschen darf bitte löschen! Ich wollt nur ne kleine 
Rückmeldung haben vom obigen Post, ob da überhaupt irgendwas richtig ist 
und ob ich da aufm richtigen Weg bin

[Karl H. (kbuchegg)]

Markus L. schrieb:
> Falls man nicht puschen darf bitte löschen!

Ist schon ok.

> Ich wollt nur ne kleine
> Rückmeldung haben vom obigen Post, ob da überhaupt irgendwas richtig ist
> und ob ich da aufm richtigen Weg bin

Na ja. Du hast ja da im Grunde noch gar nichts geschrieben, was jetzt 
irgendwie groß problematisch wäre.


Aus

int main()
{

  Wandler initialisieren


  while( 1 ) {

    Starte den Wandler

    Warte bis der Wandler fertig ist

    Hole das Ergebnis

    Mach was mit dem Ergebnis

  }
}

folgt ja dein Code mehr oder weniger unmittelbar.
Was das
 if(16&b>0)
da drinn zu suchen hat, weiß ich zwar nicht und die Teile "Hole das 
Ergbnis" und "Mach was mit dem Ergebnis" hast du noch nicht mal 
angefangen. Womit nur die Teile "Wandler initialisieren", "Starte den 
Wandler" und "Warte bis er fertig ist" übrig bleiben. Das sind im Grunde 
gerade mal 4 Zeilen Code. Und das auch nur, weil die Initialisierung 
sich über 2 Zeilen erstreckt.
Und ob deine Hex-Konstanten, die du da benutzt hast, richtig sind oder 
nicht, steht in deinen Unterlagen bzw. im Datenblatt des Prozessors. Die 
wird dir hier keiner zusammensuchen.