@DJ Sures This really helps fill in the blanks and will give me what I need to proceed.

Thanks so much.

No problem I separated some of the functionality into separate methods for you to get an idea of what is going on...

Firstly, I use the System.Net.Sockets.TcpClient instead of the EZ_B one. This is because the EZ_B one is made specifically for Shell prompts. The System.Net.Sockets.TcpClient is much more versatile for your needs.

    TcpClient _tcpClient = null;

In the connection method, I added code to allow you to specify the connection timeout. Without this code, simply using TcpClient.Connect() will timeout for 10 seconds or something ridiculous. My example allows you to specify the Timeout in the TimeSpan.FromSeconds()

Also, the TCP NoDelay will increase the transfer speed. Without NoDelay, the tcp packets will have a minimum response speed of something like 20ms - which is way too slow

      _tcpClient = new TcpClient();

      IAsyncResult ar = _tcpClient.BeginConnect(tbAddress.Text, port, null, null);

      System.Threading.WaitHandle wh = ar.AsyncWaitHandle;

      try {

        if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(3), false)) {

          _tcpClient.Close();

          throw new TimeoutException();
        }

        _tcpClient.EndConnect(ar);
      } finally {

        wh.Close();
      }

      _tcpClient.NoDelay = true;
      _tcpClient.ReceiveTimeout = 2000;
      _tcpClient.SendTimeout = 2000;

Send Command will send the command and send the response to the Debug Log window.

    /// <summary>
    /// Send command string to the ARC connection.
    /// The input buffer will be cleared, then it will send the command, finally it reads the response.
    /// There is always a response from the ARC Script Interface:
    ///  - If you are expecting to receive data, the response will be the received data.
    ///  - If you are not expecting to receive data, the response will be "OK"
    /// </summary>
    private void sendCommand(string cmd) {

      try {

        Log("Sending: {0}", cmd);

        clearInputBuffer();

        _tcpClient.Client.Send(System.Text.Encoding.ASCII.GetBytes(cmd + Environment.NewLine));

        Log(readResponseLine());
      } catch (Exception ex) {

        Log("Command Error: {0}", ex);

        disconnect();
      }
    }

The SendCommand() uses ClearInputBuffer() and ReadReponseLine(). The details are specified in their respective summary comments.

    /// <summary>
    /// Clears any data in the tcp incoming buffer by reading the buffer into an empty byte array.
    /// </summary>
    private void clearInputBuffer() {

      if (_tcpClient.Available > 0)
        _tcpClient.GetStream().Read(new byte[_tcpClient.Available], 0, _tcpClient.Available);
    }

    /// <summary>
    /// Blocks and waits for a string of data to be sent. The string is terminated with a \r\n
    /// </summary>
    private string readResponseLine() {

      string str = string.Empty;

      do {

        byte [] tmpBuffer = new byte[1024];

        _tcpClient.GetStream().Read(tmpBuffer, 0, tmpBuffer.Length);

        str += System.Text.Encoding.ASCII.GetString(tmpBuffer);
      } while (!str.Contains(Environment.NewLine));

      // Return only the first line if multiple lines were received

      return str.Substring(0, str.IndexOf(Environment.NewLine));
    }

Finally, to send a command - simply send the EZ-Script syntax and voila

    private void btnSetX_Click(object sender, EventArgs e) {

      sendCommand(string.Format("$x = {0}", tbX.Text));
    }

Let me just say that the quality and detail of your response blew away my expectations. If this is the passion you put into everything the revolution has a very rosy feature.

Based on this interaction I firmly believe I made the right choice in going with EZ-Robot in my feature robotic projects.

The fact that the EZB method is made specifically for Shell prompts at least explains why my send code did not work but my socket read did.

Thanks again.

By the way.

The reason for all of this is that I am going to try and write an application that sits between the roborealm AVM navigation module and ARC. I will pull values from the module, provide them to ARC and use EZ-Script to make the robot do the movements. That way I might be able to have the robot learn a path via the webcam and then navigate it again autonomously.

Should be a nice learning experience. Now I only need the EZ-B

@JD Sures

Just so you know your time spent on providing the information was not wasted I have successfully integrated and adjusted your code examples to pull the information I needed from Roborealm into ARC for use in EZ-Script.

Thanks again for your help

Really? That's excellent! I'm looking forward to seeing it Any chance you could share a video of your project when you're ready?

@DJ Sures At this point I can read the variable values from roborealm via their XML based API and I can get the variables into ARC for use in EZ-Script.

The next step requires me to having the EZB since I need to find a way to get the video from the robot's camera streamed into roborealm so the AVM module can do its job on the video stream and report back the movement variables.

Assuming I can get the whole thing working I have no issue posting what I did but don't want to get anyone's hopes up until I actually have the robot navigate using roborealm AVM navigate mode.

If you take a look at roborealm AVM you will see what it is I am trying to do especially the navigate mode.

Plus it's a nice way to learn c# even if the whole idea falls flat on its face in the end

Another project I was thinking of using your code examples for is having six doing a dance and having it send variables to another arduino based robot I have using xbee's and coordinating their dancing.