ATmega-Man

I have an attic full of old PC components so I'm pretty confident I will have most, if not all of the required bits'n'bobs to create my own breadboard Ethernet shield. However, I cant find a schematic to make one. Can anyone help with this? Thanks

Hi Guys, this is driving me nuts!!
I have bought an adafruit style motor shield and for some reason it seems to be suffering from a voltage drop and the L293D thats in use overheats.
Im using it with a tamiya tracked chassis and the dual motor gearbox.
The demo code I am using sends both motors through the same L293D (M3 & M4) although there are two available across 4 channels, now I think this is due to the netduinos lack of PWMs.
the code runs but the motors rapidly grind to a halt getting slower and slower, and the temp of the L293D goes through the roof.
Now i recon shifting one of the motors to the other L293D will fix the problem but I'm not sure the Netduino will let that happen due to the PWMs but as my knowledge of it is really slim im hoping im wrong.
Can anyone help me workout why this is happening and if there is an easy solution.

Im using a 6c 11.1v 5200MaH battery

Motor Shield details
Motor Shield schem
Motors (x2)

Heres the code

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

namespace MotorApp
{
    public class Program
    {
        public sealed class MotorShield
        {
            public const Cpu.Pin PWM_0A = Pins.GPIO_PIN_D6; // M4
            public const Cpu.Pin PWM_0B = Pins.GPIO_PIN_D5; // M3

            private static MotorShield _instance = new MotorShield();
            public static MotorShield Instance { get { return _instance; } }

            private OutputPort _motorLatch;
            private OutputPort _motorClock;
            private OutputPort _motorEnable;
            private OutputPort _motorData;

            internal byte LatchState = 0x00;

            private MotorShield()
            {
                _motorLatch = new OutputPort(Pins.GPIO_PIN_D12, false);
                _motorClock = new OutputPort(Pins.GPIO_PIN_D4, false);
                _motorEnable = new OutputPort(Pins.GPIO_PIN_D7, false);
                _motorData = new OutputPort(Pins.GPIO_PIN_D8, false);
            }

            internal void LatchTx()
            {
                //LATCH_PORT &= ~_BV(LATCH);
                _motorLatch.Write(false);

                //SER_PORT &= ~_BV(SER);
                _motorData.Write(false);

                for (int i = 0; i < 8; i++)
                {
                    //CLK_PORT &= ~_BV(CLK);
                    _motorClock.Write(false);

                    int mask = (1 << (7 - i));
                    if ((LatchState & mask) != 0)
                    {
                        //SER_PORT |= _BV(SER);
                        _motorData.Write(true);
                    }
                    else
                    {
                        //SER_PORT &= ~_BV(SER);
                        _motorData.Write(false);
                    }
                    //CLK_PORT |= _BV(CLK);
                    _motorClock.Write(true);
                }
                //LATCH_PORT |= _BV(LATCH);
                _motorLatch.Write(true);
            }
        }

        public sealed class DcMotor
        {
            private PWM _pwm;
            private byte _motorBitA, _motorBitB;

            public DcMotor(MotorHeaders header)
            {
                switch (header)
                {
                    case MotorHeaders.M3:
                        _motorBitA = (int)MotorBits.Motor3_A;
                        _motorBitB = (int)MotorBits.Motor3_B;
                        _pwm = new PWM(MotorShield.PWM_0B);
                        break;
                    case MotorHeaders.M4:
                        _motorBitA = (int)MotorBits.Motor4_A;
                        _motorBitB = (int)MotorBits.Motor4_B;
                        _pwm = new PWM(MotorShield.PWM_0A);
                        break;
                    default:
                        throw new InvalidOperationException("Invalid motor header specified.");
                }

                MotorShield.Instance.LatchState &= (byte)(~(1 << _motorBitA) & ~(1 << _motorBitB));
                MotorShield.Instance.LatchTx();

                _pwm.SetPulse(100, 0);
            }

            public void Run(MotorDirection dir)
            {
                switch (dir)
                {
                    case MotorDirection.Release:
                        MotorShield.Instance.LatchState &= (byte)(~(1 << _motorBitA));
                        MotorShield.Instance.LatchState &= (byte)(~(1 << _motorBitB));
                        break;
                    case MotorDirection.Forward:
                        MotorShield.Instance.LatchState |= (byte)(1 << _motorBitA);
                        MotorShield.Instance.LatchState &= (byte)(~(1 << _motorBitB));
                        break;
                    case MotorDirection.Reverse:
                        MotorShield.Instance.LatchState &= (byte)(~(1 << _motorBitA));
                        MotorShield.Instance.LatchState |= (byte)(1 << _motorBitB);
                        break;
                    default:
                        throw new InvalidOperationException("Invalid motor direction specified");
                }

                MotorShield.Instance.LatchTx();
            }

            public void SetSpeed(uint speed)
            {
                if (speed > 100)
                {
                    speed = 100;
                }

                _pwm.SetDutyCycle(speed);
            }
        }

        public enum MotorBits
        {
            Motor4_A = 0,
            Motor4_B = 6,
            Motor3_A = 5,
            Motor3_B = 7
        }

        public enum MotorDirection
        {
            Release, Forward, Reverse
        }

        public enum MotorHeaders
        {
            M3, M4
        }
        public static void Main()
        {
            DcMotor leftWheel = new DcMotor(MotorHeaders.M4);
            DcMotor rightWheel = new DcMotor(MotorHeaders.M3);

            leftWheel.SetSpeed(0);
            rightWheel.SetSpeed(0);

            leftWheel.Run(MotorDirection.Forward);
            rightWheel.Run(MotorDirection.Forward);

            leftWheel.SetSpeed(90);
            rightWheel.SetSpeed(90);

            while (true)
            {
                leftWheel.Run(MotorDirection.Reverse);
                rightWheel.Run(MotorDirection.Forward);

                Thread.Sleep(1000);

                leftWheel.Run(MotorDirection.Forward);
                rightWheel.Run(MotorDirection.Reverse);

                Thread.Sleep(1000);
            }
        }
    }
}

eternally greatful!!

Hi all, my Netduino arived from SKPang today (excelent service!) I've come from Arduino because the syntax just doesn't make any sense to me. I've come from a .net background with loads of VB.net experience and a little C#. I'm looking for some good Netduino books/tutorials/educational resources to get me started, any help would be apriciated. Thanks Adam