GridTrak Open Source PMU (GTosPMU) to Data in 5 Easy Steps

This document is derived from the openPDC project's document:  Device to Data in 5 Easy Steps
The procedure is the same. There are only a few minor code changes.

  1. Create a project
  2. Add references
  3. Copy in the code snippet
  4. Set up your data source
  5. Run the application

Step 1: Create a project

The first thing you need to do is create a console application in Microsoft Visual Studio 2008. The following are detailed steps to guide you through the process.

  1. Launch Microsoft Visual Studio
  2. In the toolbar, go to "File > New > Project..."
  3. Under "Project Types", click on "Windows".
  4. Under "Templates", click on "Console Application".
  5. In the text box labeled "Name", enter the name of your application (i.e. "DeviceToData").
  6. Click the button labeled "Browse..." and select a directory to store the project.
  7. Click the "OK" button
  8. Right Click on your new project and select "Properties"
  9. In the Application settings, change the Target Framework to ".NET Framework 4"

Step 2: Add references

In order to get the code to run, you will need to add references to the openPDC assemblies. The following are detailed steps to guide you through the process.
Note: In order to complete this step, you will need to build openPDC.

  1. In your project's Solution Explorer on the right, right-click "References", select "Add Reference...", then click the Browse button
  2. Navigate to "SOURCEDIR\Main\Build\Output\Debug\Libraries" (SOURCEDIR is the directory where you extracted and built the openPDC source code files).
  3. Select "TVA.Communication.dll", "TVA.Core.dll", "TVA.PhasorProtocols.dll", and "TimeSeriesFramework.dll" then click the "OK" button

Step 3: Copy in the code snippet

Now you are ready to copy the source code that will interface with your device. Remove everything in Program.cs and replace it with the following code snippet.

using System;
using System.Collections.Generic;
using System.Text;
using TVA;
using TVA.PhasorProtocols;

namespace DeviceToData
    class Program
        static MultiProtocolFrameParser parser;
        static long frameCount;

        static void Main(string[] args)
            // Create a new protocol parser
            parser = new MultiProtocolFrameParser();

            // Attach to desired events
            parser.ConnectionAttempt += parser_ConnectionAttempt;
            parser.ConnectionEstablished += parser_ConnectionEstablished;
            parser.ConnectionException += parser_ConnectionException;
            parser.ParsingException += parser_ParsingException;
            parser.ReceivedConfigurationFrame += parser_ReceivedConfigurationFrame;
            parser.ReceivedDataFrame += parser_ReceivedDataFrame;

            // Define the connection string
            parser.ConnectionString =
                "phasorProtocol=IeeeC37_118V1; transportProtocol=Serial; accessID=2;" +
                "port=COM1; baudrate=115200; parity=None; stopbits=One; databits=8;" +
                "dtrenable=False; rtsenable=False; autoStartDataParsingSequence = false;";

            // When connecting to a file based resource you may want to loop the data
            parser.AutoRepeatCapturedPlayback = false;    // Not Looping

            // Start frame parser
            parser.AutoStartDataParsingSequence = true;

            // To keep the console open while receiving live data with AutoRepeatCapturedPlayback = false
            // Hold the console open until the operator hits the [Enter] key

        static void parser_ReceivedDataFrame(object sender, EventArgs<IDataFrame> e)
            // Increase the frame count each time a frame is received

            // Print information each time we receive 60 frames (every 2 seconds)
            if (frameCount % 60 == 0)
                IDataCell device = e.Argument.Cells[0];
                Console.WriteLine("Received {0} data frames so far...", frameCount);
                Console.WriteLine("    Last frequency: {0}Hz", device.FrequencyValue.Frequency);
                Console.WriteLine("    Last Timestamp: {0}",
                    ((DateTime)device.Timestamp).ToString("yyyy-MM-dd HH:mm:ss.fff"));

        static void parser_ReceivedConfigurationFrame(object sender, EventArgs<IConfigurationFrame> e)
            // Notify the user when a configuration frame is received
            Console.WriteLine("Received configuration frame with {0} device(s)", e.Argument.Cells.Count);

        static void parser_ParsingException(object sender, EventArgs<Exception> e)
            // Output the exception to the user
            Console.WriteLine("Parsing exception: {0}", e.Argument);

        static void parser_ConnectionException(object sender, EventArgs<Exception, int> e)
            // Display which connection attempt failed and the exception that occurred
            Console.WriteLine("Connection attempt {0} failed due to exception: {1}",
                e.Argument2, e.Argument1);

        static void parser_ConnectionEstablished(object sender, EventArgs e)
            // Notify the user when the connection is established
            Console.WriteLine("Initiating {0} {1} based connection...",

        static void parser_ConnectionAttempt(object sender, EventArgs e)
            // Let the user know we are attempting to connect
            Console.WriteLine("Attempting connection...");

Step 4: Set up your PMU Sensor

Just connect the GTosPMU sensor to the host PC serial or USB port and and plug in the transformer.

Step 5: Run the application

If you followed all the other steps correctly, you should be able to run the project by pressing "F5" from within Microsoft Visual Studio. The result should look something like the example image below.


Last edited Feb 10, 2011 at 8:38 PM by ajstadlin, version 7


No comments yet.