Schrittmotoren

[amal (Gast)]

bitte um Korrektur, der Motor sollte nach 100 Schritte anhalten, aber 
das tut er nicht:
[c]
#include <avr/io.h>
#include <avr/interrupt.h>
unsigned int zx=0,zy=0;
void motorxR(unsigned int schr);
void motorxL(unsigned int schr);

int main()
{
DDRB=(1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3)|(1<<PB4)| (1<<PB5); // PIN0-5 
als Ausgang für die Motoren definieren // PortB als Ausgang definieren
DDRC = 0; //PORTC als Eingang für PCINT MASK 1 definieren



TCCR1A = (1<<COM1A0) | (0<<WGM11);
TCCR1B = (0<<WGM13) | (1<<WGM12) | (1<<CS10);
OCR1A=18432;


//****************** Interrupt initialisieren 
*************************************
PCMSK1 = (1 << PCINT|(1 << PCINT9)|(1 << PCINT10)|(1 << PCINT11)|(1 << 
PCINT12)|(1 << PCINT13); //Pin C0-5 für Pin Change Interrupt in Maske 1 
setzen
PCICR |= (1 << PCIE1); //Pin Change Interrupt Control Register - PCIE3 
setzen für PCINT30

//*********** TIMER1 OVF *****************

TIMSK1|=(1<<TOIE1);
sei();

while (1) {}
}

ISR(TIMER1_OVF_vect)
{
zx++;
if(zx>100)
{
PORTB&=~(1<<PB0);
TCCR1B&=~(1<<CS10);
}
zx=0;
}

ISR(PCINT1_vect) //Interrupt Service Routine
{
if(!(PINC&(1<<PC0)))
{motorxR(zx);
}
if(!(PINC&(1<<PC1)))
{motorxL(zx);
}
}

void motorxR(unsigned int schr)
{
PORTB|=(1<<PB4);
PORTB|=(1<<PB0);
}
void motorxL(unsigned int schr)
{
PORTB&=~(1<<PB4);
PORTB|=(1<<PB0);
} [c]

[Albert .. (albert-k)]

Der Fehler liegt hier drin
amal schrieb:
> unsigned int zx=0,zy=0;
Du musst die Variablen zx und als volatile deklarieren. Sonst weiß der 
kompiler nicht das zx auch von außerhalb der ISR gesetzt werden kann und 
das er sie nicht bei jeder ausfürhugn der ISR neu initialisieren soll.

[Nikos (Gast)]

Ohne das jetzt gelesen zu haben ...
Globale Variablen müssen mit volatile deklariert werden wenn sie in der 
ISR routine verändert werden sollen

[Nikos (Gast)]

ups zu langsam ... :-D

[amal (Gast)]

amal schrieb:
Nikos schrieb:
> ups zu langsam ... :-D
was ist zu langsam

[amal (Gast)]

es ist leider nicht der Fall, der Motor dreht sich immer noch ohne ende.

[Albert .. (albert-k)]

Mir ist in der ISR beim genaueren betrachten folgendes aufgefallen:
amal schrieb:
> ISR(TIMER1_OVF_vect)
> {
> zx++;
> if(zx>100)
> {
> PORTB&=~(1<<PB0);
> TCCR1B&=~(1<<CS10);
> }
> zx=0;
> }
Du zählst zx am Anfang hoch udn vergleichst dann, und am Ende setzt du 
es wieder auf 0 zurück. natürlich wird es so niemals 100 erreichen da es 
immer wieder bei 0 anfängt. Du musst zx=0 in die if-Abfrage packen.

[ulp (Gast)]

das liegt daran das du zx direkt wieder auf 0 setzt

das muss in die if anweisung

[amal (Gast)]

#include <avr/io.h>
#include <avr/interrupt.h>
volatile uint16_t zx=0,
void motorxR(unsigned int schr);
void motorxL(unsigned int schr);

int main()
{
DDRB=(1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3)|(1<<PB4)| (1<<PB5); // PIN0-5
als Ausgang für die Motoren definieren // PortB als Ausgang definieren
DDRC = 0; //PORTC als Eingang für PCINT MASK 1 definieren



TCCR1A = (1<<COM1A0) | (0<<WGM11);
TCCR1B = (0<<WGM13) | (1<<WGM12) | (1<<CS10);
OCR1A=18432;


//****************** Interrupt initialisieren
*************************************
PCMSK1 = (1 << PCINT|(1 << PCINT9)|(1 << PCINT10)|(1 << PCINT11)|(1 <<
PCINT12)|(1 << PCINT13); //Pin C0-5 für Pin Change Interrupt in Maske 1
setzen
PCICR |= (1 << PCIE1); //Pin Change Interrupt Control Register - PCIE3
setzen für PCINT30

//*********** TIMER1 OVF *****************

TIMSK1|=(1<<TOIE1);
sei();

while (1) {}
}

ISR(TIMER1_OVF_vect)
{
zx++;
if(zx>100)
{
PORTB&=~(1<<PB0);
TCCR1B&=~(1<<CS10);
}
zx=0;
}

ISR(PCINT1_vect) //Interrupt Service Routine
{
if(!(PINC&(1<<PC0)))
{motorxR(zx);
}
if(!(PINC&(1<<PC1)))
{motorxL(zx);
}
}

void motorxR(unsigned int schr)
{
PORTB|=(1<<PB4);
PORTB|=(1<<PB0);
}
void motorxL(unsigned int schr)
{
PORTB&=~(1<<PB4);
PORTB|=(1<<PB0);
}

ja wie gesagt der Motor dreht sich permanent

[amal (Gast)]

C-
#include <avr/io.h>
#include <avr/interrupt.h>
volatile uint16_t zx=0,
void motorxR(unsigned int schr);
void motorxL(unsigned int schr);

int main()
{
DDRB=(1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3)|(1<<PB4)| (1<<PB5); // PIN0-5
als Ausgang für die Motoren definieren // PortB als Ausgang definieren
DDRC = 0; //PORTC als Eingang für PCINT MASK 1 definieren



TCCR1A = (1<<COM1A0) | (0<<WGM11);
TCCR1B = (0<<WGM13) | (1<<WGM12) | (1<<CS10);
OCR1A=18432;


//****************** Interrupt initialisieren
*************************************
PCMSK1 = (1 << PCINT|(1 << PCINT9)|(1 << PCINT10)|(1 << PCINT11)|(1 <<
PCINT12)|(1 << PCINT13); //Pin C0-5 für Pin Change Interrupt in Maske 1
setzen
PCICR |= (1 << PCIE1); //Pin Change Interrupt Control Register - PCIE3
setzen für PCINT30

//*********** TIMER1 OVF *****************

TIMSK1|=(1<<TOIE1);
sei();

while (1) {}
}

ISR(TIMER1_OVF_vect)
{
zx++;
if(zx>100)
{
PORTB&=~(1<<PB0);
TCCR1B&=~(1<<CS10);
}
zx=0;
}

ISR(PCINT1_vect) //Interrupt Service Routine
{
if(!(PINC&(1<<PC0)))
{motorxR(zx);
}
if(!(PINC&(1<<PC1)))
{motorxL(zx);
}
}

void motorxR(unsigned int schr)
{
PORTB|=(1<<PB4);
PORTB|=(1<<PB0);
}
void motorxL(unsigned int schr)
{
PORTB&=~(1<<PB4);
PORTB|=(1<<PB0);
}

ja wie gesagt der Motor dreht sich permanent

[ulp (Gast)]

das liegt daran das du zx direkt wieder auf 0 setzt

das muss in die if anweisung

ulp schrieb:
> das liegt daran das du zx direkt wieder auf 0 setzt
>
> das muss in die if anweisung

[Tip (Gast)]

Kannst du mit deiner Entwicklungsumgebnung (welche?) den Programmablauf 
nicht simulieren und dabei die Variablenwerte verfolgen? Dann würdest du 
sofort sehen, wenn etwas anders läuft als vorgesehen.
AVR-Strudio 4.18 z.B. konnte das.

[amal (Gast)]

Tip schrieb:
> Kannst du mit deiner Entwicklungsumgebnung (welche?) den Programmablauf
> nicht simulieren und dabei die Variablenwerte verfolgen? Dann würdest du
> sofort sehen, wenn etwas anders läuft als vorgesehen.
> AVR-Strudio 4.18 z.B. konnte das.

ich könnte das nur wenn ich mit Assembler programmiere, in C weiß ich 
nicht wie das geht, weil du gar nicht weißt wo dein Prog steht. auf 
jedenfall der Fehler liegt daran, dass ich nie einen OVF erreichen kann, 
weil in CTC Mode 4 erreicht man OVF nur bei Max=FFFF, deswegen wird ich 
jetzt anderen Weg nehmen, und zwar über ISR(TIMER1_COMPA_Vect).übrigens 
ich habe AVR4.14

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Albert ... schrieb:
> Du musst die Variablen zx und als volatile deklarieren. Sonst weiß der
> kompiler nicht das zx auch von außerhalb der ISR gesetzt werden kann und
> das er sie nicht bei jeder ausfürhugn der ISR neu initialisieren soll.
Falsch.

Nikos schrieb:
> Globale Variablen müssen mit volatile deklariert werden wenn sie in der
> ISR routine verändert werden sollen
Auch falsch. Aber schon ein wenig besser... ;-)

Variablen müssen als volatil deklariert werden, wenn sie unverhofft von 
ausserhalb einer Funktion geändert werden könnten. Wenn z.B. in einer 
"normalen" Funktion ein Wert verwendet wird, sich dieser Wert aber von 
aussen ändern kann (z.B. ein Timer oder ein Pin oder eine globale 
Variable), dann muß dem Compiler gesagt werden, er soll diesen Wert doch 
bitte jedesmal neu einlesen. Und dieses "der Wert kann sich unvermittlet 
ändern" bedeutet volatil (=flüchtig).

Eine globale Variable, die in einer nicht unterbrechbaren 
Interuptroutine nur gelesen wird, braucht dieses Schlüsselwort also 
sicher nicht.

Eine globale Variable, die nur in 1 Interuptroutine verwendet, braucht 
dieses Schlüsselwort auch nicht.

Ein Problem wurde schon genannt:

ISR(TIMER1_OVF_vect)
{
  zx++;      // hochzählen 
  if(zx>100) 
  {
    PORTB&=~(1<<PB0);
    TCCR1B&=~(1<<CS10);
  }  
  zx=0;      // zu Null setzen
}

zx wird NIEMALS größer 100.
zx hatt immer nur die Werte 0 und 1.
Die meiste Zeit ist zx = 0.

@ amal
Formatier deinen Quelltext mit Einrückungen, dann siehst du das gleich..

[Jannis C. (kabelwurm)]

Hallo,
Du must beim Hochzählen beachten, dass du wirklich zwei Möglichkeiten 
programmierst.

ISR(TIMER1_OVF_vect)
{
  zx++;      // hochzählen
  if(zx>100)      {
      PORTB&=~(1<<PB0);
      TCCR1B&=~(1<<CS10);
      }
  zx=0;      // zu Null setzen
}
Bei dem hier gibt es nur eine Möglichkeit da zx den Wert 100 nie 
erreichen kann.

ISR(TIMER1_OVF_vect)
{

  if(zx>100)
  {
    PORTB&=~(1<<PB0);
    TCCR1B&=~(1<<CS10);
    zx=0;      // zu Null setzen
  }esle{
    zx++;      // hochzählen
  }

}
Bei dieser Variante wird zx nur dann auf 0 gesetzt, wenn die Abfrage 
zutrifft.
Gruß Jannis

[amal (Gast)]

ich habe jetzt den COMP Interrupt benutzt, ich möchte jetzt zum beispiel 
100schritte machen dann auf einem PIN eine PWM signal ausgeben, dann 
nochmal 100 Schritte, das ganze 10mal,das heißt der Motor soll sich 1000 
Schritte machen und 10 mal pwm signal ausgeben. und das habe ich so 
realisiert, ich bitte um Korrektur.

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





volatile uint16_t zx=0,zy=0;
void motorxR(void);

void sleep_ms(unsigned int ms);



    


int main()
{


    DDRB=(1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3)|(1<<PB4)|(1<<PB5); // PIN0-5 als Ausgang für die Motoren definieren                // PortB als Ausgang definieren
    DDRC = 0;                     //PORTC als Eingang für PCINT MASK 1 definieren


  // Timer 1 einstellen
  //  
  // Modus 15:
  //    Fast PWM, Top von OCR1A
  //
  //    WGM13    WGM12   WGM11    WGM10
  //      0        1       0        0
  //
  //    Timer Vorteiler: 1
  //     CS12     CS11    CS10
  //       0        0       1
  //
  //  Steuerung des Ausgangsport: Set at BOTTOM, Clear at match
  //     COM1A1   COM1A0
  //       0        1
 // OCR1A=(fclk/2*N)-1  N: Vorteiler
          TCCR1A = (1<<COM1A0) | (0<<WGM11)| (0<<WGM10);
         TCCR1B = (0<<WGM13) | (1<<WGM12) | (1<<CS10);
         OCR1A=18432;


//******************               Interrupt initialisieren             *************************************
    PCMSK1 = (1 << PCINT8)|(1 << PCINT9)|(1 << PCINT10)|(1 << PCINT11)|(1 << PCINT12)|(1 << PCINT13);      //Pin C0-5 für Pin Change Interrupt in Maske 1 setzen
    PCICR  |= (1 << PCIE1);      //Pin Change Interrupt Control Register - PCIE3 setzen für PCINT30

//***********  TIMER1 COMP *****************

        TIMSK1|=(1<<OCIE1A);
        TCNT1=0;

    

sei();    

        
    


 
  while (1) {}
}



ISR(TIMER1_COMPA_vect)
{
       if(zx>100)
        {
        PORTB&=~(1<<PB0);
        }
    zx++;
  
}

ISR(PCINT1_vect)            //Interrupt Service Routine
{

        sei();
        //*******************************       MESSUNG STARTEN    ********************************************
//*****************************************************************************************************

  if(!(PINC&(1<<PC0)))
     {
    
             for(unsigned int j=0;j<10;j++)
            {    
                  motorxR();
                PORTB|=(1<<PB5);        //
                sleep_ms(5);            //   TRIGGERN
                PORTB&=~(1<<PB5);        //
                sleep_ms(2);*/
                zx=0;            // WARTEN 2ms
            }
    }

void motorxR(void)
{
  PORTB|=(1<<PB3);
  PORTB|=(1<<PB0);
  //PORTB&=~(1<<PB2);

}



void sleep_ms(unsigned int ms)
{
  for (unsigned int s=0; s<ms; s++)
   {
    for (long int i=0; i<461; i++) 
  {
      asm volatile("nop"); 
    }
   }
}

[Jannis C. (kabelwurm)]

Hallo



ISR(PCINT1_vect)            //Interrupt Service Routine
{

       sei ();


Willst du an dieser Stelle den Interrupt erlauben oder nicht?
Wenn du in abschalten willst dann musst du diesen Befehl benutzen: cli 
().
Gruß Jannis

[amal (Gast)]

Jannis C. schrieb:
> Willst du an dieser Stelle den Interrupt erlauben oder nicht?

erlauben, ich will den nicht löschen

[Tip (Gast)]

amal schrieb:
> ich könnte das nur wenn ich mit Assembler programmiere, in C weiß ich
> nicht wie das geht, weil du gar nicht weißt wo dein Prog steht.

Wieso weißt du nicht wie das geht, wenn ich nicht weiß, wo mein "Prog" 
steht?

In C unter AVRStudio gibt es im Menü "Debug" einige nützliche 
Funktionen. Vielleicht solltest du dich damit mal beschäftigen. Das 
würde dir die Fehlersuche deutlich erleichtern.

[Jannis C. (kabelwurm)]

Hallo,
Um den Interrupt zu löschen musst du aber cli (); schreiben.
                sleep_ms(2);
Dafür gibt es delay- Funktion. Du musst also also die Funktion sleep 
löschen und ein paar Zeilen ergänzen.

#ifndef F_CPU
#define F_CPU ( Takt in Herz) UL
#endif

#include <util/delay.h>

Die vier Zeilen kopierst du dir unter die anderen Includes.
Anstelle von Sleep schreibst du jetzt _delay_ms(Zeit in Ms);

Gruß Jannis

[amal (Gast)]

aber trotzdem der Motor macht nur 100 Schritte, nicht 10x100. weißt 
jemand warum