There are times where you may want to build a nice user interface for your Arduino program to monitor input/output. In this tutorial, I will show you how to use C# to send data to and receive data from the Arduino. This tutorial assumes basic knowledge of Arduino programming and C#. For testing purposes, we will create a vary basic “echo” program that takes an input and outputs the input.

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  while(Serial.available()) {
      Serial.write(Serial.read());
  }
}

While there is data available, we read it, then write it to the output. Now open Visual Studio and create a new Windows Forms Application. I will name it ArduinoSerial.

From your toolbox, add two Label’s, two ComboBox’s, and a SerialPort. I have named them lblCOM, lblBaud, cboPorts, cboBaud, and serialPort1 respectively. ComboBox’s cboPorts and cboBaud which will allow the user to select which COM port the Arduino is using and the correct Baud rate to use.

To get the available serial ports, use the GetPortNames() method from System.IO.Ports.SerialPort. You can then add this array to cboPorts.

string[] serialPorts = System.IO.Ports.SerialPort.GetPortNames();
cboPorts.Items.AddRange(serialPorts);

For the Baud rate ComboBox I am simply going to enumerate the values.

cboBaud.Items.Add(2400);
cboBaud.Items.Add(4800);
cboBaud.Items.Add(9600);
cboBaud.Items.Add(14400);
cboBaud.Items.Add(19200);
cboBaud.Items.Add(28800);
cboBaud.Items.Add(38400);
cboBaud.Items.Add(57600);
cboBaud.Items.Add(115200);

The final constructor takes the following form:

public ArduinoSerial()
{
    InitializeComponent();

    string[] serialPorts = System.IO.Ports.SerialPort.GetPortNames();
    cboPorts.Items.AddRange(serialPorts);

    cboBaud.Items.Add(2400);
    cboBaud.Items.Add(4800);
    cboBaud.Items.Add(9600);
    cboBaud.Items.Add(14400);
    cboBaud.Items.Add(19200);
    cboBaud.Items.Add(28800);
    cboBaud.Items.Add(38400);
    cboBaud.Items.Add(57600);
    cboBaud.Items.Add(115200);

    cboPorts.SelectedIndex = 0;
    cboBaud.SelectedIndex = 2;
}

Next we are going to create a button called btnStart. This button will initiate the connection to the Arduino. In the code for the buttons click event, we first need to get the port from cboPorts. Then are are going to assign this value to the PortName attribute of the SerialPort object.

serialPort1.PortName = cboPorts.SelectedItem.ToString();

We are going to do the same for the BaudRate attribute.

serialPort1.BaudRate = Convert.ToInt32(cboBaud.SelectedItem.ToString());

Then we are going to open the connection (and toggle the Start/Stop buttons)

if (!serialPort1.IsOpen)
{
    btnStart.Enabled = false;
    btnStop.Enabled = true;
    serialPort1.Open();
}

In the btnStop click event is very similar to the above.

private void btnStop_Click(object sender, EventArgs e)
{
    if (serialPort1.IsOpen)
    {
        btnStart.Enabled = true;
        btnStop.Enabled = false;
        serialPort1.Close();
    }
}

Now we can create a TextBox and a Button called txtInput and btnSend. These two controls will be responsible for sending data to the Arduino. In the btnSend click event add the following code.

if (!serialPort1.IsOpen) return;
serialPort1.Write(txtInput.Text + "\n");

The rest of the magic takes place in the SerialPorts DataReceived event. To get the data from the serial port we simply call the ReadExisting() function on the SerialPort object. Then we just need to append that text to a text box. However, we must make this thread safe to prevent any dead locks.

/**
 * http://msdn.microsoft.com/en-us/library/ms171728(VS.80).aspx
 */
delegate void SetTextCallback(string text);
private void SetText(string text)
{
    if (this.txtOutput.InvokeRequired)
    {
        SetTextCallback d = new SetTextCallback(SetText);
        this.BeginInvoke(d, new object[] { text });
    }
    else
    {
        txtOutput.AppendText(text);
    }
}

private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
{
    try
    {
        SetText(serialPort1.ReadExisting());
    }

    catch (Exception ex)
    {
        SetText(ex.ToString());
    }

}

On traditional Unix-style file systems three timestamps are associated with each file. These timestamps are atime, ctime, and mtime. Most people understand atime as “access time.” A file is accessed when its content is viewed or is executed. ctime and mtime generate confusion since “change time” and “modification time” seem synonymous. However, what you need to focus on is what is being changed. The mtime value is updated when the actual contents of the file are changed. However, updating mtime, also updates ctime. This does not mean an update to ctime will cause an update to mtime. The ctime value is updated when the files inode or change to the files content are made. For example:

# cat foo
Hello, World

Will update the files atime, but it will not effect the ctime or mtime.

# chmod 777 foo

Will update the files ctime but not the files atime or mtime.

# echo “Goodbye, World!” > foo

Will update the files ctime and mtime but not the files atime.

If you have done any web development, passing requests becomes an integral part of your code. Whether it is a session id, data to validate, or a view file to load you will most definitely end up passing one request or another. While working on my framework (which uses the model-view-controller design pattern), I decided to pass the controller, which the framework will load, through the URL. Since the controller’s primary purpose is to handle incoming http requests, I also passed a “view” parameter through the URL (which the controller will delegate accordingly). At this point, my URLs became unattractive index.php?module=Blog&view=index, which in todays world, of Web 2.0 sex appeal and search engine optimization, is just unacceptable. To circumvent the unsightly link, many developers choose to use mod_rewrite and define expressions in a .htaccess file. This is a perfectly legitimate practice for those of you who have mod_rewrite enabled on their server (and actually understand the rules). As an alternative, PHP’s $_SERVER['REQUEST_URI'] provides a cleaver solution.

What does $_SERVER['REQUEST_URI'] provide us with? Essentially, everything after the domain name. So if our URL is http://www.example.com/index.php?module=Blog&view=index, our URI is index.php?module=Blog&view=index. Moreover, if our URL is http://www.example.com/index.php/Blog/index, our URI is index.php/Blog/index. Using this, we can simply manipulate the URI to process incoming requests. First, we want to explode the URI at the file name, in my case it is index.php.

$requests = explode("/index.php/", $_SERVER['REQUEST_URI']);

$request is now an array whose first element is everything before and including index.php, and whose second element is everything after index.php. By manipulating $requests[1] we can use that data as our data.

$requests = explode("/index.php/", $_SERVER['REQUEST_URI']);
$uri = explode('/', $requests[1]);

The $uri array now contains all our disguised requests, which we can use in the same way as a $_GET request (with the exception of a sexier URL).

With three lines of code we have transformed a ugly looking URL http://www.example.com/index.php?module=Blog&view=index to http://www.example.com/index.php/Blog/index (a URL the most avid Web 2.0 gurus would find acceptable).

Pierre-Simon De Laplace (23 March 1749 – 5 March 1827) was a French mathematician and astronomer. In 1796 he formulated a nebular hypothesis of cosmic origin and was one of the first scientists to postulate the existence of black holes. He later proposed a solution to irregularities in Newton’s calculations and presented them in a work called Mécanique céleste. According to legend, when asked by Napoleon why God did not appear in his discussion, Laplace replied “I had no need of that hypothesis.” Among many discoveries, Laplace is most notable for the Laplace Transform which aids in solving differential equations by allowing for the transformation of an equation from the time domain to the frequency domain.

For a signal x(t), its Laplace transform X(s) is defined by
[latex]\mathrm{X(s)=}\int\limits_{-\infty}^{\infty}\mathrm{x(t)}e^{-st}dt[/latex]

Example: For a signal x(t) = e^-atu(t) find the Laplace transform X(s).

By definition
[latex]\mathrm{X(s)=}\int\limits_{-\infty}^{\infty}e^{-at}u(t)e^{-st}dt[/latex]

Since u(t) = 0 for t < 0 and u(t) = 1 for t ≥ 0,
[latex]\mathrm{X(s)=}\int\limits_{0}^{\infty}e^{-at}e^{-st}dt = \mathrm{X(s)=}\int\limits_{0}^{\infty}e^{-(s+a)t}dt = -\frac{1}{s+1}e^{-(s+a)t}\big|_{0}^{\infty}[/latex]

Thus we can conclude
[latex]\mathrm{X(s)=}\frac{1}{s + a} \mathrm{for Re(s + a) > 0}[/latex]

I watched this video in its entirety. I found it very interesting how he got his point across.

Guy Steele’s keynote at the 1998 ACM OOPSLA conference on “Growing a Language” discusses the importance of and issues associated with designing a programming language that can be grown by its users.