mikrocontroller.net

Forum: Compiler & IDEs Schaltung in C zur Solarzellen nachführung


Autor: Ole S. (blackbird09)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo zusammen,
ein paar Freunde und ich haben vor ein RC-Boot auf Basis von Solarstrom 
zu bauen. Wir sind auch bereits relativ weit!
Die Solarzellen auf dem Boot sollen sich auf einer Plattform befinden, 
welche sich zur Sonne ausrichtet. Dazu wollen wir einen Servo mit Relais 
ansteuern, die wiederum vom ATmega8 geschaltet werden.
Der ATmega8 vergleich Werte aus Photowiderständen und ermittelt so wo 
die Sonne steht(Photowiderstände sind auf der Plattform, drehen sich 
also mit) und richtet die Plattform neu aus.

        ______4______
 >>>    |             |    Anordnug der Sensoren an der Plattform
 >>>   0|             |    ">>>" von der Richtung soll die Sonne die
 >>>    |             |3         Solarzellen anstrahlen.
 >>>   1|             |
 >>>    |_____________|
               2

Nun zu meiner Frage: Ist der Quellcode so richtig?
(Programmieren das erste mal ein AVR)
ADC richtige Einstelllung?
Pin ansteuerung, etc?

Code:
//----------------------------------------------------------------------
//Projekt 
//Titel     : Solar-Boot
//----------------------------------------------------------------------
// Funktion  : Überprüfung von Pins auf diff zu Vin und Ausgabe der Drehrichtung für den Motor
// Schaltung : PC0-PC4 an Fotowiederstand
//----------------------------------------------------------------------
// Prozessor : ATmega8
// Takt      : 16 MHz
// Sprache   : C
// Datum     : 21.12.2009
// Version   : 1.0

//----------------------------------------------------------------------
#define   F_CPU 16000000  // Taktfrequenz des myAVR-Boards
#include  <avr\io.h>    // AVR Register und Konstantendefinitionen
#include   <util\delay.h>  // Bibliothek mit Warteroutinen
#define TOLERANCE 50        //Spannungstoleranz bei welcher er aufhört weiterzudrehen (50 ~ 0,25V)
//----------------------------------------------------------------------
/*PINC1 = Front der Solarzellen muss Sonne abbekommen
  PINC0 = Front der Solarzellen muss Sonne abbekommen
  Belichtung zwischen PINC0 und PINC1 sollte ca. gleich sein
  PINC2-4 sind übrige Sensoren C4 links; C3 hinten ; C2 rechts
  PINB1 ist der Ausgang für den Motor wenn Bit=1 dann 5V */
void adcinit()
{
   ADMUX |= (0<<REFS1) | (1<<REFS0); // Referenzspannung = ACC
   ADCSRA = (1<<ADEN) | (1<<ADFR);         
}
//=========================================================================
void init(void)        // Unterprogramm für die Initalisierung
{
    DDRC=0x00;  // DDRC = 0 alle auf Eingang (ADC)
    DDRB=0x00;  // PINB0 auf BIt = 0
    
}
//======================================================================
int main()
{
   init();                    // Unterprogrammaufruf für Initialisierung
     while(true)
     {              // Schleifenanfang Mainloop
     if( PINC4 > PINC0)    // Wenn 4 Mehr belichtet wird, als 0, soll solange rechts gedreht werden, bis 1 = 0
       {
         PORTB = 0x2; //PortB1 = 5V (Rechts rum drehen)
         while (PINC0 > PINC1) //Solange warten, bis 0 und 1 identische Werte haben
            _delay_ms(50);     
         PORTB = 0;   
       }
    
     //-------------------------------------------------------------------------
       if ( PINC2 > PINC1)  // Überprüfung ob PINC2 mehr belichtet wird als PINC1
     {          
    
           PORTB=0x04; // PORTB2 = 5V links rum
           while (PINC1 > PINC0) //Solange warten, bis 1 und 0 identische Werte haben
                 _delay_ms(50);
           PORTB = 0;
           
       }
      
      //---------------------------------------------
      if (PINC3 > PINC1 || PINC3 > PINC0 || PINC3 > PINC2 || PINC3 > PINC4) //Wenn 3 (hinten) mehr beleuchtet wird, als einer der anderen Sensoren
      {
                
                PORTB = 0x2; //Rechts drehen, bis PINC1 = PINC0
                while(PINC0 > PINC1 || PINC3 > PINC4) //Weiterdrehen, bis 1 = 0 ist und/oder solange 3 > 4 ist
                  _delay_ms(50); 
                PORTB = 0;
      }
      
      //-----------------------------------------------------
      while (PINC1 > PINC0 + TOLERANCE || PIN1 < PINC0 - TOLERANCE) //Korrektur, falls die differenz zwischen 1 und 0 zu groß ist
      {
            if (PINC1 > PINC0)
               PORTB = 0x04; //links rum
             else
               PORTB = 0x02;   //rechts rum  
             _delay_ms(50);
      }
      PORTB = 0;
     }             // Schleifenende Mainloop
     return 0;
}
//======================================================================

MfG
Blackbird

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
 if( PINC4 > PINC0) 

und alle weiteren tun nicht das, was du erwartest. Tutorial nochmals 
lesen, wie man Eingänge einliest.
PORTB = 0;

kommt mehrfach vor, aber niemals sinvoll. Ich würde dafür einen eigenen 
Vergleichsblock anlegen, der ausgeführt wird, wenn das Solarpanel 
richtig steht.

Auch ist der Ansatz, innerhalb der einzelnen Blöcke nochmals 
while-Schlefen zu haben, auch nicht perfekt. Schließlich hast du ja in 
main eine große Schleife.

Ich würde das mit nur drei Zuständen lösen: Rechtsrum, linksrum, stehen 
bleiben. Da drin dann nur die Ausgänge passend setzen, sonst nichts.

Als letztes bleibt noch die Frage, was du mit "Servo" meinst. Ein 
Modellbauservo lässt sich so nicht ansteuern, und dreht auch nicht 
endlos in eine Richtung.

Oliver

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die Tatsache, dass da ein paar mal das Wort ADC vorkommt, lässt in mir 
den Verdacht aufkeimen, dass du die Photowiderstände mit dem ADC 
auslesen willst. Und das geht dann so schon überhaupt nicht.
Aber auch hier weiß das Tutorial Rat. Diesmal sogar in Form einer 
fertigen ADC-Auslesefunktion

Autor: Ole S. (blackbird09)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Erstmal Danke für die Tips!
Dann müssen wir uns wohl nochmal ran setzen.
Sry Servo war der falsche Begriff, ich meine einen kleinen Motor.

MfG

Ole S.

Autor: Zwölf Mal Acht (hacky)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie will man denn Photowiderstaende auslesen, wenn nicht mit einem ADC ? 
Was auch immer an diesem ADC sonst noch klebt, ist nicht Bestandteil vom 
Code.

Autor: David O. (soley)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Oliver schrieb:
> Tutorial nochmals
> lesen, wie man Eingänge einliest.

Es bringt mir nichts das Tutorial endlos oft zu lesen, wenn die 
Information, die ich benötige nicht drin steht.
Aber vielleicht kannst du mir ja die Frage beantworten, weil du dich 
recht gut auszukennen scheinst:
Die letzten 5 Bits vom ADMUX Register müssen auf den Kanal gestellt 
werden, an dem die Spannung gemessen werden soll... Im Tutorial steht 
leider nicht, was ich dort reinschreiben muss, um auf den Pin 0 vom Port 
C zuzugreifen, bzw auf die anderen Pins von C

Danke ^^

Autor: Frauenverdreher (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Die letzten 5 Bits

4 Bits beim Atmega8

> vom ADMUX Register müssen auf den Kanal gestellt werden, an dem die
> Spannung gemessen werden soll... Im Tutorial steht leider nicht, was ich
> dort reinschreiben muss, um auf den Pin 0 vom Port C zuzugreifen, bzw
> auf die anderen Pins von C

Das wäre ziemlich leicht aus dem Datenblatt zu entnehmen gewesen. Aber 
ich kann das gerne für dich da nachlesen und vorkauen:

Die Pins PC0 bis PC5 werden ausgewählt, indem man in die MUX-Bits den 
entsprechenden Wert (0 bis 5) einträgt.

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Oliver schrieb:
>> Tutorial nochmals
>> lesen, wie man Eingänge einliest.

>Es bringt mir nichts das Tutorial endlos oft zu lesen, wenn die
>Information, die ich benötige nicht drin steht.

Wenn du das falsche Tutorial endlos oft liest, bringt das natürlich 
nichts.

Hier mal der link zum richtigen:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial

Und da steht das alles drin. Wie man Eingänge einliest, und auch, wie 
das mit dem ADC funktioniert.

Ich zitiere mal:
>Mit diesen 5 Bits wird der zu messende Kanal bestimmt. Wenn man einen einfachen 
>1-kanaligen ADC verwendet wird einfach die entsprechende Pinnummer des Ports in 
>die Bits 0...2 eingeschrieben.

Beim Mega8 stimmt das nicht ganz, da sind es nur 4 Bit, aber am Prinzip 
ändert sich nichts. So etwas steht dann in der Mutter aller 
Informationsquellen, dem Datenblatt zum Mega8. Das ist die ultimative 
Referenz, ohne darin nachzusehen, kann man einen AVR nicht 
programmieren.

Oliver

Autor: David O. (soley)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Supi, solche Antworten sind doch gleich viel hilfreicher, als "Lies das 
Tutorial nochmal" ;-)

Und ich hab nicht das falsche gelesen :P

Und nachdem ich das Tutorial auch noch ein drittes mal gelesen habe und 
alle Ratschläge versucht hab zu beherzigen, poste ich hier nochmal die 
überarbeitete Version des Codes:
//----------------------------------------------------------------------
//Projekt Solaris
//Titel     : SOLAR-Boot
//----------------------------------------------------------------------
// Funktion  : Überprüfung von PORT D0-D5 auf Wiederstand und Ausgabe der Drehrichtung für den Motor
// Schaltung : PC0-PC5 an Fotowiederstand
//----------------------------------------------------------------------
// Prozessor : ATmega8
// Takt      : 16 MHz
// Sprache   : C
// Datum     : 07.12.2009
// Version   : 1.1
//----------------------------------------------------------------------
#define   F_CPU 16000000  // Taktfrequenz des myAVR-Boards
#include  <avr\io.h>    // AVR Register und Konstantendefinitionen
#include   <util\delay.h>  // Bibliothek mit Warteroutinen
#define TOLERANCE 50        //Spannungstoleranz bei welcher er aufhört weiterzudrehen (50 ~ 0,25V)
//----------------------------------------------------------------------
/*PINC1 = Front der Solarzellen muss Sonne abbekommen
  PINC0 = Front der Solarzellen muss Sonne abbekommen
  Belichtung zwischen PINC0 und PINC1 sollte ca. gleich sein
  PINC2-4 sind übrige Sensoren C4 links; C3 hinten ; C2 rechts
  PINB1 ist der Ausgang für den Motor wenn Bit=1 dann 5V */
//======================================================================
uint16_t get_voltage(int kanal) //Spannung im Bereich von 0-5V mit einer 10Bit auflösung ausgeben
{
         uint16_t voltage = 0;
         ADMUX &= 0b11100000;       //Kanal löschen
         ADMUX |= kanal;            //Kanal einstellen
         ADCSRA &= 0b11101111;      //Ausgabebit löschen, falls es nicht gelöscht war
         ADCSRA |= 1 << 6;          //Bit setzten, um Messung zu beginnen
         While(!(ADCSRA & 1 << 4)); //Warten, bis die Berechnung abgeschlossen ist
         voltage = ADCL;            //Zuerst ADCL auslesen
         voltage += (ADCH << 8);    //Anschließend ADCH auslesen
         return voltage;            //Wert zurückliefern
}
int main()
{
    //DDR initialisieren:
    DDRC=0x00;  // DDRC = 0 alle auf Eingang (ADC)
    DDRB=0xff;  // PortB = Ausgang
    
    //ADC initialisieren:
    ADCSRA = ADCEN | 0b111;
    ADMUX = 1 << 6;  // AVCC = Referenzspannung (5V)
    
    //Variableninitialisierung
    uint16_t c0, c1, c2, c3, c4;
        
    //Hauptschleife
     while(true)
     {
       c0 = get_voltage(0);
       c1 = get_voltage(1);
       c2 = get_voltage(2);
       c3 = get_voltage(3);
       c4 = get_voltage(4);
      //--------------------------------------------------------          
    if(c4 > c5)    // Wenn 4 Mehr belichtet wird, als 0, soll solange rechts gedreht werden, bis 1 = 0
           PORTB = 1 << 1; //PortB1 = 5V (Rechts rum drehen)
      //-------------------------------------------------------------------------
      if (c2 > c1)  // Überprüfung ob PINC2 mehr belichtet wird als PINC1          
           PORTB= 1 << 2; // PORTB2 = 5V links rum
      //------------------------------------------------------
      if (c3 > c1 || c3 > c0 || c3 > c2 || c3 > c4) //Wenn 3 (hinten) mehr beleuchtet wird, als einer der anderen Sensoren          
           PORTB = 1 << 1; //PORTB1 = 5V (Rechts rum)
      //-----------------------------------------------------
      if (c1 > c0 + TOLERANCE || c1 < c0 - TOLERANCE) //Korrektur, falls die differenz zwischen 1 und 0 zu groß ist
      {
            if (c1 > c0)
               PORTB = 1 << 2; //links rum
             else
               PORTB = 1 << 1;   //rechts rum  
      }
      //-------------------------------------------------------
      if (c1 <= c0 + TOLERANCE && c1 >= c0 - TOLERANCE) // Falls die Werte zwischen den Frontsensoren in Ordnung sind, anhalten
          PORTB = 0;
     }
     //Ende fer Hauptschleife
     return 0;
}
//======================================================================

Und vielen Dank für eure Hilfe :)

Autor: Simon K. (simon) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ein paar Klammern bei den if-Statements könnten nicht schaden.

Autor: David O. (soley)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Zu viele Klammern machen den Code aber auch unübersichtlich, deshalb 
lasse ich sie immer weg, wenn es möglich ist ^^

Autor: MaWin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Nun zu meiner Frage: Ist der Quellcode so richtig?

Der Motor braucht mit dem Verfahren mehr Strom,
als das Solarpanel aus der Sonne gewinnen kann.

Mehr Gelassenheit!

Auch diffuser Himmel bringt euch durcheinander.

Es reichen übrigens 2 Sensoren.

Autor: Simon K. (simon) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
David O. schrieb:
> Zu viele Klammern machen den Code aber auch unübersichtlich, deshalb
> lasse ich sie immer weg, wenn es möglich ist ^^

LOL. Mit dem Argument habe ich nicht gerechnet.

Zu wenige Klammern machen aber auch Probleme, wenn man die Prioritäten 
der Opratoren nicht auswendig kann oder lernen möchte.

Autor: Ole S. (blackbird09)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Zusammen,
leider funktioniert unser Code immer noch nicht.
Ich hoffe ihr könnt mal ein Blick auf ihn werfen und uns mögliche 
Fehlerursachen nennen. Problem ist, dass der ATMega8 nichts macht, wenn 
man eine Spannung an einen der Eingänge anlegt(es passiert nichts am 
Ausgang (links oder rechts drehen)).

Vielen Dank im Vorraus!
//----------------------------------------------------------------------
//Projekt Solaris

//----------------------------------------------------------------------
// Funktion  : Überprüfung von Pin C0-C4 auf Wiederstand und Ausgabe der Drehrichtung für den Motor
// Schaltung : PinC0-PinC4 an Fotowiederstand
//----------------------------------------------------------------------
// Prozessor : ATmega8
// Takt      : 16 MHz
// Sprache   : C
// Datum     : 23.02.2010
// Version   : 2.1


//----------------------------------------------------------------------
#define   F_CPU 16000000  // Taktfrequenz des myAVR-Boards
#include  <avr\io.h>    // AVR Register und Konstantendefinitionen
#include   <util\delay.h>  // Bibliothek mit Warteroutinen
#define TOLERANCE 50        //Spannungstoleranz bei welcher er aufhört weiterzudrehen (50 ~ 0,25V)
//----------------------------------------------------------------------
/*PINC1 = Front der Solarzellen muss Sonne abbekommen
PINC0 = Front der Solarzellen muss Sonne abbekommen
Belichtung zwischen PINC0 und PINC1 sollte ca. gleich sein
PINC2-4 sind übrige Sensoren C4 links; C3 hinten ; C2 rechts
PINB1 ist der Ausgang für den Motor wenn Bit=1 dann 5V */
//======================================================================
uint16_t get_voltage(int kanal) //Spannung im Bereich von 0-5V mit einer 10Bit auflösung ausgeben
{
  uint16_t voltage = 0;
  ADMUX &= 0b11100000;       //Kanal löschen
  ADMUX |= kanal;            //Kanal einstellen
  ADCSRA &= 0b11101111;      //Ausgabebit löschen, falls es nicht gelöscht war
  ADCSRA |= 1 << 6;          //Bit setzten, um Messung zu beginnen
  while(!(ADCSRA & 1 << 4)); //Warten, bis die Berechnung abgeschlossen ist 
  voltage = ADCL;            //Zuerst ADCL auslesen
  voltage += (ADCH << 8);    //Anschließend ADCH auslesen
  return voltage;            //Wert zurückliefern
}
int main()
{
  //DDR initialisieren:
  DDRC=0x00;  // DDRC = 0 alle auf Eingang (ADC)
  DDRB=0xff;  // PortB = Ausgang

  //ADC initialisieren:
  ADCSRA = ADEN | 0b111; 
  ADMUX = 1 << 6;  // AVCC = Referenzspannung (5V)

  //Variableninitialisierung
  uint16_t c0, c1, c2, c3, c4;

  //Hauptschleife
  while(true)
  {
    c0 = get_voltage(PINC0);
    c1 = get_voltage(PINC1);
    c2 = get_voltage(PINC2);
    c3 = get_voltage(PINC3);
    c4 = get_voltage(PINC4);
    //--------------------------------------------------------          
    if(c4 > c0)    // Wenn 4 Mehr belichtet wird, als 0, soll solange rechts gedreht werden, bis 1 = 0 
      PORTB = 1 << 1; //PortB1 = 5V (Rechts rum drehen)
    //-------------------------------------------------------------------------
    if (c2 > c1)  // Überprüfung ob PINC2 mehr belichtet wird als PINC1          
      PORTB= 1 << 2; // PORTB2 = 5V links rum
    //------------------------------------------------------
    if (c3 > c1 || c3 > c0 || c3 > c2 || c3 > c4) //Wenn 3 (hinten) mehr beleuchtet wird, als einer der anderen Sensoren          
      PORTB = 1 << 1; //PORTB1 = 5V (Rechts rum)
    //-----------------------------------------------------
    if (c1 > c0 + TOLERANCE || c1 < c0 - TOLERANCE) //Korrektur, falls die differenz zwischen 1 und 0 zu groß ist
    {
      if (c1 > c0)
        PORTB = 1 << 2; //links rum
      else
        PORTB = 1 << 1;   //rechts rum  
    }
    //-------------------------------------------------------
    if (c1 <= c0 + TOLERANCE && c1 >= c0 - TOLERANCE) // Falls die Werte zwischen den Frontsensoren in Ordnung sind, anhalten
      PORTB = 0;
  }
  //Ende fer Hauptschleife
  return 0;
}
//======================================================================
MfG

Blackbird

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>  ADCSRA = ADEN | 0b111;

Was soll denn das sein?

Tu dir selbst einen Gefallen und benutze die ADC Routine aus dem 
Tutorial so wie sie da drinnen steht. Die Referenz kannst du anpassen, 
aber den Rest lässt du erst mal so wie er ist.

Weiters künstelst du nicht mit dem Motor rum, sondern hängst dir erst 
mal einfach nur eine LED an einen Ausgang. An den ADC-Eingang (zuerst 
experimentierst du nur mit 1 ADC Eingang) hängst du ein Poti (so wie im 
Tut angegeben) und schreibst ein Programm, welches die LED einschaltet, 
wenn die Spannung am ADC (eingestellt mit dem Poti) über einem Grenzwert 
(den du im Programm fix vorgegeben hast) liegt. Durch Drehen des Potis 
links rum bzw. rechts rum kannst du die LED ein/aus schalten.

Das ist dein erstes Zwischenziel. Solange du das nicht erreicht hast, 
brauchst du nicht weiter machen.

Dein nächstes Zwischenziel ist es, den Grenzwert für den Vergleich über 
den 2.ten ADC Kanal einzustellen. D.h. du hast dann 2 Poti. Mit dem 
einen stellst du ein, welchen Wert das andere überschreiten muss, damit 
die LED leuchtet. Oder du steuerst 2 LED an, jede mit ihrem eigenen 
Poti. Im Grunde völlig egal, was du dir als Aufgabenstellung wählst - 
Ziel der Übung ist der Umgang mit 2 ADC-Eingangskanälen (die ADC Routine 
aus dem Tut hast du immer noch nicht angerührt - ausser der 
Referenzspannung - die ist immer noch so wie im Tut angegeben)

Und erst dann arbeitest du dich langsam an die Motoren ran. Immer 
Schritt für Schritt, nicht zu viele Änderungen auf einmal.

Tust du das nicht, dann gehts dir so wie es dir jetzt geht: Du stehst 
vor einem Code-Haufen der (natürlich) nicht funktioniert und hast keine 
Ahnung wo du mit der Fehlersuche anfangen sollst, weil du nichts in 
deinem Programm hast, das als bereits funktionierend und getestet 
abgehakt werden kann.


Und erst dann, wenn das alles so einigermassen läuft, gehst du her und 
mistest die Tut-ADC Routine aus, wie du das möchtest. Aber auch hier 
gehst du wieder nicht her und machst eine alles-in-einem-Aufwasch 
Rundumkur, sondern du arbeitest wieder in kleinen Schritten. Wenn in 
einem funktionierendem Programm eine kleine Veränderung gemacht wird und 
hinterher funktioniert es nicht mehr, dann hat man nur diese kleine 
Veränderung zu analysieren was da schief lief. Ändert man aber zuviel, 
dann weiß man nicht, welche der zig Änderungen für das 
Nichtfunktionieren verantwortlich ist.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.