RoboticsConnection User Forum / RoboticsConnection Software Support / Serializer .NET Library

Webcam

speeduae — Thu, 21 Aug 2008 21:36:57 GMT

Dear members,

could you help me how to open webcam window in C# console application?

thanks a lot.

Motor Control

speeduae — Sun, 03 Aug 2008 13:19:36 GMT

[quote]Hi,
I’m beginner in C# and wrote this code below in Microsoft Visual C# 2008 Express in Console application to control DC motors. Actually I want to control DC motors from the keyboard, but the problem is I have to press enter after press key.
How can I solve this problem? and How can i change Com port?
Thank you.:)
using RoboticsConnection.Serializer;
using RoboticsConnection.Serializer.Ids;
using RoboticsConnection.Serializer.Sensors;
using RoboticsConnection.Serializer.Components;
using RoboticsConnection.Serializer.Controllers;
using System;
using System.Threading;

namespace test
{
class Program
{
static Serializer serializer;
static PwmDCMotorController LeftMotor;
static PwmDCMotorController RightMotor;

static void Main(string[] args)
{
serializer = new Serializer();

LeftMotor = new PwmDCMotorController(serializer);
RightMotor = new PwmDCMotorController(serializer);

LeftMotor.DCMotorId = DCMotorId.DCMotor2;
RightMotor.DCMotorId = DCMotorId.DCMotor1;

serializer.StartCommunication();
while (true)
{
serializer.PumpEvents();

Console.Write("Enter Key:");
string s = Console.ReadLine();

if (s == "w")
{
LeftMotor.Speed = 100;
RightMotor.Speed = 100;
}
if (s == "a")
{
LeftMotor.Speed = -100;
RightMotor.Speed = 100;
}
if (s == "d")
{
LeftMotor.Speed = 100;
RightMotor.Speed = -100;
}
if (s == "x")
{
LeftMotor.Speed = -100;
RightMotor.Speed = -100;
}
if (s == "s")
{
LeftMotor.Speed = 0;
RightMotor.Speed = 0;
}
}
}
}
}

Time delay

Silvermatrix — Sat, 10 May 2008 01:42:10 GMT

Hi I have a Problem and I don´t know if it a Hard - or Software Problem.

I write a Programm in C#. There is a Button on the interface, when I press this Button a Motor starts. A switch which is connected on I/O Pin 1 works as a counter.

The start and stop from the motor over the C# Interface works great and very fast. But the count from the switch which is connected to the borad has a time delay of 0,5 - 1 second.

Is this normal? Can I make this faster? is there the possibility the press of the switch to write in a register, so that I see the counter works when i press the switch faster?

I have tried some different "Timer" periods from 25 - 200 msec. But the counter is always to slow.

Unhandled exception errror

caquinto — Tue, 24 Jun 2008 17:22:23 GMT

Hi all,
we are working on a summer robotics project at Mesa State College and have run into an early snag.
We have the serializer controller board with the bluetooth serial interface with one servo connected to servo pin 1 (digital 8). When we try to run this code:

[i]using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using RoboticsConnection.Serializer;
using RoboticsConnection.Serializer.Components;
using RoboticsConnection.Serializer.Controllers;
using RoboticsConnection.Serializer.Ids;
using RoboticsConnection.Serializer.Sensors;

namespace ServoApp
{
class Program
{
Serializer serializer;
ServoMotorController antennaServo;

private void InitializeSerializer()
{
serializer = new Serializer();
serializer.BaudRate = 19200;
serializer.PortName = "COM40";
serializer.CommunicationStarted += new SerializerEventHandler(serializer_CommunicationStarted);

antennaServo = new ServoMotorController(serializer);
antennaServo.ServoMotorId = ServoMotorId.ServoMotor1;
antennaServo.Position = -100;

serializer.Run();
}

void serializer_CommunicationStarted(Serializer sender)
{
serializer.BlinkLED(LedId.Led1, 50);
serializer.BlinkLED(LedId.Led2, 100);
serializer.Units = Units.English;
}

static void Main(string[] args)
{
Program p = new Program();

System.Threading.Thread thread = new System.Threading.Thread(
new System.Threading.ThreadStart(p.InitializeSerializer));
thread.Start();

for (int position = -99; position <= 100; ++position)
{
p.antennaServo.Position = position;
for (int i = 0; i < 100000; ++i) { ; }
}
p.serializer.ShutDown();
}

}
}[/i]

we get this error:

[i]Unhandled Exception: System.NullReferenceException: Object reference not set to
an instance of an object.
at RoboticsConnection.Serializer.Internal.CommunicationTask.ThreadProc()
at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, C
ontextCallback callback, Object state)
at System.Threading.ThreadHelper.ThreadStart()

[/i]

Does anyone have any ideas on what might be wrong here?
Thanks

Getting distance traveled from PID controller?

pirobot — Sat, 31 May 2008 11:08:36 GMT

Hi Jason,

I've checked the .Net documentation on the PID controller interface and it's not clear to me if I can get the distance traveled between any two points in time. In other words, suppose I command my robot to move 48 inches but part way through it has to stop because of an obstacle. I'd like to be able to read off how far it traveled before stopping. If I were doing it at the firmware level I could clear the encoder counters then read off their values when the robot stopped.

Thanks!
patrick

How to cleanly shutdown a .NET Serializer application?

pirobot — Thu, 24 Apr 2008 15:28:20 GMT

Yes, it's me again! :) I am trying to cleanly shut down my Serializer C# application but I must be missing something.

I am using a Bluetooth connection to the Serializer and everything works great in terms of firing up the application, connecting to the Serializer, retrieving senors values, etc. Then I close my Windows form and issue either a Serializer Shutdown() or StopCommunication() command--or both--during the "Form Closed" or "Form Closing" event handler. The application shuts down cleanly with no complaint (I'm running this all in Debug mode within Visual Studio 2005). However, if I fire the application up again, it connects to the Serializer but no longer sees any sensor values--in other words, the fields on my form that display the sensor values all show 0. With the application still running, if I reset the Serializer using the little white push button, then the sensor values show up again. This behavior always occurs--I can never run the application twice in a row without resetting or power-cycling the Serializer.

Any thoughts?

Thanks,
patrick

Volume, Pitch and Speed for SP03?

pirobot — Wed, 14 May 2008 20:33:33 GMT

Hello Jason,

Is there a way to embed volume, pitch or speed control characters in the string phrase passed to the SP03.Speak method? When I used my SP03 with a Brainstem controller in the past, the Acroname software interface had a way to set these parameters.

Thanks!
patrick

How to program the Serializer WL with VB.NET?

sven.somers@gmail.com — Mon, 12 May 2008 11:38:14 GMT

Hi,

I'm living in Europe (Belgium, Brussels) and I was looking for a controller that could work in both Visual Studio .NET and MSRS. So I found the Serializer WL, ordered it and experimented with it in Hyperterm. Everything works well!

Now, I want to drive some servo's (and probably in the near future also DC motors and sensors) with the VB 2005 express edition, but unfortunately I only find examples and software code in C#.

Is there anybody that can help me transferring this C# code into operating VB code? Maybe 1 or 2 small examples "how to drive servo's" will do the job!

Thanks and greetz from Belgium!

Sven Somers

Correct use of "static" Serializer object in C#?

pirobot — Wed, 23 Apr 2008 15:31:56 GMT

Hi Jason (or anyone else who knows!),

I'm trying to declare my Serializer object in a C# application in such a way that I can add sensors and drive motor objects by way of their own classes. In other words, in my main Windows Forms application, I want to be able to do something like this:

mySerializer = new Serializer();
mySensors = new Sensors();
myDriveMotors = new DriveMotors();

where, for example, the Sensors class looks something like:

public class Sensors
{
public Ping sPing;

public Sensors()
{
sPing = new Ping(Serializer);
sPing.Pin = GpioPinId.Pin0;
}
}

and similarly for the Controller and DriveMotors classes. Then, in the rest of my application, I can refer to the Ping sensor as mySensors.sPing etc.

The Serializer class of course creates a new Serializer object and then runs StartCommunication(). My problem is that I can't figure out what needs to be static (or not) so that I don't get "null object references" when I create the Sensors and DriveMotors classes (which depend on the Serializer object). Similarly, I'm not sure if I call StartCommunication() before or after I instantiate the Sensors and DriveMotors classes.

I know if I put all the sensor and motor definitions in the same class file as the Serializer, then I can get things to work, but I'm trying to make my code a little more modular.

Does this make any sense???

--patrick

Can't toggle Ping from Enabled=false to Enabled=true

pirobot — Thu, 17 Apr 2008 08:15:52 GMT

Hi Jason and Ringo,

I am simply trying to toggle one of my Ping sensors from Enabled=true to Enabled=false, then back to Enabled=true. My simplest test pseudo code is:

Ping.Enabled=false
sleep 2 seconds
Ping.Enabled=true

What I observe is that the first line successfully turns the Ping sensor off (LED stops flashing and I don't get updated distances), but the third line does not turn it back on. Am I missing something?

I am using the latest Serializer.NET library and firmware 1.5.1.

On a related note, do you happen to know the fastest meaningful update frequency one can use with the Ping sensors? Ditto for the GP2D12 sensors. In other words, what is the minimum round trip time for a manual update() and distance reading using these two sensors and the Serializer? (I imagine the Ping sensor will take longer than the IR sensor.)

Thanks!
patrick

Servo controll

Silvermatrix — Sat, 12 Apr 2008 02:53:12 GMT

Hi in the moment I can make a simple Programm in which i can show the state of the Digital Pins, controll the LEDs and two Motors.

Now I have added a Servo on Servo Pin1. In the timer, where I controll a Motor with the Digital Pin1, I have added the Position argument for the Servo.

When I Start the Programm, the Servo goes first time to the positon. After this the Servo don´t work. At the same time I can´t controll the Motor with my Button.

When I delete the Servo.Position = 40; in my Programm, I can controll the Motor.

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Threading;

using RoboticsConnection.Serializer;

using RoboticsConnection.Serializer.Components;

using RoboticsConnection.Serializer.Controllers;

using RoboticsConnection.Serializer.Ids;

using RoboticsConnection.Serializer.Sensors;

namespace WindowsFormsApplication1

{

public partial class Form1 : Form

{

private Serializer _s;

private PwmDCMotorController _motor;

private ServoMotorController _servo;

private GpioPin _pin;

public Form1()

{

InitializeComponent();

_s = new Serializer();

_s.PortName = "COM40";

_s.BaudRate = 19200;

_s.CommunicationStarted +=new SerializerEventHandler(_s_CommunicationStarted);

_motor = new PwmDCMotorController(_s);

_motor.DCMotorId = DCMotorId.DCMotor1;

_motor.Speed = 0;

_pin = new GpioPin(_s);

_pin.Pin = GpioPinId.Pin1;

_pin.Enabled = true;

_servo = new ServoMotorController(_s);

_servo.ServoMotorId = ServoMotorId.ServoMotor1;

// _servo.Position = 0;

_s.StartCommunication();

}

void _s_CommunicationStarted(Serializer sender)

{

timer1.Enabled = true;

}

private void timer1_Tick(object sender, EventArgs e)

{

if (_pin.State == true)

{

_motor.Speed = 80;

_servo.Position = 50;

}

if (_pin.State == false)

{

_motor.Speed =0;

_servo.Position = -50;

}

_s.PumpEvents();

}

Trouble accessing CMPS03 via I2CGeneric

cjohns — Thu, 27 Mar 2008 17:21:25 GMT

I attempted to roughly follow the example for the I2CDevice accessing CMPS03 compass, posted at:
http://www.roboticsconnection.com/multimedia/libraries/MSDNDocumentation/_23n15r2ti.htm

The main difference being that I am doing it from a Windows Forms not Console. Here is what I coded, which is not working (always returns "255"). [FYI, my compass is working fine using Serializer.NET class CMPS03, so its not a hardware issue]. Let me know if you see anything wrong here ...

[Declaration]:
private static I2CDevice i2cd;

[Form_Load]:
i2c = new I2CDevice(serializer)
i2cd.I2CAddress = 0xC0;
i2cd.ReadCommand = "1";
i2cd.WriteCommand = "1";
//I notice there is no i2cd.Update() like I would normally use for CMPS03 class?

[Periodic_Timer_Tick]:
serializer.PumpEvents();
i2cd.Write();
lblCompass.Text = i2cd.Read().ToString(); //always posts 255 to my label

High resolution CMPS03 readings

cjohns — Thu, 27 Mar 2008 16:16:12 GMT

I am experimenting with my CMPS03. Using compass.Heading() gets me a number between 0 and 255, which you are pulling from I2C register 1, according to my manual for this sensor.

However, there is a higher-resolution compass bearing (0 to 3599) available in registers 2 and 3 (divide by 10 to get actual compass bearing, in degrees). That value (in actual degrees) seems more useful. Any chance you could add that to the Serializer.NET class? I'd suggest just creating a new property, maybe HighResolutionHeading() or HeadingInDegrees() or something like that, so as not to affect anyone who may have programmatically used the regular Heading() already in their code.

In the meantime, that gives me an excuse to tinker with the I2C Generic you showed me in a previous post. I'm going to see if I can pull this high resolution reading using that, to hone my skills for when I get a power supply for my MD23. :)

I2C Generic to MD23

cjohns — Wed, 26 Mar 2008 11:45:20 GMT

Jason,

Thanks for your response to my earlier post. I'll pull this out into a separate topic in case it might help someone else. I saw the I2CDevice object and figured that would be the way to go, for communicating with the not-yet-supported MD23 I2C device.

However, I got a little hung up with the I2C byte sequences that you mention. The MD23 documentation discussing the registers, etc., is at http://www.robot-electronics.co.uk/htm/md23tech.htm and it describes "first send a start bit, the module address (0xB0 for example) with the read/write bit low, then the register number you wish to read [there is a list of registers, 0-16, in a table there]. This is followed by a repeated start and the module address again with the read/write bit high (0xB1 in this example). You are now able to read one or more registers."

Being a relative newbie to I2C and serial communication, I haven't quite been able to translate that into C#, let alone English :)

What i2cd.Write() command(s) would I issue to this (assuming it's at its default I2C address, 0xB0) to read the battery volts (register 10) and write a mode of "2" to register 16? [A read example and a write example should be enough to get me off to the races!] :)

Thanks!

Serializer .NET Library v1.2.3.0 Released

jsummerour — Tue, 25 Mar 2008 19:02:53 GMT

We just released the Serializer .NET Library version 1.2.3.0

Serializer Page
Serializer .NET Library Installer (msi)
Serializer .NET Library Release Notes (.txt)

This fixed the following issues:

PIDMotorController not allowing identical distance and rotation angles to be set back-to-back
TPA81 Fahrenheit conversion bug
Updated and auto compiled MSDN documentation examples

Best Regards!

Suggestions for addition to SerializerLIB

cjohns — Tue, 25 Mar 2008 21:56:50 GMT

For whatever it is worth, here are a couple things I'd like to see in a future Serializer.NET (and Robotics Studio) release:

1. A class for the Sharp GP2Y0A02YK infrared sensor (8-60").

2. A class for the Devontech MD23 (I2C H-Bridge).

TPA81 reads differently when calling from RoboticsStudio vs. Serializer.NET

cjohns — Tue, 25 Mar 2008 13:11:37 GMT

I have a TPA81 that reads usually 75-77 F (24-25C) in Robotics Studio service TPA81Service. However, if I poll the exact same sensor from a Windows Forms application using Serializer.Net call like this:

lblTemp = tpa81[0].Temperature.ToString(); //get ambient temp

the value I get returned is usually 56-57. If I heat the thing up, it goes up; if I cool it down, it goes down. So on a relative basis it seems to be working, but the value it is returning is clearly not Celsius or Fahrenheit. The same for all the other eight temp points. I know the sensor is working fine, because RoboticsStudio service is correctly reading the temps off it. Is my programmatic call above retrieving some kind of raw sensor reading that needs to be converted to F or C? (If so, what is the formula?) Or what might be going on here, any ideas?

Thanks!

Serializer .NET Library User Documentation and Examples Updated

jsummerour — Sun, 16 Mar 2008 20:16:52 GMT

I just updated the Serializer .NET Library User Documentation pages.

The updates included:

Example Programs Compiled to ensure there are no compilation errors.
Example Programs used are now auto compiled by the Serializer .NET Library Solution to ensure there are no more compilation errors going forward
Image Updates
Added .CHM file to the site, so you can download the Serializer .NET Library Documentation locally

Best Regards!

Update .Net library and support ?

Arnaud — Sun, 20 Jan 2008 09:25:19 GMT

i when are you inprove the current library ? (In 3 week you said me)

And when you improve documentation because a lot of new fonctions appear but the actual doesn't give any information about it ?

Regards,

Arnaud

Serializer .NET update? :)))

pirobot — Mon, 18 Feb 2008 08:50:48 GMT

Hi guys,

Congrats on your new forums and website--very nice! In the meantime, my poor robot is really beginning to suffer from the still-existing bug in the .NET libraries regarding PID motion control. (The one where a minus sign gets dropped or added so that a left rotation command actually rotates the robot to the right, or a forward command actually makes the robot go backward...) You mentioned back on Jan 16 that you hoped to have an update available within three weeks--do you have a new ETA? I'm really start to depend on your most excellent Serializer and so would appreciate the bug fix.

Thanks!
patrick

Serializer .NET Library v1.2.2.4 and Firmware v1.5.2 Released

jsummerour — Tue, 04 Mar 2008 20:31:03 GMT

The Serializer .NET Library v1.2.2.4 was released today which contains the following enhancments.

Added QueryStatus() to query internal PID algorithm status to determine when PID distance algorithm has finished traveling specified distance in the PIDMotorController class.
PIDMotorController no longer derives from QueryableComponentBase, but from SerializerComponent now.
Changed PIDMotorController QueryVelocities() to be manually invoked, instead of invoked at a specified UpdateFrequency.
Added Motor1Speed and Motor2Speed properties to the PIDMotorController class.
Updated Velocity and Distance PID params to work w/ latest motors on Traxster and Stinger
Updated encoder params to match latest encoders on Traxster and Stinger
Added optional DistDeadband and DeadbandEnabled PIDMotorController properties to work with firmware versions 1.5.2 and higher.
Added ConstantUpdates property to LineFollowingSensor, so that the LineSensorChanged event constantly occurs (based on UpdateFrequency). ConstantUpdates defaults to false, in which case the LineSensorChanged event only occurs when the actual value of the sensor changes.

We also launched a new Serializer Firmware version, v1.5.2, which includes the following enhancements:

Added Deadband for Distance PID. Also added additional (optional) deadband parameter for 'dpid' command so you can set the deadband. Deadband is defaulted to 5, and you shouldn't really need to set it.
Modified mogo and digo commands to set wheels speeds as close to the same time as possible. Mismatched motors might still show signs of one starting over the other.
Updated PID velocity and distance parameters for smoother acceleration for the DC Gearhead Motor combo used in our Traxster and Stinger Robot Kits. (vpid -> 10:0:5:10 dpid -> 1:0:0:20:5)

The Serializer .NET Library and Firmware can be downloaded from the Serializer Robot Controller Page under the Docs/HowTo/Documentation tab. The MSDN style documentation has also been updated to reflect the latest changes in the .NET Library.

Best Regards!

Is it possible programming robots without .Net library?

jsummerour — Sat, 19 Jan 2008 19:14:30 GMT

Absolutely. All you have to do is have the ability to open up a serial (COM) port, set the proper settings (baud rate, start/stop bits, etc), and send/receive commands/responses to/from the Serializer using the Serializer Protocol, which is documented in the Serializer User Guide.

Thus, if you have the ability to open up a COM port within another language/framework, then you can certainly control/query everything supported by the Serializer.

Best Regards,

When to use Serializer.Run() and Serializer.PumpEvents()

jsummerour — Sat, 19 Jan 2008 17:41:04 GMT

For those of you who have used the Serializer .NET library, you have probably seen that there are two ways to allow the library to send out events for the various objects as your application is running.

You can either use:

1.) Serializer.Run(), or

2.) In an infinite loop, call Serializer.PumpEvents()

Serializer.Run()

The Serializer.Run() method is useful if don't need to perform any processing in between events (such has handle button clicks, read joysticks, invoke other methods or interfaces). Thus, if you have a simple application where all you want to do is print the output of various sensors values to the screen, and you have nothing else to do, then Serializer.Run() is your command.

using RoboticsConnection.Serializer;
using RoboticsConnection.Serializer.Ids;
using RoboticsConnection.Serializer.Sensors;
using RoboticsConnection.Serializer.Components;
using RoboticsConnection.Serializer.Controllers;
using System;

namespace test
{
class Program
{
static Serializer serializer;
static GP2D12 irSensor;

static void Main(string[] args)
{
serializer = new Serializer();

// Sign up for the CommunicationStarted event, so we'll know
// that the library has established communications w/ the board
serializer.CommunicationStarted += new SerializerEventHandler(serializer_CommunicationStarted);

// Create some object:
irSensor = new GP2D12(serializer);
irSensor.Pin = AnalogPinId.Pin2;
irSensor.UpdateFrequency = 50;
irSensor.DistanceChangedThreshold = 0.5;

// Sign up to receive events from the GP2D12 object:
irSensor.DistanceChanged += new SerializerComponentEventHandler(irSensor_DistanceChanged);

serializer.StartCommunication();

// Enter the run loop, which constantly invokes Serializer.PumpEvents()
// Communication with the serializer board is started and this thread
// is blocked until ShutDown() is called (presumably in an event handler).
// As PumpEvents() gets called internally, event for various objects, e.g. GP2D12
// will be signalled, and our handlers below will be invoked.
serializer.Run();
}

// This gets invoked once the Serializer object has established communication
// with the Serializer board:
static void serializer_CommunicationStarted(Serializer sender)
{
Console.WriteLine("Communication Started.");
}

// This gets invoked once the GP2D12 distance has changed
// more than the threshold amount specified above.
static void irSensor_DistanceChanged(SerializerComponent sender)
{
Console.WriteLine("New gp2d12 distance: {0}", irSensor.Distance);
}
}
}

Serializer.PumpEvents()

If you want to perform other processing in between events sent out from the Serializer .NET library, then you'll want to set up your own internal loop, whether it be a while(true) { } loop, or a Timer.Tick() handler (via a Windows Form), and invoke Serializer.PumpEvents() within that loop. Building on the example above you would then have:

serializer.PortName = "COM11";

// Sign up for the CommunicationStarted event, so we'll know
// that the library has established communications w/ the board
serializer.CommunicationStarted += new SerializerEventHandler(serializer_CommunicationStarted);

// Create some object:
irSensor = new GP2D12(serializer);
irSensor.Pin = AnalogPinId.Pin2;
irSensor.UpdateFrequency = 50;
irSensor.DistanceChangedThreshold = 0.5;

// Sign up to receive events from the GP2D12 object:
irSensor.DistanceChanged += new SerializerComponentEventHandler(irSensor_DistanceChanged);

serializer.StartCommunication();

// Enter an infinite run loop, which constantly invokes Serializer.PumpEvents().
// This is doing the same thing as Serializer.Run(), however, you get a chance to
// do other tasks in between the call to Serializer.PumpEvents().
while(true)
{
// Do whatever you need to do here, such as set motor speeds, move servos,
// make navigation decisions, etc.

// Invoke Serializer.PumpEvents() so that any outstanding events
// that need to be triggered occurs.
Serializer.PumpEvents();
}
}

// This gets invoked once the Serializer object has established communication
// with the Serializer board:
static void serializer_CommunicationStarted(Serializer sender)
{
Console.WriteLine("Communication Started.");
}

// This gets invoked once the GP2D12 distance has changed
// more than the threshold amount specified above.
static void irSensor_DistanceChanged(SerializerComponent sender)
{
Console.WriteLine("new gp2d12 distance: {0}", irSensor.Distance);
}
}
}

Windows Forms...

If you want to build a Windows Form application, and interface the Serializer .NET library, it's really as simple as adding a Timer object (Components ToolBox) to your form...

setting the timer1 Enabled property to false, setting the Interval property to 10 (for example). If you enable the timer1 Enabled property to True at this point, a race condition exists, and it may attempt to invoke serializer.PumpEvents() in the timer handler before the serializer object exists.

and adding a handler to handle the Tick event...

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using RoboticsConnection.Serializer;
using RoboticsConnection.Serializer.Components;
using RoboticsConnection.Serializer.Controllers;
using RoboticsConnection.Serializer.Ids;
using RoboticsConnection.Serializer.Sensors;

namespace SerializerTestApp
{
public partial class Form1 : Form
{
private Serializer serializer;
private PwmDCMotorController motor;
private GP2D12 ir;

public Form1()
{
InitializeComponent();
serializer = new Serializer();
serializer.PortName = "COM1";
serializer.BaudRate = 19200;
serializer.Units = Units.English;
serializer.CommunicationStarted += new SerializerEventHandler(serializer_CommunicationStarted);

motor = new PwmDCMotorController(serializer);
motor.DCMotorId = DCMotorId.DCMotor1;
motor.Speed = 0;

ir = new GP2D12(serializer);
ir.DistanceChangedThreshold = 0.1;
ir.Pin = AnalogPinId.Pin0;
ir.UpdateFrequency = 50; // 50 msec
ir.DistanceChanged += new SerializerComponentEventHandler(ir_DistanceChanged);

serializer.StartCommunication();
}

void ir_DistanceChanged(SerializerComponent sender)
{
Console.WriteLine("Distance Changed: {0}", ir.Distance);
}

void serializer_CommunicationStarted(Serializer sender)
{
Console.WriteLine("Communication Started");

// Enable timer, which is disabeld by default...

timer1.Enabled = true;
}

private void timer1_Tick(object sender, EventArgs e)
{
// Set motor speed based on distance of object
// in front of ir sensor.
motor.Speed = (int)(ir.Distance * 3.22);
// Let library signal outstanding events:
serializer.PumpEvents();
}
}
}

So, every 100 msec, the timer1_Tick() handler is setting the speed of a motor based on the distance of the object in front of the ir sensor. Since the speed range of the motor is 0 to 100, and the distance range of the GP2D12 is 4 to 31, the ir distance is scaled by a factor of 3.22 so you can use the full motor speed range for this experiement. In fact, it's just and example...and the logic isn't really that useful, eh? :) Notice that even though the motor speed is being set every 100 msec, the internal distance property for the GP2D12 is being set every 50 msec. When the distance changes more than the specified threshold specified above, then the DistanceChanged event will occur, and the ir_DistanceChanged() handler will be invoked.