Posts by fosterwilliam999

what made you move away from octopuz ?

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);
  }
}

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.

set start and end current time to 0, it may be dwelling because of that.

what power supply is it ?

with fronius you can set the start and end current.

share a picture.

having good results with custom solution.

no com arc box required.

would this be sorting and stacking laser cut profiles ?

I'm interested in doing something similar.

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.

did you want to do this in play or teach mode ?

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.

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.

hey mate,

it's just magnets and a switch.. there is not much to adjust.

i had big trouble with my TPS/i having shock sensor issues.

on the TPS/i & DX200 the signal is as follows.

crash box switch>TPS/I>Ethernet back to robot controller>REGISTER>Ladder logic>physical relay>back to robot controller.

... the relay had partially failed and i would get intermittent crash box activation.

replaced one of these and now it's all good.

mod bus will probably be the easiest to implement.

try this code, just swap in your register and IP address.

i have tested this with Arduino running modbus... should work for robot too.

pip install pymodbus

from pymodbus.client import ModbusTcpClient

# Define the Modbus server details
SERVER_IP = "192.168.111.220"  # Replace with your Arduino's IP
SERVER_PORT = 502           # Default Modbus TCP port
REGISTER_ADDRESS = 1        # The address of the register to modify
NEW_VALUE = 150             # The new value to write to the register

def write_modbus_register(server_ip, port, register_address, value):
    # Create a Modbus TCP client
    client = ModbusTcpClient(host=server_ip, port=port)
    if not client.connect():
        print("Unable to connect to the Modbus server.")
        return False
    
    # Write to the register
    result = client.write_register(register_address, value)
    if result.isError():
        print(f"Failed to write to register {register_address}.")
    else:
        print(f"Successfully wrote value {value} to register {register_address}.")
    
    # Close the client connection
    client.close()
    return not result.isError()

# Call the function to update the Modbus register
if __name__ == "__main__":
    success = write_modbus_register(SERVER_IP, SERVER_PORT, REGISTER_ADDRESS, NEW_VALUE)
    if success:
        print("Operation completed successfully.")
    else:
        print("Operation failed.")

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

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