Seam Tracking with TPSI and analog current clamp.

Hi guys,

i have a robot cell that uses a fronius TPS/I 500 in combination with a current clamp to do seam tracking (TAST).

this welder has the ability to output a digital seam tracking signal but it's not used as the robot controller does not support it.

we are having mixed results with seam tracking... and just feel its more finicky than it should be.

we are pulse welding 12-16mm mild steel.

i believe back in the fronius TPS days you had to use a specific synergic line (weld program) when using seam tracking.

(please see attached PDF screenshots)

I'm assuming it controlled the arc a little differently to allow for the current clamp to get a better signal.

does a new version of (P0555) exist for the new TPSI machines or are we just expected to use the digital signal?

cheers,

-william foster

i will try making a device to intercept the mod bus seam tracking signal and pass an analog signal to the robot controller...

Seam tracking working with converting the digital mod bus signal to analog...

i think it's working better.

lots of variables.

image shows taught vs welded path.

the welder is already sending a seam track signal to robot via modbus over ethernet.

the robot just is not setup up to do anything with it... as DX200 is not digital comarc compatible.

i put a computer between the robot and the welder.

it's running a program to "intercept" the modbus packets and read their value.

it then outputs via serial to the Arduino that outputs the value in analog to the robot.

after that it's just the same as regular comarc.

I'm not entirely sure of it's performance yet... i need to conduct more test welds.

i have a feeling its better.

Quote from hermann

There exist modbus TCP client software for Arduino f. e. https://github.com/goddland16/Modbus-TCP

I tried that first,

I don’t think you can make it work just by listening in on the traffic.

only worked when I sent it direct commands.

I think it’s to do with how Ethernet library works.

having good results with custom solution.

no com arc box required.

Thanks hermann Arduino modbus library did end up being the way to to go.

i just didn't know what i was doing the first time i tried it.

I have got it all in a single unit i can mount in the cabinet now.

Summary

I don't believe analog COMARC or analog TAST in general works with pulse welding... or more specifically TPS/i welders as they don't have the special welding jobs needed for external current measuring.

this unit overcomes the limitation by converting the digital seam track signal that TPS/i welders already have... to analog your older COMARC compatible robot can read.

Solution

if anyone want to recreate this.

it's using "Arduino UNO R4 MINIMA". ( i choose this for its 12bit analog output )

and the Arduino Ethernet shield.

I'm using a low pass filter but i don't think it's necessary.

connect GND to the cabinet and A0 to analog input your robot uses for COMARC.

connect the Ethernet to the robot network. you might have to add a switch.

for parameters i changed S1E21 to 110. ( i cant remember how i came up with this number. )

this is used for analog voltage to current.

now you can just do the phase compensation as normal.

with digital COMARC the "current" value doesn't really mean anything.

so you really cant just guess the U/D value. you should just put it in measure mode and get U/D that way.

/*
William Foster


unfortunately the modbus library wont compile on the R4. 
this is ai slop GPT write for me that does a bare bone equivalent.

*/
 
#include <SPI.h>
#include <Ethernet.h>

// Ethernet settings
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 255, 214);
IPAddress serverIp(192, 168, 255, 210); // Modbus server IP
EthernetClient client;

// Modbus TCP settings
const int MODBUS_PORT = 502;

void setup() {
  // Start Ethernet
  Ethernet.begin(mac, ip);
  Serial.begin(9600);
  Serial.println("Modbus TCP Client is starting...");
  analogWriteResolution(12);
  analogWrite(A0, 0);

  // Connect to Modbus server
  if (client.connect(serverIp, MODBUS_PORT)) {
    Serial.println("Connected to Modbus server");
  } else {
    Serial.println("Connection to Modbus server failed");
  }
}

void loop() {
  if (client.connected()) {
    // Build Modbus request (Read Holding Registers, Function Code 3)
    uint8_t request[] = {
      0x00, 0x01, // Transaction ID
      0x00, 0x00, // Protocol ID
      0x00, 0x06, // Length
      0x01,       // Unit ID
      0x03,       // Function Code (Read Holding Registers)
      0xF1, 0x11, // MSB = 0x01, LSB = 0x11
      0x00, 0x01  // Quantity of Registers (1)
    };

    // Send request
    client.write(request, sizeof(request));


    // Wait for response
    delay(4);

    // Read response
    uint8_t response[256];
    int len = client.read(response, sizeof(response));

    if (len > 0) {


      // Parse the response (example: extract the first register value)
      if (len >= 9 && response[7] == 0x03) { // Check function code
        uint16_t registerValue = (response[9] << 8) | response[10];
        Serial.print("Register Value: ");
        Serial.println(registerValue);
        analogWrite(A0,map(registerValue, 0, 65535, 0, 4095)*8);
      } else {

      }
    } else {

    }

    // Wait before sending the next request
    delay(1);
  } else {
    Serial.println("Disconnected from server, retrying...");
    client.stop();
    delay(100);
    client.connect(serverIp, MODBUS_PORT);
  }
}