Most Liked Content

I am really excited about getting my Netduino Plus 2. So I thought that in order to pass the insane long wait of 2 day shipping, that I would create a pinout reference sheet. Also, I need to have these things printed and beside me at all times to help my failing memory. One community user gave me a great idea, and suggested laminating it, which I will be doing in the near future. But before I do that please let me know if you notice any errors or would like to have anything added or changed and I will do my best to update it for you.

Just in case you're wondering, the image is intentionally large, however it makes it difficult to move around using the forum's lightbox. To open the pinout zoomed out, click here: Netduino Plus 2 Pinout

If you have found it at all useful, please let me know! And as always I would love to see what your making with your Netduino Plus 2.

Edit: New pinout diagram Ver. 1.2

* Added IOREF, ADC, and Erase pad info.

Cheers,
Steve

For a few months now I have been writing a series of blog posts on using the STM8S chip with the aim that I may actually get to the point where I can show how to develop a module using the chip.  The series has been titled The Way of the Register since I had a few problems with the STD Peripheral Library produced by ST and moved on to direct register access on the chip.  Each article in the series takes a distinct task and describes how to achieve the task using the STM8S. Where possible, full project and source code for the IAR environment is included.

All of these examples use the STM8S103F3 chip.  If you are using other chips (say the STM8S Discovery Board) then you will also want to have a look at the post on Converting The Way of The Register Examples in order to work out what you will need to do in order to convert these examples.

You can find the series on The Way of the Register page.  I have covered the following topics so far:

Converting STD Library Code to use Direct Register Access on the STM8S
Going from using the STD Peripheral Library on the ST processors can be a little bewildering.  This article attempt to guide you through the process of converting you code from using the STD Peripheral library to using registers.

Simple GPIO
Toggle a single GPIO line to produce an approximate square wave signal.

Configuring the System Clock on the STM8S
Configure the system clock to use the internal HSI oscillator running at 16MHz.  Generate a square wave signal using a GPIO line and show how the frequency of the square wave can be changed by manipulating the clock divider.

External Interrupts on the STM8S
Capturing user input through a switch using the STM8S.

Using the UART on the STM8S Microcontroller
Learn how to setup and use the serial port on the STM8S to generate debug information or control serial devices.

Generating a regular signal using Timers
Here we will learn how to use one of the timers on the STM8S to generate a square wave signal.

Generating a PWM signal on the STM8S
In this article we look at generating a PWM signal using channel 1 of Timer 2 on the STM8S.

Interrupts on the STM8S
An overview of how interrupts works on the STM8S

Single Pulse Generation and Timer 1 Counting Modes
These two articles take a look at Timer 1 and show how to generate a single pulse of a known length and also suggest some modifications which can be made as a exercise to show the different counting modes available on this timer.

Single mode ADC Conversion
Setup the ADC to perform a single conversion and then use that value to control the properties of a PWM signal and hence control the brightness of the LED.

I have also converted a number of the sample programs to us not only my own reference platform but also the Variable Labs Protomodule and the STM8S Discovery boards.

STM8S SPI Slave

This post sets up SPI on the STM8S using hardware chip select.  The data exchange is restricted to single bytes.

STM8S SPI Slave (Part 2)
This post adds buffering to the SPI data exchanges and uses software controlled chip select to determine when data transfer should be started.

STM8S SPI Slave (Part 3) - Making a Netduino Go Module
Building on the previous two SPI posts, this one implements a simple GoBus comms protocol allowing module developers to create simple modules using the STM8S.

Hope that you find this useful,
Mark

Edit: Converted the headings into links to the original posts.
Edit: 8th Oct 2012 - Added details on four additional posts.
Edit: 19th Nov 2012 - Added details about two SPI posts.
Edit: 26th Nov 2012 - Add the Module post link and information.

The Ethernet part (ENC28J60) alone on the N+2 consumes 150 mA, that along with the on-board led and potentially a uSD card could contribute to quite a bit of waste.  If you plan on running your project off of a battery, you obviously want to get the power consumption down as low as you can.  I've written up a small class with a single static method, and a single enum to make the process of turning off the peripherals easy.

Usage;

//Turn off the Ethernet controller
PowerManagment.SetPeripheralState(Peripheral.Ethernet, false);
//Turn off the uSD Card
PowerManagment.SetPeripheralState(Peripheral.SDCard, false);
//Turn off the Power LED
PowerManagment.SetPeripheralState(Peripheral.PowerLED, false);

//Turn On uSD Card
PowerManagment.SetPeripheralState(Peripheral.SDCard, true);

I don't have the public source code repositories up for Variable Labs just yet, so I've attached the source below.

 PowerManagment.cs   3.13K   94 downloads

Dear Friends,

Many of you have asked for a Netduino Plus with more speed, more flash, more RAM, and more features.

Today we make that dream a reality.

Introducing Netduino Plus 2.  Just $59.95.
Netduino Plus 2 Specs
Where to Buy (resellers)

Netduino Plus 2 has four times the speed (168MHz), six times the code space (384KB), and twice the available RAM (100KB+) of Netduino Plus 1.

And we didn't just make the board faster or give it more flash and ram.  We also gave it a whole series of rich new features.

Features like four serial ports.  Six PWM channels.  And 12-bit ADC.

Features like power headers that turn on and off via code, so you can power on shields when you want to.  Pins which can drive up to 25mA of current to light LEDs.  And Arduino "R3" compatibility to support future shields (in addition to existing shields, thanks to Netduino Plus 2's 5V digital I/O tolerance).

And because there's so much room in flash, we've added OneWire and Time Server directly into the NETMF firmware.  We've left quite a bit of space for future features.  

This board is built to last, to get even more feature-rich over time.

You might notice that we swapped out the 6-pin ICSP header for a 10-pin MiniJTAG header.  The goal is to enable developers to compile their own firmware using GCC--and debug both native and managed code at the same time.  If you need the ICSP header for a shield, simply sandwich a MakerShield in the middle: it'll route the ICSP pins for you.

There are a lot of microcontroller features which we can expose through software updates.  We'll be leveraging OTP and could expose the Watchdog timer, and I know that more than a few users will want to hack away at the exposed CANBUS peripheral.

We're really excited about the new gen2 hardware (both Netduino Go and Netduino Plus 2).  They both have a long life ahead of them including even more functionality to help you realize your dream projects and commercial endeavors.

There's so much more to cover...  Please enjoy your Netduino Plus 2 boards, and let me know your questions!

Chris
Secret Labs LLC

P.S.  Commercial customers -- we're not leaving you behind.  Netduino Plus 2 is designed to be a drop-in replacement in most circumstances, and we can still make Netduino Plus 1 boards for you.

To help build and debug the new GoBus 1.5 protocol, I have created a pair of protocol analyzer plugins for use with the Saleae Logic software.  There are two versions of the analyzer: one for GoBus over asynchronous serial, and one for GoBus over SPI.

After installing the new Netduino Go firmware and Shield Base firmware released earlier today, you can use the serial analyzer to view the protocol between the Netduino Go mainboard and the Shield Base module.  Using a breakout board (for example, the GoBus Breakout Module), simply connect your logic analyzer to GoBus pins 4, 5, and GND and you'll be able to capture and view the serial GoBus traffic between the module and the mainboard. (On the GoBus Breakout Module pins 4 and 5 are labeled with the STM8 functions SWIM and NRST.)

Download: Beta 1
Includes compiled files for Windows and Mac OS X, as well as the source code for both analyzers.

Here's what the analyzer looks like:

When you zoom in you can see a few more details about each byte:

Here's what the SPI analyzer looks like. At the moment I only have sample ("fake") data to display but it should work correctly with actual GoBus SPI traffic when that is available


Installation:

Windows:

Copy the following files:

• GoBusAsyncSerial.dll
• GoBusSPI.dll

to the Logic Analyzers directory: C:\Program Files\Saleae LLC\Analyzers

If the GoBus analyzers don't show up within the Logic software, make sure you have the Microsoft Visual C++ 2010 Redistributable Package installed. This can be downloaded from: http://www.microsoft...ls.aspx?id=5555

Mac OS X

Copy the following files:

• libGoBusAsyncSerial.dylib
• libGoBusSPI.dylib

to the Logic Analyzers directory: /Applications/Logic.app/Contents/Resources/Analyzers

Right click Logic.app and select "Show Package Contents" to access the "Contents" folder.

Limitations:

• The analyzers currently only support CRC8 frames. This is due, in part, to CRC8/16 being a transport setting that is not indicated within each packet. This will be fixed in the future, either from a change in the protocol or through a setting in the analyzer.
• The SPI analyzer currently uses the Enable line to determine frame length (and therefore where the CRC byte is located) as well as where each new frame begins. This could cause issues if the Enable line is not cycled between frames.
• For both analyzers, the CRC value is only displayed and not actually verified by the analyzer.  The CRC value in simulated data is not accurate and will always be set to 0xFF.
• I haven't worked on the export function yet, these features are purely for displaying GoBus traffic at the moment.  That will be fixed later

Enjoy, and let me know what you think!

Matt

Attached are zip archives with custom Netduino, Netduino Mini, Netduino Plus, Netduino 2 and Netduino Plus 2 parts for popular prototyping tool Fritzing. The breadboard layout matches the official Rev.A boards for all variants.

Enjoy


Edit 2010-11-30: Added Netduino Mini version 1.0. Use 'variant' combo box in the Inspector window to switch among Netduino boards. You may need to restart Fritzing after import for changes to take effect.

Edit 2010-10-04: Added Netduino Plus version 1.0.

Edit 2010-09-09: Updated to version 1.1 - Corrected logo font (thanks Chris), improved pin names (alternate functions) and descriptions (max output current), added USB logo to the connector.

Edit 2012-11-24: Added Netduino Plus 2

 

Edit 2013-01-15: Added Netduino 2

heres my little playground.
it contains:
netduino mini
102x64 lcd - spi
9dof imu sensor module + barometric sensor - i2c
128kb eeprom - i2c
temerature sensor - analog
trackball connected to pcf8574 - i2c
mcp23017 - i2c
4bit 7 segment (not connected atm)
sd-card slot - spi
real time clock (drifting a lot, like 2-3 secs an hour ...) - i2c
cp2102 usb-uart bridge
ftdi usb-uart bridge
max232
one step up and one step down module for 3.3 and 5v power supply

not on the sceen: joystick and led matrix module.

soon ill add a spi master <-> spi master wireless chip (NRF24L01+)
maybe some pIR chips (but well, they work without netduino/uC also)

next month plans:
i2c camera module (to save some pictures on the sd card) - not doable
bluetooth module - i hope i can get it to programm my netduino w/o cable (!) - working
ENC28J60 network module (spi) - dont have ethernet cable right now
TEA5767 fm radio (i2c) - todo

ill make better pictures as soon as i get my hands on a real digicam, not webcam as of now


everything now is working ofc
(except the imu, need more code for them, in progress!) - imu working (at least i can read the basic values)


greetings


// edit: some video of my compass in action.
atm it sends its data per uart to pc, gets rendered there in xna

its on my old led matrix




//edit: COBS and a simple UART transport system added
// cobs is just ported from original author // damn - link is gona and i dont have it anymore

//edit multi I2c and temerature sensor code added, its a smooth sensor, change history lenght to //make it faster

 

//edit: i now hooked up my rgb matrix

its only 3bit color, but still impressive

 

https://www.youtube.com/watch?v=siBAG85j6Co

 

 

 

i also designed an app with that i can create images in color for it, its still in progress

(i klick the pixels, it shift to the next aviable color, a button to save it to a file is missing)

 

i also made a small "testbench" wich connect per uart to my netduino, and is capable of read/write register for a specified device (in that case my gyro sensor)

 

//edit: change in uart.cs its better now > it waits till it actually received the data it expects

uart class deleted for now, it has a memory leak

 

//edit: drivers for the mcp3201 added - 12 bit external adc.

also the uart bug seems to only affect stm32, have to look further into that.

 

// edit: uploaded a fixed version of realtimeclock (ds1307)

Dear Friends,

You asked for a Netduino with more speed, more flash, and more RAM.

You asked for a Netduino with more GPIOs, more serial ports, more analog inputs, and more PWMs.

Some of you aren't yet comfortable picking up a soldering iron, or you don't want to spend your time calculating resistor band colors.  You want a plug-and-play Netduino.

We've been listening.  And together with several members of the Netduino community, we've been crafting radical new hardware.

Today, we introduce a Netduino with more speed, flash, and RAM.  And a Netduino with support for more GPIOs, serial ports, analog inputs, and PWMs.  And today, we introduce a plug-and-play Netduino.

Best of all, these are all the same board.  

Introducing Netduino Go.  Just $49.95.
http://www.netduino.com/netduinogo/

Netduino Go has four times the speed (168MHz), six times the code space (384KB), and twice the available RAM (100KB+) of Netduino Plus.

And with Netduino Go, we've virtualized all the peripherals.  So you simply pick what you need and plug it in.  Each module has a small microchip which works together with the mainboard.

Want to use a relay?  Just plug it in.  Need six RGB LEDs?  No problem.  How about a touchscreen?  One cable, plug and play.

Alongside Netduino Go, we're introducing a very cool accessory.  We call it the Shield Base.  You plug it into your Netduino Go and it provides you with the latest Arduino pinout, 6 PWMs, 6 ADCs, and a handful of GPIOs.  To use it, you just create InputPorts, AnalogInputs, etc. using the standard NETMF classes.

It's like freedom, in the form of electrons.

All Netduino Go hardware is production hardware.  We're shipping the production Shield Base hardware with early beta firmware so that we can get wide feedback on this new virtualization technology.  And to say thank you for beta testing the Shield Base, we've temporarily upgraded its 128KB-flash MCU to a full-blown 512KB-flash 120MHz Cortex-M3 microcontroller.  You can connect it to power and a USB-TTL serial cable and use it as a traditional Netduino if you'd like as well--while enjoying its 3 serial ports and other new enhancements.

Both the Netduino Go and the Shield Base run production versions of .NET MF 4.2 QFE1 (RTM).

We are introducing the first six modules today (button, rgb led, potentiometer, shield base, nwazet relay, and nwazet touchscreen).  Next up are Piezo Buzzer, Ethernet, and SD Card modules--coming soon.  Several dozen modules will ship this year...and we welcome you to build your own as well.  More on that separately.

Last but not least...  Microsoft Research created a nifty technology for researchers to prototype electronic devices.  We appreciate that they open sourced their platform, called .NET Gadgeteer.  So we created a compatibility mode for Netduino Go which lets you use most S-U-X Gadgeteer modules with Netduino Go.  Bluetooth and XBee modules, Temperature+Humidity sensors, GPS modules and more are all available today.  There are some limitations--we'll create a thread to discuss and to provide drivers.

You may have some questions about the new hardware.  We will try to answer them here as best we can.  And we'll be talking more about Netduino Go and doing Q&A at next week's O'Reilly webcast.

I'm looking forward to seeing your creations using Netduino Go!

Chris
Secret Labs LLC

There are definitely some ladies who frequent the forums.  But they're vastly outnumbered by the gentlemen, so perhaps they don't speak up often (or don't disclose their gender).

[ That said, ladies...you are welcome in this community.  The guys are friendly.  And if they aren't, just let me know ]

Chris

If you want to skip the blah blah blah and only want to see something or download the schematic and source, scroll to the bottom of this article

From the moment I got my Netduino microprocessor board I was thinking, what are it's limitations, and how can I work around them? One of the most obvious limitations is the amount of Input/Output (I/O) ports. This image shows what the board is capable of.



I wanted to look a way around this limitation with quite some success. By adding multiple bitshift IC's it's possible to get virtually unlimited I/O-ports. The only limitation in this is the clock speed, but I haven't reached this limitation yet.

I've used two kinds of IC's, a serial-in/parallel-out, called 74HC595, and a parallel-in/serial-out, called 74HC165. They can be used in chains, so by adding more IC's, you won't need to use more I/O ports on the Netduino board. In my example below I got 32 I/O ports by only occupying 5 I/O's on the netduino.

The schematic is quite simple, I used buttons with pull-up resistor to represent of inputs and leds to represent outputs. The basic idea is that every added IC adds 8 Input or Output ports.
You can see it working at Youtube.



Then we get at the code part. Connecting stuff is one thing, making it work is another. The Netduino is filled with code compiled from C# and uses the .NET MicroFramework.
This framework has a couple of built-in classes, for example, OutputPort, InputPort and InterruptPort. I made copies of those built-in classes to work with the bitshift IC's, so usage would be a simple as the rest of the framework.

The only difference is that we need to define the IC setup first. So we got two input IC's and two output IC's. We define the connected chains first:

Ic74HC165Chain ChainIn = new Ic74HC165Chain(SPI_Devices.SPI1, Pins.GPIO_PIN_D10, 2);
Ic74HC595Chain ChainOut = new Ic74HC595Chain(SPI_Devices.SPI1, Pins.GPIO_PIN_D9, 2);

Both IC chains are connected to the Netduino's SPI bus (Pins 11 to 13) and use a different Chip Select-pin, in this example pins 9 and 10. Both chains contain 2 IC's.

When the chains are defined, we have to make interfaces for the IC's. This is done by this:

Ic74HC165 IcIn1 = new Ic74HC165(ChainIn, 0);
Ic74HC165 IcIn2 = new Ic74HC165(ChainIn, 1);
Ic74HC595 IcOut1 = new Ic74HC595(ChainOut, 0);
Ic74HC595 IcOut2 = new Ic74HC595(ChainOut, 1);

The enumeration starts at 0 as you can see. 0 is the first IC in the chain, 1 the second, 2 the third, etcetera.

Now we can define our Input/Output/InterruptPort classes. They have the same parameters as the regular classes except for the first one, which defines the IC it's connected to:

InterruptPortShift Button0 = new InterruptPortShift(IcIn1, Ic74HC165.Pins.GPI_PIN_D0, false, Port.ResistorMode.Disabled, Port.InterruptMode.InterruptEdgeBoth);            
OutputPortShift Led0 = new OutputPortShift(IcOut1, Ic74HC595.Pins.GPO_PIN_D0, false);

Here we defined an InterruptPort and OutputPort using bitshift registers. From this part, the code which follows is exactly the same as it would be using the onboard I/O ports.

Credits
I wouldn't have done this without the help of two very nice guys in the Netduino Community: Mario Vernari and CW2. Thanks again
The schematics are made with the free tool Fritzing. Should also be mentioned since the tool is a great help!

Download source at http://netmftoolbox.codeplex.com/

Coincidentally, I was playing with xbees the other day and made these two videos.  
One end is a FEZ Domino, the other end is a Netduino.
Not exactly a tutorial, but you may find it interesting.



You may want to watch this one on youtube to so you can read the text.

I’m not sure about you – but ever since watching the Apollo 11 mission in 1969, I’ve been obsessed with the moon.  Combine that with my obsession for cool electronic gadgets and Netduinos, and you get the following project: a Moon Phase Clock.  And what better time to post this project than during a full moon!

I thought it would be fun to make a clock that showed the current phase of the moon.  The project turned out nicely and is currently mounted on the wall of my wife’s first grade classroom.  The students are fascinated by it and refer to it often.  See Figure 1.

Operation: The shapes of the moon (i.e., the lunar phases) are caused by the light shining on the moon and the position of the Earth relative to the sun and moon throughout the lunar cycle.  For my moon, I decided to have 8 lighted segments; which allows me to depict 16 different moon phases, from a New Moon (fully dark), to a Full Moon (fully lit), and back to the New Moon again.

As described in http://www.moonconne...on_phases.phtml the synodic period, or lunation, is exactly 29.5305882 days. It's the time required for the moon to move to the same position (same phase) as seen by an observer on earth.

For my project, the 29.5305882 day synodic period is divided into 16 clock phases, each 1.8456617625 days; or 44 hours 17 minutes and 45.176 seconds; or 159465.2 seconds long.  My clock uses a counter to keep track of the time, and advances to the next phase after each 159465 second interval.

Construction: I used an old wall clock for the chassis and put a picture of the moon under the plastic front as shown in Figure 1.  The face of the clock is segmented into 8 sections, each with a pair of bright LEDs, as shown in Figure 2.

For the electronics, I used a Netduino Mini mounted on a Radio Shack circuit card.  Each of the 8 LED moon phase segments is powered by a GPIO output pin connected to an NPN transistor.  The Phase Advance switch shorts a GPIO input pin to ground to allow me to set the clock.  This is shown in Figure 3.

On startup, the software initializes its program variables, performs a simple LED test to verify that the lights work, sets the clock to a New Moon (no lights lit), and starts a counter to keep track of the time.  When the time for a phase elapses (159465 seconds, as explained above), the software advances the phase and turns the next LED segment on or off, depending on whether the moon is waxing or waning.  The user may also advance the phase by pressing the Phase Advance button.  The code is included in Attachment 1.

Moderator note:

Just a quick request to make sure we all keep things civil here.  The Netduino community is a happy (and even family friendly) place where people come to enjoy their passion and belong to a community of fellow enthusiasts.  I know that everyone means well...but we don't want Ulrik or others to feel insulted or alienated.  

Let's keep this thread limited to helping ensure that [nwazet Touch Display users get updated drivers (or a firmware update if there's a bug in the NETMF firmware) so they can continue enjoying the use of their [nwazet product.  

If we get too far off topic or insults start hurtling, one of the moderators will close the post.  We hardly ever have to moderate that way, but we need users to feel safe and know that they're appreciated here.

Chris

HHHMMMnnn That cost me around US$250 + $$(Dymo labels) total around $US300

If you don't like it then don't buy it but at least take the time to appreciate the product for what it is and the hard work that has been put in to it.

Regards,
Mark

Moderator note
This type of conversation is probably best carried on offline.  We want the forums to be a family-friendly place free of bad feelings or conversations of such a personal nature.

I have split this thread and am going to close it, at least for a while.  I'm not big on censorship, but sometimes it's good to let feelings cool.

I really appreciate all the effort that both of you puts into your projects, products, and the community.  Your words evoke that passion.  Let's see what we can all build together.

Chris

P.S. This topic has been split off and closed. If both Fabien and Arron would like the thread removed, a moderator will comply with the request.

After a year of development on my free time I'd like to present Netduino Console.

A dynamic plugin interface with a built in messaging layer for you to create control plugins that send and receive events to and from the Netduino Controller.

You can find the source code at https://netduinoconsole.codeplex.com

Linked is a quick demonstration of some of the capabilities of what the Netduino Console can do.

Feedback and questions are welcome.

Enjoy!

Hi Galibore,

Reading the table on page 2 of the data sheet, the forward current of all the LEDs is 350mA. At that current the Red LED has a voltage drop of 2.4V, Green 3.5V and Blue 3.4V.

So if you want to use a 12V supply, you need to drop quite a lot of volts!

First lets work out the minimum resistance to limit the maximum current through each LED:
Red, R = V / I = (12 - 2.4) / 0.35 = 9.6V / 0.35A = 27.42 ohms
Blue, R = V / I = (12 - 3.4) / 0.35 = 8.6V / 0.35A = 24.57 ohms
Green, R = V / I = (12 - 3.5) / 0.35 = 8.5V / 0.35A = 24.28 ohms

The resistors are going to have to be quite powerful. Typical small wire resistors are only good for 1/4 Watt. The above numbers give the power in each resistor as:
Red, P = V x I = 9.6 x 0.35 = 3.36 Watts
Blue, P = V x I = 8.6 x 0.35 = 3.01 Watts
Green, P = V x I = 8.5 x 0.35 = 2.975 Watts

That's a lot of power to turn into heat! You will need to find suitable high power resistors to cope.

Next we need to add a variable resistor (potentiometer) in series with each of the fixed resistors.
Each variable resistor should go from zero to ? ohms to reduce the current below 350mA.

Looking at the forward current versus forward voltage curves on page 4 of the data sheet, the forward voltage curves stop at about 25mA. So lets say the minimum current should be 25mA.
For the Red, the curve shows about 2V at 25mA. This gives R_total = V / I = (12 - 2) / 0.025 = 400 ohms. R_variable = 400 - 27.4 = 372 ohms.
For the Blue, the curve shows about 2.375V at 25mA. This gives R_total = V / I = (12 - 2.375) / 0.025 = 385 ohms. R_variable = 385 - 24.57 = 360 ohms.
For the Green, the curve shows about 2.325V at 25mA. This gives R_total = V / I = (12 - 2.325) / 0.025 = 387 ohms. R_variable = 387 - 24.28 = 363 ohms.

At the lowest current the power in the variable resistors will be P = I² x R
Red P = 0.025 x 0.025 x 372 = 0.23 Watts
Blue P = 0.025 x 0.025 x 360 = 0.225 Watts
Green P = 0.025 x 0.025 x 387 = 0.24 Watts

When the resistance is reduced more current will flow and the power in the variable resistor will increase. Its a curve relationship, so I can't do the calculation in my head. But you get the idea, its more power than a cheap variable resistor will want to handle.

First thing I would do, is use a lower power supply voltage. With 5V the fixed resistors are going to need to be about 1 Watt each rather than 3 Watts - this is more manageable.
Then look for some high power variable resistors.

Hope this helps - this is why we use PWM to drive high current loads.

Paul

Hi guys,

I have attached an article for beginners that will include step by step introduction to Netduino with basic circuit design and programming examples.

I am expecting your comments and suggestions, thank you in advance.

Updates
23/04/2011 - v1.1 Initial draft.
28/04/2011 - v1.2 Updated file with quick code example and some future content outline.
02/05/2011 - v1.3 Transistor parameters table and few more explanatory text. Future content outline.
10/05/2011 - v1.4 Transistor operation modes explained. Typical logical switch modes illustrated. Edited and simplified calculation section.Programming example explanations added
17/05/2011 - v1.5 Added second project chapter. Schematics and diagrams has new style. Code highlighting. LED flash code examples attached.
29/05/2011 - v1.6 Fixed link to BC547 datasheet. Breadboard schematics and exercises. "Become ECO friendly" chapter and code examples. Minor other changes
25/06/2011 - v 1.7 Added long expected chapter "Solving problem with LED becoming ON when Netduino boots". New chapter "Better multithreading". Changed the name and format of the tutorial and included TOC. Started new chapter "Basic introduction to electronics principles and components"  for absolute beginners (only outline for now).
20/08/2011 - v1.8 Fixed calculations and improved explanations for PNP switch. Tutorial was reviewed technically and language and style was Improved too. Outlined some more future content.
15/10/2011 - v1.9 Included second approach for "Solving problem with LED becoming ON when Netduino boots" using SCR thyristor instead of relay. Included some preliminary content of the "Introduction to electronic principles and components".

19/12/2011 v1.10 From now on, due to a 2MB file size limit on the forum I'll publish the tutorial on my blog here. You can download the file and code from the "box" section on the right side. Downloads are available also from Netduino wiki page.

27/02/2012 v1.11 Get it from my blog (download the file and code from the "box" section on the right side). Downloads are available also from Netduino wiki page and accessible for online reading here .


NOTE: Following files are from old v1.9 of the tutorial!

Lately I've been back working on my Blog Site and wanted to add some Netduino topics on there.  So I decided to build a Netduino Tutorials Section and start doing some articles on various Netduino topics.

 

I am planning to target these more towards the Netduino 2 and Netduino 2 Plus as these are what I more commonly work with.  I know new Netduino users and Forum member are always looking to learn and looking to find tutorials on certain topics.

 

I've started a list of some of the topics I am going to cover.  They are broken down into Beginner, Intermediate and Advanced tutorials.  I've listed a few to start.  Not all of them are written yet but I will be writing them and releasing them over time.

 

Please take a look at my topics and my Netduino 2 Tutorial page and feel free to post up any tutorials you may want to see.  If it is something I have the knowledge of and can do a tutorial I will gladly add it to the list and work on it.

 

My hope is to have a small resource that I can give back to the community for all the help they provided getting me off the ground.

 

Here is the link to my main Tutorials Page http://www.davevande...ino-2-tutorials

Below is the list of tutorials I am planning to cover thus far.  Those with hyperlinks are currently posted.
 

Beginner

• Updating your Firmware
• Creating a Project in Visual Studio
• How to blink an LED
• How to use Buttons
• Reading from an Analog Pin
• Basic PWM (Pulse Width Modulation) Output

Intermediate

• Reading a Button Matrix

Advanced

• Dynamically Loading Assemblies

 

Hi All

 

I'm in the middle stages of getting a GoBus module put together for one MIDI input and 3 MIDI outputs.

 

The intent is for this to be a great board for creating your own MIDI controllers, arpeggiators, sequencers, and interfaces.

 

I don't have any code for this written (I've written both native and managed MIDI libraries in the past, however, including one for .NET Gadgeteer, so I have quite a bit of experience there), but I expect to have at least the following features:

• Splitting/Routing MIDI in to Any of the outs based on different rules (message type, channel, etc.). This includes soft-thru without the messages having to be processed by your C#/VB code.
• Generating a 24ppqn clock pulse on the CLK corresponding to incoming MIDI clock messages (this is useful for some other modules I'm working on).
• Automatic responding to active sense messages from within module code (you can switch this on/off)
• On-module filtering by different rules (message type, channel, etc.). This is especially helpful to avoid spamming the relatively slow NETMF side with clock messages or, if you don't want them, pitch bend and other continuous controller stuff.
• A message-based API for NETMF allowing you to respond to incoming messages from MIDI.IN.1
• A message-based API for NETMF allowing you to send messages out through any combination of MIDI.OUT ports
• Automatic message assembly on-module before they are sent to your code. This greatly simplifies the NETMF code as it doesn't have to worry about interrupted or partial messages.

In general, all the time-critical functions and filtering happen in native code on the module, and rather than expose virtualized UARTs, I'm going with the stream protocol. This will help eliminate the lag issues I had with my other MIDI module.

 

Attached is the current layout. I had it ready to send to production until Chris talked me into putting a crystal on board, and dealing with startup power, so now it's a mess and isn't properly routed. You get the idea, though.

 

Here's the image from yesterday, routed, without crystal. U2 is a new component I'm testing to replace 6n138 opto isolation for MIDI. It's much smaller and much faster. It's typically used for USB isolation, as I understand it. If it doesn't work, I'll go with a 6n138/6n137, despite their large DIP-8 size.

 

 

I don't have a release date or pricing for this board yet. It's the first of a group of related modules which could be used together to produce some pretty cool music-related devices.

 

On-board processor is a STM32F205, plenty powerful enough for quite a bit of on-module processing.

 

I'm trying to wrap up the board this week so I can send it off for prototype manufacturing before I head to India on the 15th. If you have requests related to this board (or other related modules), let me know.

 

Pete