-         

Ergebnis 1 bis 8 von 8

Thema: Ardressübergabe von z.B. OCRn ==>> LÄUFT!!

  1. #1
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    12.06.2006
    Beiträge
    473

    Ardressübergabe von z.B. OCRn ==>> LÄUFT!!

    Anzeige

    Hallo,

    wie kann ich an eine Funktion die Adresse von z.B. OCR2 übergeben?
    Ich hatte schon über google und die Suchfunktion geschaut, aber keine Variante gefunden, die bei mir funktioniert hat.

    Meine Version war:

    void funktion (unsigned int* addr1){

    }


    funktion(&OCR2);

    Hatte auch ähnliches gefunden, aber wenn ich das Programm aufspiele läuft es nicht. Weiß jemand, wie die richtig Syntax ist?

    The Man
    Chuck Norris kann Windows Vista auf einem Atmel in Assembler implementieren!
    Chuck Norris coded mit 3 Tasten:"1","0" und "compile"

  2. #2
    Super-Moderator Robotik Visionär Avatar von PicNick
    Registriert seit
    23.11.2004
    Ort
    Wien
    Beiträge
    6.836
    Wenn ich nicht irre, dann ist "OCR2" bereits die Adresse /pointer,
    also würde reichen
    funktion ((unsigned int*)OCR2 )
    mfg robert
    Wer glaubt zu wissen, muß wissen, er glaubt.

  3. #3
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    25.11.2003
    Beiträge
    1.111
    Ja, OCR2 ist die Adresse und die ist const, das heißt Du kannst eh in jedem Teil des Programms darauf zugreifen und musst sie nicht explizit übergeben.
    Gruß

  4. #4
    Erfahrener Benutzer Roboter Experte Avatar von sternst
    Registriert seit
    07.07.2008
    Beiträge
    672
    Zitat Zitat von PicNick
    funktion ((unsigned int*)OCR2 )
    Diese Zeile ließt das Register aus und interpretiert den Inhalt dann als Zeiger auf ein unsigned int.

    Richtig wäre:
    funktion ((unsigned int*)&OCR2 );

    Der OP müsste halt mal darlegen, was genau dann nicht funktioniert und zwar am besten zusammen mit dem Sourcecode.
    MfG
    Stefan

  5. #5
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    12.06.2006
    Beiträge
    473
    Hallo,

    mit der Version von sternst geht es.

    Bei mir repräsentieren die OCR Register jew. eine Farbe aus rgb.
    Im Mom muss immer schreiben

    funktion ((unsigned int*)&OCR1A,(unsigned int*)&OCR2,
    (unsigned int*)&OCR1B);

    was nicht sonderlich intuitiv ist.

    Deshalb wollte ich dieses Problem mit

    unsigned int* rot;
    rot = &OCRn;

    lösen. Allerdings ist der Compiler damit nicht einverstanden und sagt:
    ../rgb_in_C_c.c:129: warning: assignment from incompatible pointer type

    Weiß jemand wie das richtig läuft?

    The Man


    Code:
    #include <avr/io.h>
    #include <avr/interrupt.h>
    
    volatile unsigned char zyklus;
    volatile unsigned char helligkeit;
    
    SIGNAL (SIG_OVERFLOW2){
    zyklus++;
    if (zyklus >= helligkeit) PORTB |= (1<<PB0);
    else PORTB &= (0<<PB0);
    helligkeit = ADCH;
    }
    
    void init(){
    DDRB = 0b00001111;
    
    TIMSK = 0b01000000;
    
    TCNT1 = 254;// vorladen von TCNT1, damit T1 und T2 nacher synchron laufen
    ICR1 = 255;
    //***********************
    // Anteile der Farben
    OCR1A = 0; 
    OCR1B = 0; 
    OCR2 = 0;
    //************************
    
    
    TCCR1A |= (1<<COM1A1)|(1<<COM1A0)|(1<<COM1B1)|(1<<COM1B0)|(1<<WGM11);
    TCCR1B |= (1<<WGM13)|(1<<WGM12)|(1<<CS10);
    TCCR2 |= (1<<WGM20)|(1<<COM21)|(1<<COM20)|(1<<WGM21)|(1<<CS20);
    
    ADMUX = 0b00100000;
    ADCSRA = 0b11110101;
    
    sei();
    }
    void red_blau_grun_up(unsigned int* addr1, char ans1, unsigned int* addr2, char ans2,unsigned int* addr3){
    unsigned char verz;
    char f1;
    char f3;
    char f2;
    f1 = *addr1;
    f2 = *addr2;
    f3 = *addr2;
    do{
      do{
      do{
      //nur verzögern^^
      }while(zyklus<255);
      verz++;
      }while (verz<50);
      verz=0;
      if (f1 < 255) f1++;
      if ((f1 > ans1)&&(f2 < 255)) f2++;
      if ((f2 > ans2) && (f3 < 255)) f3++;
      *addr1 = f1;
      *addr2 = f2;
      *addr3 = f3;
    }while (f3<255);
      
    }
    
    void red_blau_grun_down(unsigned int* addr1, char ans1, unsigned int* addr2, char ans2,unsigned int* addr3){
    unsigned char verz;
    char f1;
    char f3;
    char f2;
    f1 = *addr1;//farbe 1
    f2 = *addr2;
    f3 = *addr2;
    do{
      do{
      do{
      //nur verzögern^^
      }while(zyklus<255);
      verz++;
      }while (verz<50);
      verz=0;
      if (f3 > 0) f3--;
      if ((f3 < ans1)&&(f2 > 0)) f2--;
      if ((f2 < ans2) && (f1 > 0)) f1--;
      *addr1 = f1;
      *addr2 = f2;
      *addr3 = f3;
    }while (f1 > 0);
    
    }
    
    void up(unsigned int* addr1)
    {
    char f1;
    char verz = 0;
    f1 = *addr1;
    do{
    do{
      do{
      //nur verzögern^^
      }while(zyklus<255);
      verz++;
      }while (verz<50);
      verz = 0;
    if (f1 < 255) f1++;
    *addr1 = f1;
    }while (f1 < 255);
    }
    
    void down(unsigned int* addr1)
    {
      char verz = 0;
      char f1;
      f1 = *addr1;
      do{
         do{
      do{
      //nur verzögern^^
      }while(zyklus<255);
      verz++;
      }while (verz<50);
      verz = 0;
         if (f1 > 0) f1--;
         *addr1 = f1;
      }while (f1 > 0);
    }
    
    int main(void)
    {
    unsigned int* rot;
    rot = &OCR2;
    
    init();
    main2:
    up ((unsigned int*)&OCR2);
    down ((unsigned int*)&OCR2);
    
    
    up ((unsigned int*)&OCR1A);
    down ((unsigned int*)&OCR1A);
    
    up ((unsigned int*)&OCR1B);
    down ((unsigned int*)&OCR1B);
    
    up ((unsigned int*)&OCR2);//rot h
    up ((unsigned int*)&OCR1A);//blau h
    down ((unsigned int*)&OCR2);//rot d
    up ((unsigned int*)&OCR1B);//grun h
    down ((unsigned int*)&OCR1A);//blau d
    up ((unsigned int*)&OCR2);//rot h
    down ((unsigned int*)&OCR1B);//grun d
    up ((unsigned int*)&OCR1A);//blau h
    down ((unsigned int*)&OCR2);//rot d
    down ((unsigned int*)&OCR1A);//blau d
    
    red_blau_grun_up((unsigned int*)&OCR2,0,(unsigned int*)&OCR1A,0,(unsigned int*)&OCR1B);
    red_blau_grun_down((unsigned int*)&OCR2,255,(unsigned int*)&OCR1A,255,(unsigned int*)&OCR1B);
    //*********************************************************
    red_blau_grun_up((unsigned int*)&OCR2,85,(unsigned int*)&OCR1A,85,(unsigned int*)&OCR1B);
    red_blau_grun_down((unsigned int*)&OCR2,171,(unsigned int*)&OCR1A,171,(unsigned int*)&OCR1B);
    
    red_blau_grun_up((unsigned int*)&OCR1B,85,(unsigned int*)&OCR2,85,(unsigned int*)&OCR1A);
    red_blau_grun_down((unsigned int*)&OCR1B,171,(unsigned int*)&OCR2,171,(unsigned int*)&OCR1A);
    
    red_blau_grun_up((unsigned int*)&OCR1A,85,(unsigned int*)&OCR1B,85,(unsigned int*)&OCR2);
    red_blau_grun_down((unsigned int*)&OCR1A,171,(unsigned int*)&OCR1B,171,(unsigned int*)&OCR2);
    //*********************************************************
    //*********************************************************
    red_blau_grun_up((unsigned int*)&OCR2,85,(unsigned int*)&OCR1B,85,(unsigned int*)&OCR1A);
    red_blau_grun_down((unsigned int*)&OCR2,171,(unsigned int*)&OCR1B,171,(unsigned int*)&OCR1A);
    
    red_blau_grun_up((unsigned int*)&OCR1B,85,(unsigned int*)&OCR1A,85,(unsigned int*)&OCR2);
    red_blau_grun_down((unsigned int*)&OCR1B,171,(unsigned int*)&OCR1A,171,(unsigned int*)&OCR2);
    
    red_blau_grun_up((unsigned int*)&OCR1A,85,(unsigned int*)&OCR2,85,(unsigned int*)&OCR1B);
    red_blau_grun_down((unsigned int*)&OCR1A,171,(unsigned int*)&OCR2,171,(unsigned int*)&OCR1B);
    //*********************************************************
    //*********************************************************
    goto main2;
    return 0;
    }
    Chuck Norris kann Windows Vista auf einem Atmel in Assembler implementieren!
    Chuck Norris coded mit 3 Tasten:"1","0" und "compile"

  6. #6
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    08.07.2004
    Ort
    Südhessen
    Beiträge
    1.312
    Zitat Zitat von The Man
    unsigned int* rot;
    rot = &OCRn;
    So müsste es gehen:

    Code:
    unsigned int* rot;
    rot = (unsigned int*)&OCR2
    Getestet -> Bei mir kommt kein Fehler.

    Allerdings machen mir beim Disassemblieren diese zwei Zeilen Sorgen:
    Code:
    +00000030:   B7CD        IN      R28,0x3D         In from I/O location
    +00000031:   B7DE        IN      R29,0x3E         In from I/O location

  7. #7
    Erfahrener Benutzer Roboter Experte Avatar von sternst
    Registriert seit
    07.07.2008
    Beiträge
    672
    Allerdings machen mir beim Disassemblieren diese zwei Zeilen Sorgen:
    Code:
    +00000030:   B7CD        IN      R28,0x3D         In from I/O location
    +00000031:   B7DE        IN      R29,0x3E         In from I/O location
    Hier wird der Stackpointer in Register geladen.
    Inwiefern macht dir das Sorgen?
    MfG
    Stefan

  8. #8
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    12.06.2006
    Beiträge
    473
    THX! @ the wulf

    So das geht jetzt und kann auch gut gelesen werden.

    The Man

    Die Zahlenübergaben in den Funktionsaufrufen geben an, welchen Wert die Zahl n der Adresse N haben muss, damit die darauf folgende Zahl der Adresse N+1 verändert wird.
    Deshalb habe ich die auch zwischen den Addressübergaben angeordnet.

    Code:
    #include <avr/io.h>
    #include <avr/interrupt.h>
    
    volatile unsigned char zyklus;
    volatile unsigned char helligkeit;
    
    SIGNAL (SIG_OVERFLOW2){
    zyklus++;
    if (zyklus >= helligkeit) PORTB |= (1<<PB0);
    else PORTB &= (0<<PB0);
    helligkeit = ADCH;
    }
    
    void init(){
    DDRB = 0b00001111;
    
    TIMSK = 0b01000000;
    
    TCNT1 = 254;// vorladen von TCNT1, damit T1 und T2 nacher synchron laufen
    ICR1 = 255;
    //***********************
    // Anteile der Farben
    OCR1A = 0; 
    OCR1B = 0; 
    OCR2 = 0;
    //************************
    
    
    TCCR1A |= (1<<COM1A1)|(1<<COM1A0)|(1<<COM1B1)|(1<<COM1B0)|(1<<WGM11);
    TCCR1B |= (1<<WGM13)|(1<<WGM12)|(1<<CS10);
    TCCR2 |= (1<<WGM20)|(1<<COM21)|(1<<COM20)|(1<<WGM21)|(1<<CS20);
    
    ADMUX = 0b00100000;
    ADCSRA = 0b11110101;
    
    sei();
    }
    void all_up(unsigned int* addr1, char ans1, unsigned int* addr2, char ans2,unsigned int* addr3){
    unsigned char verz;
    char f1;
    char f3;
    char f2;
    f1 = *addr1;
    f2 = *addr2;
    f3 = *addr2;
    do{
      do{
      do{
      //nur verzögern^^
      }while(zyklus<255);
      verz++;
      }while (verz<50);
      verz=0;
      if (f1 < 255) f1++;
      if ((f1 > ans1)&&(f2 < 255)) f2++;
      if ((f2 > ans2) && (f3 < 255)) f3++;
      *addr1 = f1;
      *addr2 = f2;
      *addr3 = f3;
    }while (f3<255);
      
    }
    
    void all_down(unsigned int* addr1, char ans1, unsigned int* addr2, char ans2,unsigned int* addr3){
    unsigned char verz;
    char f1;
    char f3;
    char f2;
    f1 = *addr1;//farbe 1
    f2 = *addr2;
    f3 = *addr2;
    do{
      do{
      do{
      //nur verzögern^^
      }while(zyklus<255);
      verz++;
      }while (verz<50);
      verz=0;
      if (f3 > 0) f3--;
      if ((f3 < ans1)&&(f2 > 0)) f2--;
      if ((f2 < ans2) && (f1 > 0)) f1--;
      *addr1 = f1;
      *addr2 = f2;
      *addr3 = f3;
    }while (f1 > 0);
    
    }
    
    void up(unsigned int* addr1)
    {
    char f1;
    char verz = 0;
    f1 = *addr1;
    do{
    do{
      do{
      //nur verzögern^^
      }while(zyklus<255);
      verz++;
      }while (verz<50);
      verz = 0;
    if (f1 < 255) f1++;
    *addr1 = f1;
    }while (f1 < 255);
    }
    
    void down(unsigned int* addr1)
    {
      char verz = 0;
      char f1;
      f1 = *addr1;
      do{
         do{
      do{
      //nur verzögern^^
      }while(zyklus<255);
      verz++;
      }while (verz<50);
      verz = 0;
         if (f1 > 0) f1--;
         *addr1 = f1;
      }while (f1 > 0);
    }
    
    int main(void)
    {
    unsigned int* rot;
    unsigned int* blau;
    unsigned int* grun;
    rot = (unsigned int*)&OCR2;
    blau = (unsigned int*)&OCR1A;
    grun = (unsigned int*)&OCR1B;
    
    init();
    main2:
    
    up (rot);
    down (rot);
    
    
    up (blau);
    down (blau);
    
    up (grun);
    down (grun);
    
    up (rot);//rot h
    up (blau);//blau h
    down (blau);//blau d
    down (rot);//rot d
    
    up (rot);//rot h
    up (grun);//blau h
    down (grun);//blau d
    down (rot);//rot d
    
    up(grun);
    up(rot);
    down(rot);
    down(grun);
    
    up(grun);
    up(blau);
    down(blau);
    down(grun);
    
    up(blau);
    up(rot);
    down(rot);
    down(blau);
    
    up(blau);
    up(grun);
    down(grun);
    down(blau);
    
    
    
    
    all_up(rot,0,blau,0,grun);
    all_down(rot,255,blau,255,grun);
    //*********************************************************
    all_up(rot,85,blau,85,grun);
    all_down(rot,171,blau,171,grun);
    
    all_up(grun,85,rot,85,blau);
    all_down(grun,171,rot,171,blau);
    
    all_up(blau,85,grun,85,rot);
    all_down(blau,171,grun,171,rot);
    //*********************************************************
    //*********************************************************
    all_up(rot,85,grun,85,blau);
    all_down(rot,171,grun,171,blau);
    
    all_up(grun,85,blau,85,rot);
    all_down(grun,171,blau,171,rot);
    
    all_up(blau,85,rot,85,grun);
    all_down(blau,171,rot,171,grun);
    //*********************************************************
    //*********************************************************
    goto main2;
    return 0;
    }
    Chuck Norris kann Windows Vista auf einem Atmel in Assembler implementieren!
    Chuck Norris coded mit 3 Tasten:"1","0" und "compile"

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •