Thread: C# Application using OBDPro scantool

If an admin thinks this is better suited in the Software Development, please move it there. I didn't see an dedicated OBD section over there and I wanted to make sure the people using OBDPro see this.

OrangeSword,

In your control loop thread you should wait for the ">" prompt before sending another command. The OBDPro can buffer serial data while executing a previous OBD Command but ocasionally it will not be able to keep up with buffering serial data and processing the OBD command at the same time.

One way to do this is create a boolean promptSeen. Set this to true when you read a ">" on the serial port handler, and only send a new OBD command when promptSeen == TRUE

hth

Paul
www.obdpros.com

I am not getting a "Buffer Full" message back so I don't think the buffer is full.

But anyway following your advice, I've changed the code to this:

Code:

private void BeginControlLoopThread()
    {
      bool promptFound; ;
      bool responseEndFound;
      string response;

      while (true)
      {
        
        foreach (OBDCommand obdCommand in mOBDCommandRepository.OBDCommands)
        {
          response = "";
          promptFound = false;

          while (!promptFound)
          {
            try
            {
              mSerialPort.ReadTo(">");
              mSerialPort.WriteLine(obdCommand.Mode + " " + obdCommand.PID);
              mMainWindow.WriteToInputLogDisplay(obdCommand.Mode + " " + obdCommand.PID);
              promptFound = true;
            }
            catch (Exception e)
            {
              // Prompt was not found, do nothing
            }
            
          }

          responseEndFound = false;

          while (!responseEndFound)
          {
            try
            {
              response = mSerialPort.ReadTo("\r");
              response = response.Trim();
              mMainWindow.WriteToOutputLogDisplay(response);

              if (response.StartsWith("4"))
              {
                string[] translatedResponse = mOBDCommandRepository.TranslateResponse(response);
                SendToUI(translatedResponse);
              }
              responseEndFound = true;

            }
            catch (Exception e)
            {
              // Command not finished was not found, do nothing
            }


          }
        }
        Thread.Sleep(1000);
      }

Potentially I will have a large number of responses to loop through and it might take awhile to finish the loop if I have to wait for every response. Is there a way to get multiple responses back at one time? Like ALL of the data in Mode 01? Am I doing it the most efficient way, is what I am trying to get at.

Sorry I should have made it a bit more clear....

It's not the OBD buffer that is full, but when getting data from the vehicle bus there are times when the interface needs to shut off processing the serial port interrupts, this means some characters would be dropped...

The ">" char signals the PC that the OBDPro is done executing the command and is now ready to accept additional commands. To make sure you can issue the command immediately when the interface is ready one way would be to send the data right out of the serial data recieved handler. Let me find the code that I use to test the interface and I can send you something as an example...

Paul
www.obdpros.com

Thanks. I appreciate it. One other question, is the "NO DATA" and "?" results terminated by a carriage return?

hi have you finished this yet

Originally Posted by aslaughter

hi have you finished this yet

No not yet. I'm not really building it for distribution, but here is the code I have so far if you are interested in that:

Code:

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.IO.Ports;
using System.Configuration;

namespace OrangeSword.FrontierDash.ObdReader.BusinessLogic
{
  /// <summary>
  /// Represents a OBD device such as a OBDPro.
  /// </summary>
  public class ObdDevice
  {
    private string portName;
    private int baudRate;
    private SerialPort serialPort;

    /// <summary>
    /// Initializes a new instance of the <see cref="ObdDevice"/> class.
    /// </summary>
    public ObdDevice()
    {
      portName = ConfigurationManager.AppSettings["portName"];
      baudRate = Convert.ToInt32(ConfigurationManager.AppSettings["baudRate"]);
      Connect();
    }

    /// <summary>
    /// Connects this instance.
    /// </summary>
    private void Connect()
    {
      serialPort = new SerialPort(portName, baudRate);
      serialPort.Open();
      serialPort.ReadTimeout = 1000;
      serialPort.NewLine = "\r";
    }

    /// <summary>
    /// Disconnects this instance.
    /// </summary>
    private void Disconnect()
    {
      serialPort.Close();
    }

    /// <summary>
    /// Initializes this instance.
    /// </summary>
    public void Initialize()
    {
      Reset();
      SendAtCommand("ate0");
      SendAtCommand("atl0");
    }

    /// <summary>
    /// Sends the obd command.
    /// </summary>
    /// <param name="obdCommand">The obd command.</param>
    /// <returns>The response to the OBD command from the OBD device.</returns>
    public string SendObdCommand(ObdCommand obdCommand)
    {
      string response = "";
      bool promptFound = false;
      bool responseEndFound = false;

      while (!promptFound)
      {
        try
        {
          serialPort.ReadTo(">");
          serialPort.WriteLine(obdCommand.Mode + " " + obdCommand.PID);
          promptFound = true;
        }
        catch (Exception e)
        {
          // Prompt was not found
          Console.WriteLine("Prompt not found: " + e.Message);
        }
      }

      while (!responseEndFound)
      {
        try
        {
          response = serialPort.ReadTo("\r");
          response = response.Trim();

          if (response.StartsWith("4"))
          {
            responseEndFound = true;
          }
        }
        catch (Exception e)
        {
          // Carriage Return not found
          Console.WriteLine("Carriage Return not found: " + e.Message);
          if (response == "NO DATA")
          {
            responseEndFound = true;
          }          
        }
      }
      return response;

    }

    /// <summary>
    /// Sends the AT command.
    /// </summary>
    /// <param name="atCommand">The AT command.</param>
    /// <returns></returns>
    public string SendAtCommand(string atCommand)
    {
      string response = "";
      bool promptFound = false;
      bool responseEndFound = false;

      while (!promptFound)
      {
        try
        {
          serialPort.ReadTo(">");
          serialPort.WriteLine(atCommand);
          promptFound = true;
        }
        catch (Exception e)
        {
          // Prompt was not found
          Console.WriteLine("Prompt not Found: " + e.Message);
        }

      }

      while (!responseEndFound)
      {
        try
        {
          response = serialPort.ReadTo("\r");
          response = response.Trim();
          responseEndFound = true;
        }
        catch (Exception e)
        {
          // Carriage Return not found
          Console.WriteLine("Carriage Return not found: " + e.Message);
        }

      }
      return response;
    }

    /// <summary>
    /// Resets this instance.
    /// </summary>
    public void Reset()
    {
      serialPort.WriteLine("atz");
    }
  }
}

Hey guys, new here but been lurking a few weeks. I am about to start a project as well in C#.net, and Orange I think that code is a great start, I had no idea that there's a ports namespace (just looked it up and it looks like it's new to framework 2.0+). upon just a quick msdn read, it looks like the SerialPort class has event handler delegates, so that would seem to be your best bet, rather than waiting for a certain response, you could just use the SerialDataReceivedEventHanlder delegate to invoke a callback function. I'm going to start messing around with this tonight so if I make any progress I'll be sure and post it up here.