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

[The Man]

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

[PicNick]

Wenn ich nicht irre, dann ist "OCR2" bereits die Adresse /pointer,
also würde reichen
funktion ((unsigned int*)OCR2 )

[Gock]

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ß

[sternst]

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.

[The Man]

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




#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;
}

[thewulf00]

unsigned int* rot;
rot = &OCRn;


So müsste es gehen:


unsigned int* rot;
rot = (unsigned int*)&OCR2

Getestet -> Bei mir kommt kein Fehler.

Allerdings machen mir beim Disassemblieren diese zwei Zeilen Sorgen:

+00000030: B7CD IN R28,0x3D In from I/O location
+00000031: B7DE IN R29,0x3E In from I/O location

[sternst]

Allerdings machen mir beim Disassemblieren diese zwei Zeilen Sorgen:

+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?

[The Man]

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.



#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;
}