Anfänger: Motorsteuerung funktioniert nicht richtig - mal bitte drüber sehen

[Rocco L. (kaufparkangucker)]

Hallo,

ich bastel gerade an einem "Thermomixer". Der Größte Teil funzt auch 
schon nur mit der Motorsteuerung stelle ich mich irgendwie doof an.
Das ganze Projekt ist um einen Mega 16 aufgebaut, den ich als 
"Mainframe" bezeichne. An diesem Mega 16 hängen 4 Stück Mega 48. Drei 
davon messen mit einem 1 wire Sensor die Temperatur und einer kümmert 
sich um den Motor.

Das Arbeitsprinzip ist so das es ein Wärmebad und ein Kältebad gibt in 
denen jeweils die Temperatur gemessen wird. Außerdem wird die Temperatur 
einer Probe gemessen.
Es wird zuerst verglichen ob die Temperatur der Probe mit der Temperatur 
des Kältebads übereinstimmt - wenn ja wird der Motor gestartet und die 
Probe fährt ins Wärmebad. Nun wir wieder die Temperatur zw. Probe und 
Wärmebad verglichen und wenn die Temperaturen gleich sind wird wieder 
ins Kältebad gefahren.

Am Kälte und am Wärmebad gibt es je einen Anschlagschalter der dem 
Atmega 48, der den Motor Steuert, ein Signal gibt, das dazu führt das 
der Motor stoppt.
Diese Anschlagschalter sind zusätzlich noch mit dem Mainframe verbunden.

Der Teil, wo der Motor zur initialisierung erst mal ins Kältebad fährt 
funktioniert einwandfrei, aber ab da an kommt nur noch Unsinn heraus.

Ich traue mich jetzt mal die beiden Quelltexte hier mit anzuhängen:

Also erst mal die Motoransteuerung:

//C0 cw in vom Mainframe
//C1 ccw in vom Mainframe
//
//C2 Taster K?ltebad
//C3 Taster W?rmebad
//
//D6 cw out zum Motor  -> Richtung K?ltebad
//D7 ccw out zum Motor  -> Richtung W?rmebad
//D2 LED on als Anzeige das mit dem Beladen begonnen werden kann

#define F_CPU 1000000UL

//#include <inttypes.h>
#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>
//#include <avr/interrupt.h>


#define MOTOR_DDR        DDRD        //MOTOR und LED
#define TASTER_DDR       DDRC        //Anschlagtaster und Mainframe
#define MOTOR_PORT       PORTD       //PORTD
#define STROMVERSORGUNG       PD5         //LED
#define MOTORCW_PORTPIN   PD6         //Richtung Kältebad
#define MOTORCCW_PORTPIN PD7         //Richtung Wärmebad

#define MAIN_CW           PC0         //cw vom Mainframe -> Richtung Kältebad
#define MAIN_CCW       PC1         //ccw vom Mainframe -> Richtung Wärmebad
#define TASTER_KALT      PC2         //Anschlagtaster Kältebad
#define TASTER_WARM      PC3         //Anschlagtaster Wärmebad




////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//****************************************
//Einstiegspunkt
int main(void)
{

        TASTER_DDR = 0x00;    //Eing?nge
        MOTOR_DDR  = 0xFF;    //Ausg?nge
        MOTOR_PORT = 0x00;    //D-PINs alle auf low

//Initialisierung : erst mal zum Kältebad fahren
    for(int a=0; a<20; a++){ _delay_ms( 1000 ); }    
        //Wenn Taster vom K?ltebad aus,
        if(!(PINC & (1<<TASTER_KALT)))          
        {
                //=> Motor Richtung K?ltebad fahren.
                MOTOR_PORT |= (1<<MOTORCW_PORTPIN);
        MOTOR_PORT |= (1<<STROMVERSORGUNG);        

                //warten bis Taster vom K?ltebad durch Motor gedr?ckt wurde
                while(!(PINC & (1<<TASTER_KALT)))      
                {}

                //=> Motor anhalten
                MOTOR_PORT &= ~(1<<MOTORCW_PORTPIN);        
        MOTOR_PORT &= ~(1<<STROMVERSORGUNG);
        }
        
        // Hauptroutine
        while(1)
        {
                //Mainframe: Wenn Signal f?r Richtung W?rmebad anliegt
                if((PINC & (1<<MAIN_CCW)) && !(PINC & (1<<MAIN_CW)))         
                {
                        //=> Motor Richtung W?rmebad fahren.
                        MOTOR_PORT |= (1<<MOTORCCW_PORTPIN);
            MOTOR_PORT |= (1<<STROMVERSORGUNG);  
            
             //warten bis Taster vom K?ltebad durch Motor gedr?ckt wurde
                    while(!(PINC & (1<<TASTER_WARM)))      
                    {}

                    //=> Motor anhalten
                    MOTOR_PORT &= ~(1<<MOTORCCW_PORTPIN);        
            MOTOR_PORT &= ~(1<<STROMVERSORGUNG);          
                }
                //Mainframe: Wenn Signal f?r Richtung K?ltebad anliegt
                else if((PINC & (1<<MAIN_CW)) && !(PINC & (1<<MAIN_CCW)))  
                {
                        //=> Motor Richtung K?ltebad fahren.
            MOTOR_PORT |= (1<<STROMVERSORGUNG);
                        MOTOR_PORT |= (1<<MOTORCW_PORTPIN);
            
            //warten bis Taster vom K?ltebad durch Motor gedr?ckt wurde
                    while(!(PINC & (1<<TASTER_KALT)))      
                    {}

                    //=> Motor anhalten
                    MOTOR_PORT &= ~(1<<MOTORCW_PORTPIN);        
            MOTOR_PORT &= ~(1<<STROMVERSORGUNG);            
                }
                //Taster: K?ltebad ODER W?rmebad gedr?ckt
                //else if( ( (PINC & (1<<TASTER_KALT)) || (PINC & (1<<TASTER_WARM)) )
                            //und wenn Motor noch nicht angehalten wurde
                            //&& ( PORTD & (1<<MOTORCW_PORTPIN) || PORTD & (1<<MOTORCCW_PORTPIN) ) )
                //{
                        //Motor anhalten (cw und ccw Pin f?r Motor auf Low setzen)
                       // MOTOR_PORT &= ~( (1<<MOTORCW_PORTPIN) | (1<<MOTORCCW_PORTPIN) | (1<<STROMVERSORGUNG) );
                //}

        }//Hauptroutine / while(1)
}//main()

Hier noch der Mainframe:

//B2 Taster K?ltebad
//B3 Taster W?rmebad



#include <avr/io.h>
#include <avr/interrupt.h>
#define F_CPU 2000000
#include <util/delay.h>
#include <inttypes.h>
#include <stdint.h>

#define TRUE 1
#define FALSE 0

// Anchlussbelegung:

#define KTEMP_DDR DDRD        //Temperatur Input vom Kältebad
#define WTEMP_DDR DDRC        //Temperatur Input vom Wärmebad
#define PTEMP_DDR DDRA        //Temperatur Input von Probe

#define MOTOR_DDR DDRB        //Datenrichtung zum Motor-Steuer-Atmega festlegen
#define MOTOR_OUT PORTB        //Ausgänge zum Motor-Steuer-Atmega
#define MOTOR_IN  PINB

#define WTEMP_IN   PINC        //Wärmebad abfragen
#define KTEMP_IN   PIND        //Kältebad abfragen      
#define PTEMP_IN   PINA        //Probentemperatur abfragen

#define CW   PB0          //Motor cw richtung Kältebad
#define CCW  PB1          //Motor ccw richtung Wärmebad
#define KB   PB2          //Taster Kältebad abfragen 
#define WB   PB3          //Taster Wärmebad abfragen








int main(void)
{
    uint8_t w_temp = 0;          //Variable zum speichern der Zustände vom Wärmebad
    uint8_t k_temp = 0;          //Variable zum speichern der Zustände vom Kältebad
    uint8_t p_temp = 0;          //Variable zum speichern der Zustände von der Probe
         
        const uint16_t pause = 200;
    const uint16_t pause_2 =80;
    
    
    KTEMP_DDR = 0x00;    //Eing?nge
        WTEMP_DDR = 0x00;    //Eing?nge
    PTEMP_DDR = 0x00;    //Eing?nge
    //B0 und B1 als Ausgänge, B2 und B3 als Eingänge:
    MOTOR_DDR = DDRB = (1 << DDB0) | (1 << DDB1) | (0 << DDB2) | (0 << DDB3);
        


    //Pause für 20 Sekunden damit alles andere initialisieren kann
    //for(int a=0; a<10; a++){_delay_ms( 1000 )};
    

        do
        {
      k_temp = KTEMP_IN;          //Temp vom Kältebad abholen
      p_temp = PTEMP_IN;          //Temp der Probe abholen
      w_temp = WTEMP_IN;          //Temp vom Wärmebad abholen

      //Wenn Taster vom K?ltebad an (d.h. Probe ist im Kältebad)
      if((PINB & (1<<KB)) && (p_temp <= k_temp + 1))
      {
         //ins Wärmebad fahren)
         PORTB &= ~ (1<<CCW);
         PORTB |= (1<<CW);
      }
         
      //Wenn Taster vom Wärmebad an (d.h. Probe ist im Wärmebad)
      else if((PINB & (1<<WB)) && (p_temp >= w_temp - 1))
      {
         //ins Kältebad fahre
         PORTB &= ~ (1<<CW);
         PORTB |= (1<<CCW);
      }
        } //ENDE do
    while(1);

} //ENDE main

danke Rocco

[Karl H. (kbuchegg)]

Rocco L. schrieb:

> Der Teil, wo der Motor zur initialisierung erst mal ins Kältebad fährt
> funktioniert einwandfrei, aber ab da an kommt nur noch Unsinn heraus.

Dann schaff dir als aller erstes erst mal Möglichkeiten, wie du dir 
Variablenwerte ansehen kannst und dir der µC Werte, die er empfangen hat 
ausgeben kann. Alles andere ist stochern im Nebel, vor allen Dingen dann 
wenn du mehrere µC einsetzt.


> An diesem Mega 16 hängen 4 Stück Mega 48. Drei
> davon messen mit einem 1 wire Sensor die Temperatur und einer kümmert
> sich um den Motor.

Man kann also so kompiliziert aufbauen, dass man selber nicht mehr 
durchschaut was da vor sich geht und sich selbst in der selbstgebauten 
Komplexität verliert.

[fff (Gast)]

Karl Heinz Buchegger schrieb:
> Man kann also so kompiliziert aufbauen
lol, nette Wortverschmelzung, muss ich mir merken.