Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Seite 2 von 3 ErsteErste 123 LetzteLetzte
Ergebnis 11 bis 20 von 22

Thema: Avr net io

  1. #11
    Registriert seit
    10.08.2010
    Beiträge
    774
    Danke
    1
    Erhielt 14 Danke für 13 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo hab mal ein paar fragen zu diesem Programm siehe rot markierte stellen

    Code:
    FUNCTION_BLOCK NET_IO
    TITLE = 'NET-IO'
    NAME    : NET_IO
    FAMILY  : ''
    AUTHOR  : dalbi
    VERSION : '1.0'
    
    VAR_INPUT
      CONNECT : BOOL;
      ID : WORD;  
      DEV_ID : BYTE;  
      IP_ADDR1 : INT;  
      IP_ADDR2 : INT;  
      IP_ADDR3 : INT;  
      IP_ADDR4 : INT;  
    END_VAR
    VAR_IN_OUT
      NET_IO : UDT_NET_IO;
    END_VAR  
    VAR_OUTPUT
      CONNECTED : BOOL;
    END_VAR    
    VAR_TEMP
      TempPointer : ANY;
      AnyPointer AT TempPointer : STRUCT
        BYTE0 : BYTE; //10h
        TYP : BYTE;   //Daten/Parametertyp
        ANZ : WORD;   //Länge
        DBNr : WORD;  //DB-Nummer
        BZ : DWORD;   //Bereichszeiger
      END_STRUCT;
      i : INT;
      BCD_Code : DWORD;
    END_VAR
    VAR
      TCON : TCON;
      TSEND : TSEND;
      TRCV : TRCV;
      TDISCON : TDISCON;
      TCON_PAR : TCON_PAR;
      TON_CON : TON;
      TON_SEND : TOF;
      PulsePosConn : BOOL;   
      PulseNegConn : BOOL;   
      EdgeFlagPos : BOOL;
      EdgeFlagNeg : BOOL;
      Count : INT;
      RcvData : ARRAY[0..23] OF CHAR;
      GETPORT : ARRAY [0..10] OF CHAR := 'G','E','T','P','O','R','T',' ','X', '$L', '$R';  
      GETADC : ARRAY [0..9] OF CHAR := 'G','E','T','A','D','C',' ','X', '$L', '$R';  
      SETPORT : ARRAY [0..12] OF CHAR := 'S','E','T','P','O','R','T',' ','X','.','Y', '$L', '$R';  
      GETSTATUS : ARRAY [0..10] OF CHAR := 'G','E','T','S','T','A','T','U','S', '$L', '$R';  
    END_VAR
    
    BEGIN
    
    (*********************************************************)    
    (* Get the positive pulse                                *)
    (*********************************************************)    
    
      PulsePosConn := CONNECT AND NOT EdgeFlagPos;
      EdgeFlagPos := CONNECT;
    
    (*********************************************************)    
    (* Get the negative pulse                                *)
    (*********************************************************)    
    
      PulseNegConn := NOT CONNECT AND EdgeFlagNeg;
      EdgeFlagNeg := CONNECT;
    
    (*********************************************************)    
    (* Set ID of the specified connection                    *)
    (*********************************************************)
    
      TCON_PAR.id := ID;
      TCON_PAR.local_device_id := DEV_ID;
    
    (*********************************************************)    
    (* Set IP address values                                 *)
    (*********************************************************)    
    
      TCON_PAR.rem_staddr[1] := WORD_TO_BYTE(INT_TO_WORD(IP_ADDR1));
      TCON_PAR.rem_staddr[2] := WORD_TO_BYTE(INT_TO_WORD(IP_ADDR2));
      TCON_PAR.rem_staddr[3] := WORD_TO_BYTE(INT_TO_WORD(IP_ADDR3));
      TCON_PAR.rem_staddr[4] := WORD_TO_BYTE(INT_TO_WORD(IP_ADDR4));
    
    (*********************************************************)    
    (* Establish connection                                  *)
    (*********************************************************)    
    
      IF PulsePosConn THEN
        TCON.REQ := TRUE;
      END_IF;  
      
      TCON(REQ     := TCON.REQ,
           ID      := TCON_PAR.id,
           CONNECT := TCON_PAR);
          
      IF TCON.DONE THEN
        CONNECTED := TRUE;
        TCON.REQ := FALSE;
      END_IF;
      
      TON_CON(IN := CONNECTED,
              PT := T#2s); 
       
    (*********************************************************)
    (*********************************************************)
    
      CASE Count OF
        1..8:   SETPORT[8] := INT_TO_CHAR(Count + 48); // was hat es mit den 48 aufsich ?
                SETPORT[10] := INT_TO_CHAR(BOOL_TO_INT(NET_IO.DigiOut[Count]) + 48);
                TempPointer := SETPORT;
        9..12:  GETPORT[8] := INT_TO_CHAR(Count - 8 + 48);
                TempPointer := GETPORT;
        13..16: GETADC[7] := INT_TO_CHAR(Count - 12 + 48);
                TempPointer := GETADC;
        17:     TempPointer := GETSTATUS;
      ELSE
        Count := 1;
        TempPointer := GETSTATUS;
      END_CASE;      
    
    (*********************************************************)
    (* Send data over existing connection                    *)    
    (*********************************************************) 
    
      TSEND.LEN := WORD_TO_INT(AnyPointer.ANZ);
    
      IF TON_CON.Q THEN
        
        TON_SEND(IN := NOT TSEND.REQ,
                 PT := T#50ms);
                  
        TSEND.REQ := TON_SEND.Q; 
        
        TSEND(REQ  := TSEND.REQ,
              ID   := TCON_PAR.id,
              LEN  := TSEND.LEN, 
              DATA := TempPointer);
    
      END_IF; 
    
    (*********************************************************)
    (* Receive data over existing connection                 *)    
    (*********************************************************)    
    
      IF CONNECTED THEN
    
        TRCV(EN_R := TRUE,
             ID   := TCON_PAR.ID,
             LEN  := TRCV.LEN,  // woher weiß mann wieviele BYTE ankommen ? 
             DATA := RcvData); 
         
      END_IF;
      
      BCD_Code := 0;
      
      IF TRCV.NDR THEN 
        CASE Count OF
          1..8:   IF RcvData[0] = 'A' AND RcvData[1] = 'C' AND RcvData[1] = 'K' THEN  //??? musste das nicht 2 heißen ?
                    ;
                  END_IF;  
          9..12:  IF RcvData[0] = '0' THEN
                    NET_IO.DigiIn[Count-8] := FALSE;
                  ELSIF RcvData[0] = '1' THEN
                    NET_IO.DigiIn[Count-8] := TRUE;
                  END_IF;    
          13..16: IF CHAR_TO_INT(RcvData[0]) >= 48 AND CHAR_TO_INT(RcvData[0]) <= 57 THEN
                    BCD_Code := WORD_TO_DWORD(INT_TO_BCD(CHAR_TO_INT(RcvData[0]) - 48)); 
                  END_IF;
                  IF CHAR_TO_INT(RcvData[1]) >= 48 AND CHAR_TO_INT(RcvData[1]) <= 57 THEN
                    BCD_Code := SHL(IN:=BCD_Code, N:=4);
                    BCD_Code := BCD_Code OR WORD_TO_DWORD(INT_TO_BCD(CHAR_TO_INT(RcvData[1]) - 48));
                  END_IF;  
                  IF CHAR_TO_INT(RcvData[2]) >= 48 AND CHAR_TO_INT(RcvData[2]) <= 57 THEN
                    BCD_Code := SHL(IN:=BCD_Code, N:=4);
                    BCD_Code := BCD_Code OR WORD_TO_DWORD(INT_TO_BCD(CHAR_TO_INT(RcvData[2]) - 48));
                  END_IF;  
                  IF CHAR_TO_INT(RcvData[3]) >= 48 AND CHAR_TO_INT(RcvData[3]) <= 57 THEN
                    BCD_Code := SHL(IN:=BCD_Code, N:=4);
                    BCD_Code := BCD_Code OR WORD_TO_DWORD(INT_TO_BCD(CHAR_TO_INT(RcvData[3]) - 48));
                  END_IF;  
                  NET_IO.AnaIn[Count-12] := DINT_TO_INT(DWORD_BCD_TO_DINT(BCD_Code));
          17:     IF RcvData[0] = 'S' THEN
                    FOR i := 1 TO 8 DO
                      NET_IO.StatusOut[i] := INT_TO_BOOL(CHAR_TO_INT(RcvData[9-i]) - 48);
                    END_FOR;  
                  END_IF;
        END_CASE;
        Count := Count + 1;  
        
        FOR i := 0 TO 23 DO
          RcvData[i] := ' ';
        END_FOR;      
      END_IF;
      
    (*********************************************************)    
    (* Existing connection end                               *)
    (*********************************************************)    
    
      IF PulseNegConn AND CONNECTED THEN
        TDISCON.REQ := TRUE;
      END_IF;  
      
      TDISCON(REQ := TDISCON.REQ,
              ID  := TCON_PAR.id); 
          
      IF TDISCON.DONE THEN
        CONNECTED := FALSE;
        TDISCON.REQ := FALSE;
        Count := 1;
      END_IF;
    
    END_FUNCTION_BLOCK
    Geändert von emilio20 (17.02.2013 um 11:46 Uhr)

  2. #12
    Registriert seit
    29.03.2004
    Beiträge
    5.793
    Danke
    144
    Erhielt 1.706 Danke für 1.238 Beiträge

    Standard

    Mach dich mal über die ASCII-Zeichenkodierung schlau, und sieh dir den Wert für das Zeichen '0' an.

  3. #13
    Registriert seit
    10.08.2010
    Beiträge
    774
    Danke
    1
    Erhielt 14 Danke für 13 Beiträge

    Standard

    Ok und die anderen sachen ?

    Wollte sowas für ein Arduino anpassen . Hier muss ich aber erst den CODe am Arduino erstellen.

  4. #14
    Registriert seit
    19.06.2005
    Ort
    in Bayern ganz oben
    Beiträge
    1.360
    Danke
    188
    Erhielt 372 Danke für 290 Beiträge

    Standard

    Erfahrung ist eine nützliche Sache. Leider macht man sie immer erst kurz nachdem man sie brauchte...

    OSCAT.lib Step 7

    Open Source Community for Automation Technolgy

    SPS-Forum Chat (Mibbit) | SPS-Forum Chat (MIRC)

  5. #15
    Registriert seit
    10.08.2010
    Beiträge
    774
    Danke
    1
    Erhielt 14 Danke für 13 Beiträge

    Standard

    Hallo Dalbi
    das kenne ich. Hab eine Komunikation mit einem Arduino erstellt. Wollte jetzt ich E/A und die Analogen eingänge noch abfragen. hierzu wollte ich dein Programm abändern.

    Könntest du mir dei rot markierten stellen erklären. Das mit den 48 hat sich erledigt.

    Wie gibts du die große der empfangenen byts an ?


    LEN := TRCV.LEN, // woher weiß mann wieviele BYTE ankommen ?

    mann muss doch im vorfeld sagen vieviel BYTE's empfangen werden oder ?

    OK habs glaube ich verstanden du schreibs die empfangene datenlänge in LEN.
    Geändert von emilio20 (17.02.2013 um 11:46 Uhr)

  6. #16
    Registriert seit
    19.06.2005
    Ort
    in Bayern ganz oben
    Beiträge
    1.360
    Danke
    188
    Erhielt 372 Danke für 290 Beiträge

    Standard

    Nein. NDR ist TRUE es liegen neue Daten vor.
    Die Anzahl der empfangenen Bytes erkennt man dann über LEN.

    Voraussetzung der Empfangspuffer ist groß genug.

    Hab ja auch einen Arduino hier. Vielleicht probiere ich das auch mal aus.

    Gruss Daniel
    Erfahrung ist eine nützliche Sache. Leider macht man sie immer erst kurz nachdem man sie brauchte...

    OSCAT.lib Step 7

    Open Source Community for Automation Technolgy

    SPS-Forum Chat (Mibbit) | SPS-Forum Chat (MIRC)

  7. #17
    Registriert seit
    10.08.2010
    Beiträge
    774
    Danke
    1
    Erhielt 14 Danke für 13 Beiträge

    Standard

    Wäre super.
    Ich beschreibe dir mal mein Aktuelle Programm.
    Ich Sende einen Array of CHAR mit 32Byte ans Arduino. Dort zerlegen ich den CHAR in 2x 16 CHAR und schreibe den TEXT auf einen 2x16 Zeichen Display.
    Das Arduino Sendet die empfangenden Daten wieder an die SPS, 32 CHAR. In der SPS vergleiche ich die empfangenen Daten mit den gesendeten Daten. Wenn dies ungleich sind wird gesendet wenn gleich wird nicht gesendet.

    Ich hatte das Problem das ich immer 32Byte Senden musste(Text musste mit leerzeichen gefüllt werden.) annstonsten haben meine empfangenden Daten nicht mit meinen gesendeten übereingestimmt.

    Kann aber auch an dem Arduino Programm liegen.

    Code:
    Arduino Programm
    
    #include <SPI.h>
    #include <Ethernet.h>
    #include <Wire.h> 
    #include <LiquidCrystal_I2C.h>
    
        LiquidCrystal_I2C lcd(0x3F,16,2);
    
    
    byte mac[] = { 
      0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
    IPAddress ip(192,168,178, 50);
    IPAddress gateway(192,168,178, 1);
    IPAddress subnet(255, 255, 255, 0);
    
    
    
    EthernetServer server(2500);
    boolean alreadyConnected = false; 
    
      char thisChar[33];
      char thisChar1[16];
      char thisChar2[16];
      
      
      int i;
    
    void setup() {
      
      lcd.init();
       
        
      lcd.backlight();
      lcd.setCursor(0,0);
      lcd.print("Starten");
      lcd.setCursor(0,1);
      lcd.print("System");
      delay( 3000);
      lcd.clear();
      
      
      // initialize the ethernet device
      Ethernet.begin(mac, ip, gateway, subnet);
      // start listening for clients
      server.begin();
     // Open serial communications and wait for port to open:
      Serial.begin(9600);
       while (!Serial) {
        ; // wait for serial port to connect. Needed for Leonardo only
      }
    
    
      Serial.print("Chat server address:");
      Serial.println(Ethernet.localIP());
    }
    
    void loop() {
      // wait for a new client:
      EthernetClient client = server.available();
    
      
      if (client) {
        if (!alreadyConnected) {
          // clead out the input buffer:
          client.flush();    
          Serial.println("We have a new client");
          //client.println(Verbindung);
          //server.write(Verbindung); 
          alreadyConnected = true;
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("  Verbunden  ");
          delay( 5000);
          lcd.clear();
                
          
        } 
        
        if (client.available() > 0) {
           for (i = 0; i < 32; i++) {
           // read the bytes incoming from the client:
           thisChar[i] = client.read();
          }
         // Backlight aus  
           if (strcmp (thisChar, "noBacklight                     ") == 0){
              lcd.noBacklight();
              Serial.println("noBacklight");
              delay(500);}
              else{
              lcd.backlight();
          }
          
          // echo the bytes back to the client:
          server.write(thisChar);
          // echo the bytes to the server as well:
          Serial.write(thisChar);
          
          for (i =0;i <17;  i++){
            thisChar1[i]=thisChar[i];
                
          }
               
          
          for (i =17;i <33;  i++){
            thisChar2[i-16]=thisChar[i];
          
          }
          lcd.setCursor(0,0);
          lcd.print(thisChar1);
          lcd.setCursor(0,1);
          lcd.print(thisChar2);
          
          delay( 1);
        }
      }
        
      
    }
    Geändert von emilio20 (17.02.2013 um 14:27 Uhr)

  8. #18
    Registriert seit
    10.08.2010
    Beiträge
    774
    Danke
    1
    Erhielt 14 Danke für 13 Beiträge

    Standard

    Hallo
    dalbi

    habe mir mal das ganze angeschaut ich bin nicht fit genug in C++ um den Code vom AVR net io am Arduino nachzubilden. Hast du erfahrung und lust dir das mal anzuschauen ? Wäre super wenn das gehen würde.

  9. #19
    Registriert seit
    08.02.2013
    Beiträge
    1
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Hallo,

    ich bin im Besitz einer S7 315-2 DP und CP343-1. Ist es auch mit diesen Baugruppen möglich
    mit dem AVR NET-IO zu kommunizieren?
    Die FB63 bis FB65 werden ja in dieser CPU nicht unterstützt.

  10. #20
    Registriert seit
    19.06.2005
    Ort
    in Bayern ganz oben
    Beiträge
    1.360
    Danke
    188
    Erhielt 372 Danke für 290 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hi emilio20,

    Code:
    #include <SPI.h>
    #include <Ethernet.h>
    #include <Wire.h> 
    #include <LiquidCrystal_I2C.h>
    
    
    LiquidCrystal_I2C lcd(0x38,20,4);
    
    
    byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; // MAC-Adresse
    byte ip[] = {192, 168, 0, 98}; // IP-Adresse
    EthernetServer server(1000);   // Port
     
    String readBuffer;
    
    
     
    void setup()
    {
      Serial.begin(9600);
    
    
      lcd.init();
      lcd.backlight();
      lcd.setCursor(0,0);
      lcd.print("dalbi");
      lcd.setCursor(0,1);
      lcd.print("SPS <-> Arduino");
      
      Ethernet.begin(mac, ip);
      server.begin();
      delay(1000);
    }
     
    void loop() {
      EthernetClient client = server.available();
      if (client) {
        while (client.connected()) {
          if (client.available()) {
            char c = client.read();
            readBuffer = readBuffer + c;
            if (c == '\n') {    // warten auf new line
              // clearlcd <= Löscht alle Zeichen          
              if(readBuffer.startsWith("clearlcd")) {
                lcd.clear();
                client.println("ACK");
              }
              // writelcd 1.Testtext <= Schreibt Testtext in Zeile 1
              // writelcd 2.Testtext <= Schreibt Testtext in Zeile 2
              if(readBuffer.startsWith("writelcd")) {
                lcd.setCursor(0, readBuffer[9]-49);  // Zeile 1-x
                lcd.print(readBuffer.substring(11, readBuffer.length()-2));
                client.println("ACK");
              }
              // backllcd 1 <= Schaltet die Hintergrundbeleuchtung ein
              // backllcd 0 <= Schaltet die Hintergrungbeleuchtung aus
              if(readBuffer.startsWith("backllcd")) {
                if ((readBuffer[9]-48) == 1) {
                  lcd.setBacklight(0);
                } else {
                  lcd.backlight();
                }
                client.println("ACK");
              }          
              readBuffer = "";
            }
          }
        }
      }
      client.stop();
    }
    Die Ethernetparameter und das LCD musst halt entsprechend anpassen.

    Folgendes geht jetzt:

    clearlcd <- Löscht alle Zeichen
    writelcd 1.Testtext <- Schreibt Testtext in die erste Zeile
    backllcd 1 <- Schaltet die Hintergrundbeleuchtung ein
    backllcd 0 <- Schaltet die Hintergrundbeleuchtung aus

    Beim Senden von der SPS ist darauf zu achten das die letzten Zeichen \r\n sind.
    Als quittierung vom Arduino zur SPS wird ACK gesendet.

    Gruss Daniel
    Geändert von dalbi (25.02.2013 um 19:44 Uhr)
    Erfahrung ist eine nützliche Sache. Leider macht man sie immer erst kurz nachdem man sie brauchte...

    OSCAT.lib Step 7

    Open Source Community for Automation Technolgy

    SPS-Forum Chat (Mibbit) | SPS-Forum Chat (MIRC)

Lesezeichen

Berechtigungen

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