-         

Ergebnis 1 bis 3 von 3

Thema: 2 Prozessoren koppeln?

  1. #1
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    09.11.2005
    Ort
    Ichtershausen
    Alter
    48
    Beiträge
    148

    2 Prozessoren koppeln?

    Anzeige

    Hallo Leute.

    ich habe derzeit ein projekt in der Planung bei dem ich 2 Module miteinander verbinden möchte. eine Handsteuerbox mit Controller (Display3000) und eine Basisstation in der eine weiterer Controller sitzt, der Motoransteuerung, USB,Netzwerk usw. bearbeitet.
    Meine Frage ist nun, mit welchem Verfahren man am elegantesten mit wenigen Leitungen beide Controller so verbindet, dass sie miteinander kommunizieren können. Sie sollen untereinander Daten und Steuerbefehle austauschen, wobei beide gleichberechtigt sein können, also kein Master-Slave. Ich habe mir schon mal Gedanken gemacht, ob man es über I2C macht. Da gehen ja mehrere Master am Bus und es wird ja auch bei einigen RN-Boards zwischen Haupt- und Coprozessor verwendet.
    Dann wäre ja noch RS232. Da muss ich vielleicht noch dazu sagen, daß das Verbindungskabel zwischen beiden Modulen etwa 2m lang ist. Bei RS232 wollt eich allerdings keinen MAX232 zur Pegelanpassung verwenden, sondern direkt die Controllerausgänge miteinander verbinden. Die Frage ist nun, ob man über die Entfernung dann keine Probleme bekommt.
    Kurz gefragt, wie würdet ihr das Ganze lösen und warum?

  2. #2
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    17.08.2005
    Alter
    33
    Beiträge
    685
    Zu den 2m kann ich leider nichts sagen (ob danach nochwas brauchbares ankommt, selber arbeite ich mit 0,5m).

    Bei meinen Bot habe ich das mit den Usarts gelöst - funktioniert tadellos.
    Wenn du eh nur 2 Controller verwenden willst, biedet dies sich ja gerade an.

    Falls weitere µC dazu kommen, muss einer der Master sein (hängen ja alle auf der selben Leitung und haben nur je 1x txd und rxd) und die Daten wieder senden.

    Hier mal eine Möglichkeit mit einem Atmega 162 (2xUsart) und einem Atmega 32:

    Atmega 162 -> USART0 -> Empfang von PC-Signalen
    Code:
    ISR(USART0_RXC_vect)
    {
    	 char rec_buffer0;
         rec_buffer0 = UDR0;           // speichere UDR0-Wert in temp
    	 data0[a]=rec_buffer0;      
    	 if (rec_buffer0=='#')
    	 {
    	     switch (data0[0])
    	     {
    	         case 'B':  string_senden1(data0);  // String gleich Slave_Controller übermitteln
    			             break; 
    					 
    	         case 'A':  switch (data0[1])       
    		                 {	 
    						     case 'L':  switch (data0[2])    //------------Lüfter---------- 
    						                 {
    						                     case '1':  PORTB |= (1<<0); 
    									                     break;
    						                     case '0':  PORTB &=~(1<<0); 
    									                     break;
    									     }
    									     break;
    									 
    							 case 'Q':  data0[a]='\0';             //------------Servo_1---------
    						                 serv1=atoi(&data0[2]);
    										 s1=1;
    									     break;
    										 
    							 case 'W':  data0[a]='\0';             //------------Servo_2----------
    							             serv2=atoi(&data0[2]);
    										 s2=1;
    									     break;
    									 
    					     }
                             break;
    	     }
    		 strcpy(data0,"");
    		 a=-1;               
         }
    	 a++;
    }
    Atmega 162 -> USART1 -> Verbindung mit anderen µC (egal ob Slave oder nicht)
    Code:
    ISR(USART1_RXC_vect)
    {  
    	 char rec_buffer1;
         rec_buffer1 = UDR1;           // speichere UDR1-Wert in temp
    	 data1[b]=rec_buffer1;            
    	 if (rec_buffer1=='#') 
    	 {
    	     //-----------------------------------------------------
             if (data1[0]=='€')
    	     {
    	         strcpy(fehler,&data1[1]);
    	         strcpy(data1,fehler);
    		     b=b-1;
    	     }
    	     //-----------------------------------------------------
    	     switch (data1[0])
    	     {
    	         case 'B':  switch (data1[1])
    		                 {
    					         case 'V':  string_senden0(data1);            // Spannungswert
    							             data1[b]='\0';
    							     		 strcpy(spannung,&data1[2]);
    										 rxd_V=1;
    							    		 break;
    									 
    						     case 'S':  string_senden0(data1);            // Warnung
    							    		 break;
    									 
    						     case 'T':  string_senden0(data1);            // Temperaturwert
    							             switch (data1[2])                
    						                 {
    									         case '1':  data1[b]='\0';
    									    				 strcpy(temp1,&data1[3]);
    														 rxd_T1=1;
    											    		 break;
    										     case '2':  data1[b]='\0';
    												    	 strcpy(temp2,&data1[3]);
    														 rxd_T2=1;
    												    	 break;
    						                 }
    									     break;
    									 
    						     case 'X':  slave1=0;
    						                 break;
    					     }
    					     break;
    		 }
    		 strcpy(data1,"");
    		 b=-1;                   // Zeichen '\0' weg
         }
    	 b++;
    }
    Atmega 32:
    Code:
    ISR(USART_RXC_vect)
    {
         char temp;
         temp = UDR;           // speichere UDR-Wert in temp
    	 data[a]=temp;       
    	 if (temp=='#')
    	 {
    	     //----------receive_str_edit------------------
    		 data[a]='\0';        // '#' weg
    	     if (data[0]=='B')
    	     {
    		     switch (data[1])
    		     {
    			     case 'G':  go=1;
    						     break;
    						 
    			     case 'L':  switch (data[2])
    			                 {
    							     case '0':  PORTC &=~(1<<5);
    							                 break;
    						         case '1':  PORTC |= (1<<5);
    							                 break;
    			                 }
    						     break;
    						 
    			     case 'M':  manual=0;
    			                 switch (data[2])
    						     {
    							     case '1':  PORTB |= (1<<0)|(1<<4);      //-----vorwaerts------
    			                                 PORTB &=~((1<<1)|(1<<2));
    											 break;
    							     case '2':  PORTB |= (1<<1)|(1<<2);     //-----rueckwaerts------
    			                                 PORTB &=~((1<<0)|(1<<4));
    											 break;
    							     case '3':  PORTB |= (1<<2)|(1<<4);     //-----links------
    			                                 PORTB &=~((1<<0)|(1<<1));
    											 break;
    							     case '4':  PORTB |= (1<<0)|(1<<1);     //-----rechts------
    			                                 PORTB &=~((1<<2)|(1<<4));
    											 break;
    							     case '5':  PORTB |= (1<<0)|(1<<1)|(1<<2)|(1<<4);     //-----stopp------
    											 break;
    						     }
    						     OCR1A=255;
    			                 OCR1B=255;
    						     stop_manual=0;
    						     manual=1;
    						     break;
    						 
    			     case 'P':  PWM=atoi(&data[3]);
    			                 switch (data[2])
    						     {
    							     case 'A':  OCR1A=PWM;
    			                                 OCR1B=PWM;
    								    		 break;
    							     case 'R':  OCR1A=PWM;
    									     	 break;
    							     case 'L':  OCR1B=PWM;
    									    	 break;
    						     }
    						     break;
    				 
    				 case 'Z':  switch (data[2])
    						     {
    							     case 'Q':  OCR1B=0;
    								    		 break;
    							     case 'E':  OCR1A=0;
    									     	 break;
    						     }
    						     break;
    			 }
             }
    		 strcpy(data,"");
    		 //----------receive_str_edit------------------
    		 a=-1;                   
         }
    	 a++;
    }

    Funktionsbeispiel:

    1. Zeichen== Ziel µC
    2. und folgende Zeichen== beliebige Unterteilung
    letztes Zeichen == '#'

    Beispiel:
    PC ->
    • "AL1#" (Licht an -> Befehl für µC A)
      "BM1#" (Motoren_vorwaerts -> Befehl an µC B)

    Alle µC sind quasi gleichwertig.
    Bei mehreren µC fragt der Atmega 162 alle nacheinander ab und wird zum Master, bei nur 2 µC ist dies irrelevant.
    Es kann also auch ein Slave (B) zu einem Slave (C) Daten problemlos über den Master (A) versenden.


    Zur Hardware:
    Meine µC sind alle seperat per ISP zu erreichen und auch seperat über RS232 zu flashen (per Schalter -jeder µC hat einen - lege ich die RXD und TXD Leitung entweder zum MAX323 oder über Kreuz zum anderen µC).

    Verwende ich ohne Probleme bei meinem Bot:
    http://www.roboternetz.de/phpBB2/zei...=33059&start=0

    Gruß Stefan

  3. #3
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    09.11.2005
    Ort
    Ichtershausen
    Alter
    48
    Beiträge
    148
    Danke für die Anregungen. Ist natürlich eine einfache und saubere Sache und da es eh nur 2 Controller sind, kann ich mich damit anfreunden. Die Baudraten auf RS232 sollten iegentlch auch ausreichend schnell sein.
    Das Problem mit der Länge dürfte auch nicht weiter bestehen, da auf dem einen Controllerboard ein MAX232 drauf ist.

Berechtigungen

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