I was wondering if anyone had a comprehensive list of Netduino Resources such as blogs, videos etc. Thanks

I've amassed about 50+ sites that have .NET MF related blog posts, code, and circuits. They are not all Netduino related, but I use them day to day in my development. My list is a lot like Pete Brown's geek list, I'll spend some time breaking them out into various categories and update the Wiki with them. Thanks Guys!

This is a really good piece of work. Once you have it all documented it definitely should get posted to the WIKI. Thanks for sharing your idea!

I studied the NETduino HW a bit and found that DM9161A chip performs autonegotiation for Ethernet link establishment autonomously.

I'm wondering if maybe you've come across something that has always plagued systems. I know in the windows world auto negotiation has always been problem some for devices and I have worked with network technicians who have recommended that it be turned off.

Maybe we should look at adding the capability to set the port speed on the Netduino Plus. If the network folks are having people turn it off, maybe we need to provide similar capabilities to allow the device to coexist with all of the other devices on the network.

If you are just starting out check out "Getting Started with Netduino" by Chris Walker http://www.amazon.co...ywords=Netduino and "Getting Started with the Internet of Things: Connecting Sensors and Microcontrollers to the Cloud" by Cuno Pfister http://www.amazon.co...micro framework If you want a little more detail about the .Net Micro Framework check out "Expert .NET Micro Framework" by Jens Kühner http://www.amazon.co...micro framework Another good example about .Net Micro Framework devices that includes code examples for the Netduino is "Professional's Guide To .NET Micro Framework Application Development" by Sean D. Liming and John R. Malin http://www.amazon.co...micro framework Otherwise, the best examples you are going to find are right here in the forums. I don't think there is nothing that hasn't been covered or discussed in one way or another. Good Luck!

Later in this tutorial I also will describe how one can use FET/MOSFET, DIOD or Transistor NAND as well as NAND TTL IC to achieve same.

Wouldn't an XOR Gate work better than a NAND Gate? I would think you would only want a high output when the two input are different. So if the Netduino board sets all pins to high at reset you could hook up one input to the Netduino pin you are going to use as a switching signal and the second to positive voltage. This way when the board resets both inputs would be high and the output would stay low. Then once your application starts you could drive the Netduino pin low to get a high output from the XOR Gate thus providing the voltage required to allow current to flow through the transistor.

Or do I have my logic backwards and you need the NAND gate to keep the signal high so there is not enough difference at the base of the transistor to allow current to flow?

Regards,

Jim Lavin

Looking at the specs for both a NAND Gate and XOR Gate I think I answered my question. They both give you a high output when the inputs are different. The only difference is that the XOR Gate does not give you a high output when both signals are the same where as the NAND Gate will give you a high output if both signals are low. So I guess you could use either type of gate. Regards, Jim Lavin

Nevyn, Don't feel bad I resorted to buying a magnifying lamp this summer so I could read the letters on my components plus I have to use my multimeter to read my resistors.

Have you made sure that the assemblies your program is referencing have been built for .Net 4.2? I know that if you use some of the libraries directly from the web sites, they have not been compiled for .Net 4.2 and you will see that error when you try to deploy them to your Netduino. I tend to add the source code to my solution and then I know that all of the libraries have been compiled for whatever version of .Net my device is running. Good Luck.

Here are a couple of links that discuss this process in some detail that might help you to make your routine more efficient. The last link actually has an entire library to provide the missing functionality for all of the decimal types. http://www.eggheadca...bledecimal.aspx and http://bloggingabout...-framework.aspx Hope it helps

I've been working on a new brewing project and have gotten far enough along to start showing it off to folks. I've been working on modifying an Electric Turkey Fryer that I can use to brew small batch of beer for competitions and such. I based the temperature control off of my previous DIY Brewery Temperature Monitor project and enhanced it to allow the user to enter in a temperature that the Netduino will work to maintain during the mashing process. I've also added buttons to control the system for those times when I don't have a network handy along with a LCD Display to show the current status of the system. I'm still waiting for the circuit boards to come back from BatchPCB.com so I can assemble the system in a nice control panel. You can read about it over at my DIY Brewery Blog at http://diybrewery.com

Valkyrie-MT, I applied your change and got another couple of KBytes back on my app. It really helps to be able to squeeze memory from different places when you are trying to shoe horn in a lot of functionality in an app. Thanks!

The Netduino will handle what you are looking for as far as inputs and outputs. The biggest issue I've ran across is memory. To do a lot of what you want to do, requires a lot of code and even under .Net 4.2 you are limited to around 64Kb of code on the Netduino Plus which makes things cramped. You'll need to probably start off with some of the libraries out in the community and cut them down to just what you'll need and jettison all of the extra stuff that you don't to get everything on the Netduino Plus. I'll be interested in how things go. I always love seeing someone using off the shelf items to build out their brewery. Good Luck

BTW: I have a project out on GitHub that covers my Brew Controller for a modified Electric Turkey Fryer, that runs on a Netduino Plus that has both a physical user itnerface, (LCD and Buttons), as well as a web based UI. It is based on my DIY Brewery TempLogger Project out at http://diybrewery.com You can find the code on GitHub at https://github.com/l...yTempController Hope it helps you get started!

Nicky, Good Catch! I had to do something similar with my web server. All TCP/IP communications would hang until the Netduino would get an IP Address when the Netduino was configured for DHCP. Another thing to watch out for, is your app will hang if the Netduino is configured for DHCP and you are not connected to a network. I ran into that a couple of times as well.

Did you try the usual methods to stabilize the voltages, like in http://highfieldtale...highfieldtales/ - connect aref to 3v3 via a inductor, use a (fast) capacitor between aref and ground and a "big" one between 3v3 and ground?

Stefan,

That is a really good article, I never realized how much noise was going on. Being pretty rusty with electronics do you have a sample schematic that shows what your final solution was to filter out the noise?

Thanks,

Jim Lavin

I picked up an Adafruit 20x2 Character VFD (Vacuum Fluorescent Display) - SPI interface - 20T202DA2JA

http://www.adafruit.com/products/347

I was hoping to use it an one of my controller projects. I based my driver off of the MicroLiquidCrystal Shifter74Hc595LcdTransferProvider and the LCD class. I made changes based on the datasheets, but I'm having to send data and commands twice in order to get the controller to recognize what I'm sending.

I'm thinking maybe my SPI configuration is setup incorrectly, but I haven't been able to find too much about how to configure the SPI port.

I've included the code below, in case anyone can figure it out.

Thanks!

using System;
using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.NetduinoPlus;

//
// SPI Vacum Flouresent Display Driver
// Based on the SPI_VFD Arduino Library
// Created by AdaFruit
//
namespace CodingSmackdown.Drivers
{
// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set:
// N = 1; 2-line display
// BR1=BR0=0; (100% brightness)
// 3. Display on/off control:
// D = 0; Display off
// C = 0; Cursor off
// B = 0; Blinking off
// 4. Entry mode set:
// I/D = 1; Increment by 1
// S = 0; No shift
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that its in that state when a sketch starts (and the
// SPI_VFD constructor is called).
public class SPI_VFDisplay : IDisposable
{
// commands
private const byte VFD_CLEARDISPLAY = 0x01;
private const byte VFD_RETURNHOME = 0x00;
private const byte VFD_ENTRYMODESET = 0x04;
private const byte VFD_DISPLAYCONTROL = 0x08;
private const byte VFD_CURSORSHIFT = 0x10;
private const byte VFD_FUNCTIONSET = 0x30;
private const byte VFD_SETCGRAMADDR = 0x40;
private const byte VFD_SETDDRAMADDR = 0x80;

// flags for display entry mode
private const byte VFD_ENTRYRIGHT = 0x00;
private const byte VFD_ENTRYLEFT = 0x02;
private const byte VFD_ENTRYSHIFTINCREMENT = 0x01;
private const byte VFD_ENTRYSHIFTDECREMENT = 0x00;

// flags for display on/off control
private const byte VFD_DISPLAYON = 0x04;
private const byte VFD_DISPLAYOFF = 0x00;
private const byte VFD_CURSORON = 0x02;
private const byte VFD_CURSOROFF = 0x00;
private const byte VFD_BLINKON = 0x01;
private const byte VFD_BLINKOFF = 0x00;

// flags for display/cursor shift
private const byte VFD_DISPLAYMOVE = 0x08;
private const byte VFD_CURSORMOVE = 0x00;
private const byte VFD_MOVERIGHT = 0x04;
private const byte VFD_MOVELEFT = 0x00;

// flags for function set
private const byte VFD_2LINE = 0x08;
private const byte VFD_1LINE = 0x00;

private const byte VFD_SPICOMMAND = 0xF8;
private const byte VFD_SPIDATA = 0xFA;

private byte _linemode;
private byte _brightness;
private byte _displaycontrol;
private byte _shiftmode;
private byte _incrementmode;
private byte _displaymode;
private byte _cursormode;
private byte _blinkmode;

private byte _initialized;

private byte _numlines;
private byte _currline;

private readonly SPI _spi;
private readonly OutputPort _latchPort;
readonly byte[] _writeBuf = new byte[1];

public enum Brightness
{
VFD_BRIGHTNESS25 = 0x03,
VFD_BRIGHTNESS50 = 0x02,
VFD_BRIGHTNESS75 = 0x01,
VFD_BRIGHTNESS100 = 0x00
}

public SPI_VFDisplay(SPI.SPI_module spiBus, Cpu.Pin latchPin, Brightness brightness)
{
var spiConfig = new SPI.Configuration(
Cpu.Pin.GPIO_NONE, //latchPin,
false, // active state
0, // setup time
0, // hold time
false, // clock idle state
true, // clock edge
1000, // clock rate
spiBus);

_spi = new SPI(spiConfig);

_latchPort = new OutputPort(latchPin, true);

//default to 2x20 display (SAMSUNG 20T202DA2JA)
begin(20, 2, brightness);
}

public void begin(byte columns, byte lines, Brightness brightness)
{
// set number of lines
if (lines > 1)
_linemode = VFD_2LINE;
else
_linemode = VFD_1LINE;
// save off for address translation
_numlines = lines;

// turn the display on with no cursor or blinking default
_displaycontrol = VFD_DISPLAYON;
_cursormode = VFD_CURSORON;
_blinkmode = VFD_BLINKOFF;
_shiftmode = VFD_ENTRYLEFT;
_incrementmode = VFD_ENTRYSHIFTDECREMENT;
// init the display
display();

//catch bad values
if (brightness > Brightness.VFD_BRIGHTNESS25)
_brightness = (byte)Brightness.VFD_BRIGHTNESS100;
else
_brightness = (byte)brightness;
// set the brightness and push the linecount with VFD_SETFUNCTION
setBrightness(brightness);

// set cursor shift for romance lnaguages
leftToRight();

// clear the display
clear();
// set starting address to column 0, row 0
home();
}

public void setBrightness(Brightness brightness)
{
// set the brightness (only if a valid value is passed
if (brightness <= Brightness.VFD_BRIGHTNESS25)
{
_brightness = (byte)brightness;

command((byte)(VFD_FUNCTIONSET | _brightness | _linemode));
}
}

public byte getBrightness()
{
// get the brightness
return (byte)(_brightness);
}

public void clear()
{
command(VFD_CLEARDISPLAY); // clear display, set cursor position to zero
}

public void home()
{
command(VFD_SETDDRAMADDR | 0x00); // set cursor position to zero
}

public void setCursor(byte col, byte row)
{
int[] row_offsets = { 0x00, 0x40, 0x14, 0x54 };

if (row > _numlines)
{
row = (byte)(_numlines - 1); // we count rows starting w/0
}
// we only have 20 columns even though there are 40 cols addressable
if (col > 20)
{
col = 20;
}

int address = col + row_offsets[row];

command((byte)(VFD_SETDDRAMADDR | address));
}

// Turn the display on/off (quickly)
public void noDisplay()
{
_displaycontrol = VFD_DISPLAYOFF;
command((byte)(VFD_DISPLAYCONTROL | _displaycontrol | _cursormode | _blinkmode));
}

public void display()
{
_displaycontrol = VFD_DISPLAYON;
command((byte)(VFD_DISPLAYCONTROL | _displaycontrol | _cursormode | _blinkmode));
}

// Turns the underline cursor on/off
public void noCursor()
{
_cursormode = VFD_CURSOROFF;
command((byte)(VFD_DISPLAYCONTROL | _displaycontrol | _cursormode | _blinkmode));
}

public void cursor()
{
_cursormode = VFD_CURSORON;
command((byte)(VFD_DISPLAYCONTROL | _displaycontrol | _cursormode | _blinkmode));
}

// Turn on and off the blinking cursor
public void noBlink()
{
_blinkmode = VFD_BLINKOFF;
command((byte)(VFD_DISPLAYCONTROL | _displaycontrol | _cursormode | _blinkmode));
}

public void blink()
{
_blinkmode = VFD_BLINKON;
command((byte)(VFD_DISPLAYCONTROL | _displaycontrol | _cursormode | _blinkmode));
}

// These commands scroll the display without changing the RAM
public void scrollDisplayLeft()
{
command((byte)(VFD_CURSORSHIFT | VFD_DISPLAYMOVE | VFD_MOVELEFT));
}

public void scrollDisplayRight()
{
command((byte)(VFD_CURSORSHIFT | VFD_DISPLAYMOVE | VFD_MOVERIGHT));
}

// This is for text that flows Left to Right
public void leftToRight()
{
_shiftmode = VFD_ENTRYLEFT;
command((byte)(VFD_ENTRYMODESET | _shiftmode | _incrementmode));
}

// This is for text that flows Right to Left
public void rightToLeft()
{
_shiftmode = VFD_ENTRYRIGHT;
command((byte)(VFD_ENTRYMODESET | _shiftmode | _incrementmode));
}

// This will 'right justify' text from the cursor
public void autoscroll()
{
_incrementmode = VFD_ENTRYSHIFTINCREMENT;
command((byte)(VFD_ENTRYMODESET | _shiftmode | _incrementmode));
}

// This will 'left justify' text from the cursor
public void noAutoscroll()
{
_incrementmode = VFD_ENTRYSHIFTDECREMENT;
command((byte)(VFD_ENTRYMODESET | _shiftmode | _incrementmode));
}

// Allows us to fill the first 8 CGRAM locations
// with custom characters
public void createChar(byte location, byte[] charmap)
{
location &= 0x7; // we only have 8 locations 0-7
command((byte)(VFD_SETCGRAMADDR | (location << 3)));
for (int i = 0; i < 8; i++)
{
write(charmap[i]);
}
}

// spool string data to the display
public void print(string data)
{
byte[] output = System.Text.Encoding.UTF8.GetBytes(data);
for (int i = 0; i < output.Length; i++)
{
write(output[i]);
}
}

/*********** mid level commands, for sending data/cmds, init */

private void command(byte value)
{
_latchPort.Write(false);

_writeBuf[0] = VFD_SPICOMMAND;
_spi.Write(_writeBuf);
_writeBuf[0] = value;
_spi.Write(_writeBuf);

_latchPort.Write(true);

Thread.Sleep(1);

_latchPort.Write(false);

_writeBuf[0] = VFD_SPICOMMAND;
_spi.Write(_writeBuf);
_writeBuf[0] = value;
_spi.Write(_writeBuf);

_latchPort.Write(true);

Thread.Sleep(1);
}

private void write(byte value)
{
_latchPort.Write(false);

_writeBuf[0] = VFD_SPIDATA;
_spi.Write(_writeBuf);
_writeBuf[0] = value;
_spi.Write(_writeBuf);

_latchPort.Write(true);

Thread.Sleep(1);

_latchPort.Write(false);

_writeBuf[0] = VFD_SPIDATA;
_spi.Write(_writeBuf);
_writeBuf[0] = value;
_spi.Write(_writeBuf);

_latchPort.Write(true);

Thread.Sleep(1);
}

public void Dispose()
{
_spi.Dispose();
_latchPort.Dispose();
}
}
}

Kem, I like how you've made the SPI write calls a more compact. I was thinking that maybe I needed to add some time between the writes in order to get the device to understand the commands. The only thing I can think of is that the first time through we are writing to the CG Buffer and the second time we are writing to the Data Buffer which gets displayed. I'm still a bit lost on why we have to write it out two times. Nothing in the documentation give a clue. I've got a second one on the way and this time I'll put a data analyzer on it to see what is going on. Cheers

If you are planning to just keep the robot within your back yard I would think you could get away with just using a beacon style system. Ben Heck did this in one of his episodes out on element14.com where he used a couple of XBees and Ultrasonic Devices to create a Call and Ping configuration to allow his automated luggage to follow the user. The XBee on the luggage would send out a request and the target would then reply with a ultrasonic ping which would then let the Arduino calculate the distance and direction of the target. I'm pretty sure you could set up some type of similar system that would allow the robot to navigate your backyard. Since the Xbee has a short range you would probably need multiple stations to cover a good sized back yard. I'm interested to see what you come up with. Good Luck!

You need to add a reference to SecretLabs.NETMF.Hardware.AnalogInput and that should get you what you need. Hope this helps.

After checking out the sourceforge project and Mario's ModBus library, I'm thinking of replacing the web based app on my brew controller with this. Should be great for an example on how to use both together.

Hello Bryan.
Here the answers:

• no, I'm not familiar with *that* project, although we're developing our own, which is similar;
• yes, you should able to interface easily with a Netduino just leveraging my Modbus library.

Hope it helps.
Cheers

Mario,

I have a couple of questions for you about your Modbus library. Being new to the whole world of Modbus, let me give you a little background as to what I want to do with it and maybe you can steer me in the right direction.

I'd like to use it to control my Electric Brew Kettle's heating element by setting the target temperature I want to reach and then read back the current temperature and whether the element is on or off.

As for setting the target temperature and reading the current temperature and if the element is on or off, I'm thinking I could use the ReadRegisters and SetRegister methods.

I've also been working on porting over the Arduino PID Library to provide a better control algorithm and would love to be able to set the PID settings, however they are all doubles and I didn't see anything in the Modbus spec that talked about sending doubles to a device, everything looks like integer values.

Any ideas on the best way to go about setting this up?

Thanks