Thank you for visiting my weblog... ;-)

http://ecrafts.g.hat...e.jp/Lynx-EyED/

Hi lynxeyed_atsu,

Very cool that you are here too. It looks like lot of people in Japan are excited about netduino (or maybe with .NET Micro Framework in general?). Due to language barier it's hard for me to keep up with what you are doing. Hope you could give us some updates on cool project you are working on.

Hi, I have published article on my blog that shows how to use shift registers to extend number of digital output pins on Netduino. In particular I demonstrate how to use it to control a 7-segment display or any other LED components. In two examples I show how to display values from potentiometer and SHT15 temperatuer & humidity sensor. Here is the blog post: http://geekswithblog...nking_leds.aspx I also made a short video to show how this works: You can download the source code here: http://cid-4c7ec0c21...s^_20100822.zip Please let me know if you like it or not, and if you would like to see more projects like this from me.

Szymon

Waiting for that, will help me a lot

Thanks

segu

I have published the article on my blog: http://forums.netdui...-blinking-leds/

Now I will look into writing the driver for one-wire DS18B20 sensor.

What potentiometer are you using?

10K

Do you know the part/model # or where I could buy one? It's nice!

It's just regular potentiomater that I got from a local hobby electronics store in my town.
Looks exactly like this one: http://www.oreind.co...products_id=859

I only put a platics knob on it :-)

I'm pretty new at this, but am wondering whether this board could be used to run the Mendel REPRAP machine? I mean, would it simply be a case of recompiling the Java code they provide, or would it need to be re-written from scratch?

I just found that there is a new RepRap G5 Mini Shield posted on http://www.thingiverse.com/thing:3863
It is specially designed to work with ARM boards, such like Netduino, FEZ domino, Maple Leaf and etc.
So I think that would take care of the hardware side.

On the software front I also found that the RepRap firmware is written so that it can be compiled by GNU GCC compiler:
http://reprap.org/wiki/General_FAQ

So I think instead of rewriting it in .NET Micro Framework, the easiest route would be to compile it natively and reflash the board. Don't get me wrong, I love the idea of RepRap.NET too, but .NET MF is not designed for real-time devices so I'm afraid it wouldn't work in this scenario. But I still hope someone else will shortly prove I was wrong.

Since .NET MF allows interop with native code, this is definitely possible using a mix of native C++ and managed C# code. Maybe managed C# code alone.

100% Native C++ code on the Netduino is definitely possible as well.

Chris,
It sounds very tempting to give it a try, and besides I wanted a MakerBot for some time alredy... but maybe I should finish some other projects first :-)

Moving this discussion from the main forum. I think the bigest benefit for RepRap would be to use Netduino Plus. With network connection it could work just like a regular printer. And the SD card would be used as a print buffer, so one could send the whole print job, and turn off the computer (3D printers are still quite slow). Indeed this sounds as a very exciting thing to do. Hopefuly some people in Japan are already working on this (the shield was designed by Kenzo Yoshida).

That's a fantastic idea.

Do you think it would make sense to use the USB port on the regular Netduino to make a RepRap type of device which could be printed via USB as well?

Yes, I think this might work too. But I think Ethernet+SC card combo would make it more interesting. I will try to digg why people are looking to use ARM boards for RepRap in general. Maybe Arduino has other limitations they want to solve this way.

Hi, I received the adafruit's arduino enclosure today. Netduino fits nicely inside but of course I will have to make a new hole if I wanted to plug USB from outside. Also because the power plug dosn't stick out as much as on arduino there is a little gap between the bottomplate. Here you can see few photos of it: http://cid-4c7ec0c21...e.aspx/Netduino Overall the board looks good. I will try to connect the LCD and figure out how to add the buttons (probably will use switch buttons on the proto shield).

As the topic states, what prototype shield would you recommend?

Yesterday I received bunch of these shields ordered from Adafruit:
http://www.adafruit....&products_id=51
http://www.adafruit....products_id=187

Haven't tried them yet with Netduino, but I had used the first one in past with Arduino and I think its very well designed. Especially if you plan to test some ICs than it has a dedicated pads for it (up to 20 pins). You also get two LEDs and general use button. Important to note that reset button is brought up so it's not obscured by the shield. Important to note that board is double-sided so you can solder on both sides.

If you don't need the extra components you can order just the PCB for half the price:
http://www.adafruit....&products_id=55
But you also need the headers http://www.adafruit....&products_id=85
Or if you don't plant to stack shields simple break-away headers like this (you can cut them easily to proper length):
http://www.sparkfun....products_id=116

The other shield is just regular single-sided prototyping surface but you get lots of free space.

Chris, The project looks super cool! Please keep posting about your progress. I'm busy now with some other things but would like to follow along and build one later too.

That would be realy cool. Would even do greater distances and could use a switch for connecting them..

In the meantime I recommend reading the "Making Things Talk" book that dicusses many other communication technologies.
http://oreilly.com/c...g/9780596510510

Maybe it will give you some ideas. In any case let us know what you came up with.

I have update schematics on my blog. It looks great! Thanks for great work. http://geekswithblog...nking_leds.aspx

Hi, Last couple of days I was trying to write drivers for the DS18B20 one-wire temperature sensor. I converted the code from arduino library found here: http://milesburton.c...Control_Library Since it relies on one-wire protocol I also tried to convert the OneWire arduino library. The latest version is here: http://www.pjrc.com/...bs_OneWire.html Unfortunatelly I couldn't get it to work using managed ports (I used a TristatePort for data pin). I first confirmed my setup is correct by connecting the sensor to Arduino. It works fine there. I think the problem again is the correct timing. I don't have an osciloscope so I can't confirm this, but since one-wire doesn't even use a clock pin it has to rely on tight timings. As explained on http://en.wikipedia.org/wiki/1-Wire to transmit logical "0" master needs to send short 1-15 µs pulse. To send "1" the pulse should be 60 µs. The arduino code implements direct write through registers and microsecond delays. I don't think we can achieve this timing accuracy in managed code as was already observed by Pavel Bánský http://bansky.net/bl...k/comments.html However guys from GHI have included one-wire support in their firmware. So I run the same code for the temperature sensor on FEZ Mini board (but using their OneWire library instead) and this time it works perfectly. Chris Seto implemented it on FEZ a while ago as well http://files.chrisseto.com/8DC So I'm afraid that to interface with this type of devices we would need native support in the netduino firmware. It doesn't look very complex so I hope it could be added quickly. EDIT: I submited change proposal to the .NET MF team http://www.netmf.com...bf-3e8d70abfffb

Here is my delay microseconds method:

        private const long TicksPerMicrosecond = TimeSpan.TicksPerMillisecond/1000;

        private static void DelayMicroseconds(int microSeconds)
        {
            long stopTicks = Utility.GetMachineTime().Ticks + 
                (microSeconds * TicksPerMicrosecond);

            while (Utility.GetMachineTime().Ticks < stopTicks) { }
        }

With my oscilloscope I see that the period is 115.28 uS. So it take 115.28 / 2 = 57.64 uS to change Digital Port state. To slow for OneWire communication.

Hi Pascal,
Great that you confirmed this with the oscilloscope. I tried this myself and came to the same conlusion like you and Pavel. See here http://forums.netdui...ntation-needed/

@Segu,
I'm afraid that right now if you want to use any OneWire devices you will have to use FEZ boards.

The wikipedia article on 1-wire talks about bridge chips. http://en.wikipedia.org/wiki/1-Wire
For example I found this one DS2482-800 that works over I2C. This might be a viable short term solution.

The same article also mentions that UART ports could be used:

If a parallel port is inconvenient or the operating system interferes with the timing, a UART running at 100 kbit/s with a few resistors and special software can produce and sense acceptable 1-wire pulses.

Does anyone you know how to make this work?

Just thought of something else I'd love to see - a couple of power pins for the netduino itself. I'd like to be able to power it with LiPo batteries using a JST connector, but just a a couple of power input pins I can work with.

(no, I don't want to have to hook a barrel connector up to the battery if possible).

If I understand you are thinking about something like with Arduino Pro?
http://www.sparkfun....roducts_id=9221

And similar with Arduino Fio (it even has LiPo charger built-in):
http://www.sparkfun....roducts_id=9712

Thats great news! Let me know if I can help with testing or anything.

I'm using Dig Pin5 for DS, Dig Pin6 as Data, Pin7 as latch and reading values from Q0 on Pin0 and Q1 on Pin1.

You should be using the SecretLabs.NETMF.Hardware.Netduino.Pins enumeration instead of Cpu.Pin. This will ensure correct mapping from hardware specific pin numbers to internal numbers. For example Netduino.Pins.GPIO_PIN_D5 true value is 51. So in your case you should change these lines:

            OutputPort DS = new OutputPort(SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D5, false); 
            OutputPort StoreData = new OutputPort(SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D6, false); 
            OutputPort Latch = new OutputPort(SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D7, true); 
 
            InputPort Read1 = new InputPort(SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D0, false, Port.ResistorMode.Disabled); 
            InputPort Read2 = new InputPort(SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D1, false, Port.ResistorMode.Disabled); 

I hope this helps.

Here is a simple Shifter test class extracted from my project:

using System;
using System.Threading;
using Microsoft.SPOT.Hardware;

namespace ShiftRegisterTest
{
    public class Program
    {
        private static Cpu.Pin latchPin     = SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D7;
        private static Cpu.Pin clockPin     = SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D6;
        private static Cpu.Pin dataPin      = SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D5;

        public static void Main()
        {
            var shifter = new Shifter(latchPin, clockPin, dataPin);

            byte value = 0;
            while (true)
            {
/*
                // blink all LEDs
                shifter.Write(255);
                Thread.Sleep(200);
                shifter.Write(0);
                Thread.Sleep(200);
*/
                // blink single LED
                shifter.Write(value);
                value = (byte)(value << 1);
                if (value == 0) value = 1;
                Thread.Sleep(200);
            }
        }
    }

    public class Shifter : IDisposable
    {
        private readonly OutputPort _latchPort;
        private readonly OutputPort _clockPort;
        private readonly OutputPort _dataPort;

        public Shifter(Cpu.Pin latchPin, Cpu.Pin clockPin, Cpu.Pin dataPin)
        {
            _latchPort = new OutputPort(latchPin, false);
            _clockPort = new OutputPort(clockPin, false);
            _dataPort = new OutputPort(dataPin, false);
        }

        public void Dispose()
        {
            _latchPort.Dispose();
            _clockPort.Dispose();
            _dataPort.Dispose();
        }

        public void Write(params byte[] buffer)
        {
            // Ground latchPin and hold low for as long as you are transmitting
            _latchPort.Write(false);

            for (int i = 0; i < buffer.Length; i++)
            {
                ShiftOut(buffer[i]);
            }

            // Return the latch pin high to signal chip that it 
            // no longer needs to listen for information
            _latchPort.Write(true);
            _latchPort.Write(false);
        }

        private void ShiftOut(byte value)
        {
            _clockPort.Write(false);

            for (int i = 0; i < 8; i++)
            {
                byte mask = (byte)(1 << i);
                _dataPort.Write((value & mask) != 0);

                // Raise Clock
                _clockPort.Write(true);

                // Raise Data to prevent IO conflict 
                _dataPort.Write(true);

                // Lower Clock
                _clockPort.Write(false);
            }
        }
    }
}

The processor itself is surely fast enough for 1-Wire, at this time the problem is with native (C++) code generated by GCC, but it works.

It works on Arduino so it would be weird if Netduino's much superior CPU couldn't handle it :-)

If you can afford it, I suggest the Rigol DS1052E. It has the bandwidth and sampling rate needed for most microcontroller project.

There was some hack to double the sampling rate to 100Mhz (but it no longer works with new firmware)
http://www.eevblog.c...100mhz-ds1102e/

I found it on http://www.dealextre...ls.dx/sku.30573

But what you think about this one? http://www.dealextre...ls.dx/sku.36153

If you are just going to look at digital signals, you can consider USB logic analyzer. There are a few companies that makes them.

I was thinking to buy this one http://www.saleae.com/logic/features/. Is it good enough?

Are there any others I should look into? I'm on the Windows platform, BTW.

Did you look at Fritzing? It's what I use to document schematics for my projects.
And CW2 already created Fritzing part for Netduino.