Is there an equivalent to Config in netMF?

Chris,
Thank you for this. I think this will help a great deal in the cases where near realtime is necessary. I know this requires alot of work to integrate and glad your team are doing it. I would really hope that the NETMF team will take you and GHI's lead as far as providing interops and push it into NETMF. I love managed code and will always write in it when i can, even when knowing i am sacrificing speed for elegance, but given my recent project DotCopter.NET there is no way it can all be done in managed. So in an appeal to the NETMF team, to avoid further fragmentation, they need to pull this into the framework for the cases where its a last resort.

Again, thank you for your efforts Chris.
Brandon

I think i ran into a brick wall here, which .NET 4.0 project in the sdk loads up assemblies based in NETMF 4.0? Here's the error i get, i dont necessarily want to emulate hardware i merely want to use some of its assemblies I will always get the error ECall methods must be packaged into a system module I have successfully run test before that called simple classes but the call i am making from a form app to netmf dll is using Spot.Hardware which I cant see how to load that in

I actually have got Nunit to work on some simple tests but maybe thats because the classes were so simple

I have a windows app that i want to be able to call some of the methods of netmf assemblies, is this at all possible? is there a way for an emulator to take over to be able to load those objects

if you could dig up when in front of computer cause thus far my search has revealed nothing

great job JBW, PM me when you get a chance

https://code.google.com/p/quadnet/

http://www.engadget....nType=wl-gadget

Magoocas, I didnt realize that video was you!!!! With a little bit of work you could fly with the code i've updated and a little bit of messing around with the source. I would love to see it run!

I am not a DDD expert but i try to use their methodologies

Yes i pm'ed you the credentials, let me give you your own Harness for your implementation will call it Quad.Net.FeziQuad.Implementation, dont think it'll fly right off bat there's a few things that might still need to be done, you've used some fairly specific esc implemntations and mine use some assumptions that i dont know yet, but not much will PM once i've committed with changes. Chris at this point i'm not sure the hz range i've seen has varied between 250 and 1000 level i've seen is, once i get some hardware in i can be more specific, I'll defer to Chris and Luke on this one

all of them have great reviews, i may be following your lead here. frame wise i am still uncertain i might be going full on here and get one of these guys http://www.maximus-r...fr/maxicopters/

I have updated and made a very quick implementation of the hardware you have, there may be a few bugs in there but not bad for 10 mins work, your startup project is Quad.Net.FlightController.Implementations.FeziQuad

well after checking out the feziQuad i took all their code and implemented it in my framework, main control loop, PID, obviously not testing with hardware and have no test coverage yet but its fairly slick if i do say so myself, it has his implementation of PID minus the windup, want to understand its implications first, i have not implemented his gyro, esc, or radio yet either. If we got in touch with Cummings, we could test this

If i get hardware and some skills with soddering i could be up and running right now, I cleaned up alot of his code as well

Magoocas, its in source control

Here's an entry point to give u an idea

using Quad.Net.Commons.Configuration;
using Quad.Net.ElectricSpeedController;
using Quad.Net.Framework.Implementations.SecretLabs.PulseWidthModulation;
using Quad.Net.Framework.PulseWidthModulation;
using Quad.Net.Hardware.ElectricSpeedController;
using Quad.Net.Hardware.Gyro;
using Quad.Net.Hardware.Implementations.ElectricSpeedController.Implementations;
using Quad.Net.Hardware.Implementations.Gyro;
using Quad.Net.Hardware.Implementations.Radio;
using Quad.Net.Hardware.Implementations.SecretLabs.Pin;
using Quad.Net.Hardware.Pin;
using Quad.Net.Hardware.Radio;
using SecretLabs.NETMF.Hardware.Netduino;

namespace Quad.Net.FlightController.Implementations.Netduino
{
    public class Program
    {
        public static void Main()
        {
            IConfiguration settings = GetStaticSettings();

            //Assumes one type of speed controller on quad
            ISpeedControllerSettings speedControllerSettings = new HobbyKingSs2530Settings();
            
            ICpuPin pinFrontESC = new CpuPin(Pins.GPIO_PIN_D9);
            IPWM pwmFront = new SecretLabsPWM(pinFrontESC);
            SpeedController electricSpeedControllerFront = new SpeedController(speedControllerSettings, pwmFront);

            ICpuPin pinRearESC = new CpuPin(Pins.GPIO_PIN_D8);
            IPWM pwmRear = new SecretLabsPWM(pinRearESC);
            SpeedController electricSpeedControllerRear = new SpeedController(speedControllerSettings, pwmRear);

            ICpuPin pinRightESC = new CpuPin(Pins.GPIO_PIN_D7);
            IPWM pwmRight = new SecretLabsPWM(pinRightESC);
            SpeedController electricSpeedControllerRight = new SpeedController(speedControllerSettings, pwmRight);

            ICpuPin pinLeftESC = new CpuPin(Pins.GPIO_PIN_D6);
            IPWM pwmLeft = new SecretLabsPWM(pinLeftESC);
            SpeedController electricSpeedControllerLeft = new SpeedController(speedControllerSettings, pwmLeft);


            Motors motors= new Motors(electricSpeedControllerFront,electricSpeedControllerRear,electricSpeedControllerRight,electricSpeedControllerLeft);
           

            AxesController axesController = new AxesController(settings);
            IGyro gyro = new DefaultGyro();
            IRadio radio = new DefaultRadio();
            ControllerLoopSettings loopSettings = new ControllerLoopSettings(settings);
            Controller controller = new Controller(motors, axesController, gyro, radio, loopSettings);
                      

        }

        private static IConfiguration GetStaticSettings()
        {
            InMemoryConfiguration config = new InMemoryConfiguration();
            config["PitchDerivativeGain"] = "-.5";
            config["PitchItegralGain"] = "0";
            config["PitchProportionalGain"] = "1.2";

            config["RollDerivativeGain"] = "-.5";
            config["RollItegralGain"] = "0";
            config["RollProportionalGain"] = "1.2";

            config["YawDerivativeGain"] = "0";
            config["YawItegralGain"] = "0";
            config["YawProportionalGain"] = "3";

            config["RadioLoopFrequency"] = "25";
            config["SensorLoopFrequency"] = "300";
            config["MotorLoopFrequency"] = "300";
            config["LoopUnit"] = "2";

            return config;

        }
    }
}

Chris, that is exactly what we are looking for, if it were possible to get a faster line to the handlers send in delegates of our own to those handlers and was wrapped in a nice library i think we'd be laughing with a fast enough hz to do anything that can be done in arduino, therein lies the bottleneck, like i said there are ways around GC. I did some more research on F# the other day and saw how people have fooled the compiler to use VB and have found a way to do it in F# but for purposes of simplicity within this project i've decided to use C# and when i get to optimizing (if need be) might switch out some of the loops for F3 for speed.
Magoocas,
I am impressed, i think we found our starting point and might want to involve Luke in what we are trying to do. if you've looked at source control you can see the implementational way in which im approaching.
We have
the Quad.Net solution with:
Framework (contains interfaces like IPWM)
Framwork.Implementations.SecretLabs (implementations like SecretLabs.NETMF.Hardware.PWM)
This allows for us to swap out framework specific implementations, ie using fez's custom framework
Hardware (contains generic interfaces for things like motors, gyros and escs)
Hardware.Implementations (implemntations of hardware like HobbyKings ss2530 ESC)
Hardware.Implementations.Secretlabs (implementations for things specific to netduino board, things like Pins)
Quad.Net.FlightController (main entry point but in the form of interfaces, requires an implemntation, like fez or netduino)
Quad.Net.FlightController.Netduino (specific implementation of netduino board and its settings)

Example of Netduino Implemntation with a speedcontroller

using System.Threading;
using Quad.Net.ElectricSpeedController;
using Quad.Net.Framework.Implementations.SecretLabs.PulseWidthModulation;
using Quad.Net.Framework.PulseWidthModulation;
using Quad.Net.Hardware.ElectricSpeedController;
using Quad.Net.Hardware.Implementations.ElectricSpeedController.Implementations;
using Quad.Net.Hardware.Implementations.SecretLabs.Pin;
using Quad.Net.Hardware.Pin;
using SecretLabs.NETMF.Hardware.Netduino;

namespace Quad.Net.FlightController.Implementations.Netduino
{
    public class Program
    {
        public static void Main()
        {
            ICpuPin pin = new CpuPin(Pins.GPIO_PIN_D9);
            ISpeedControllerSettings electricSpeedControllerSettings = new HobbyKingSs2530Settings(pin);
            IPWM pwm = new SecretLabsPWM(pin);
            Controller controller = new Controller(electricSpeedControllerSettings,pwm);

            for (int i = 0; i <= 100; i++)
            {
                controller.ElectricSpeedController.SetThrottle(i);
                Thread.Sleep(50);
            }
        }

    }
}

What i have tried to accomplish with this is a framework where any contributor can swap out hardware, gyros or microcontroller that supports netmf and specific implementations of framework, fez vs secretlabs

What i'm hoping will happen is a user can throw a new esc in, implement an ESC interface specific to that esc, and fly 5 minutes later, or a board or a gyro or eventually other sensors, if we keep this generic enough we could add features and hardware very quickly and segregate the project in a more agile framework than what is being done in other projects as well as allow for various combinations of hardware software with little or no effort. Everyone else code that i have veiwed ha been scary dependent on hardware or assumptions and thus why the project falls down

Magoocas, Fellow Canuck. The aeroquad software is pretty good. I've looked through a few of their classes and they've done agreat job with some of the avionics and physics concepts. A big part of what i am trying to accomplish in this project is a nice domain of those concepts, they seem to have mashed them together quite a bit, I come from DDD and want to apply that technique here. A port would be great and we can just try and organize it better. I have been inundated with my day job and my own $ making projects the last 2 weeks, but I'm about to order all my parts and start with the three gyro concept which will be just the stab part, not the full 9 degrees of freedom concepts. I will PM you for SVN repository

just looked at the source there for feziquad, is that the one that you have flying in that video????? the code is very simple and I like how its organized, I like alot of things in there. If thats the one thats flying i am impressed

that video when posted on engadget is what got me really interested. there's some guys at MIT doing some cool stuff too. The one i found a lil crazy was the one that had the kinect hardware attached for object detection, which i think can be done alot simpler with less weight but still a neat concept

Whoa a month, i guess i need to stop procrastinating......

heres my ideas hardware wise, would like some opinions, you mentioned using a better BEC, so I have taken it off the list open for your suggestions, keeping in mind i am trying to be very modular is the reason for the component shield

Motor	6	 $6.00 	 $36.00 	http://www.hobbyking.com/hobbycity/store/uh_viewItem.asp?idProduct=5354&aff=104834
ESC	6	 $9.23 	 $55.38 	http://www.hobbyking.com/hobbycity/store/uh_viewItem.asp?idProduct=6458&Product_Name=Hobbyking_SS_Series_25-30A_ESC_%28card_programmable%29&aff=104834
Props	8	 $4.00 	 $32.00 	https://www.mikrocontroller.com/index.php?main_page=product_info&cPath=75&products_id=256&zenid=43fb24fa5fbee9bca99cea5ee6462e48
Battery	3	 $19.00 	 $57.00 	http://hobbycity.com/hobbyking/store/uh_viewItem.asp?idProduct=7634
Battery Charger	1	 $25.00 	 $25.00 	http://www.hobbyking.com/hobbyking/store/uh_viewitem.asp?idproduct=2055 
Frame	1	 $90.00 	 $90.00 	http://quadframe.com/html/quad002.html
RC Transmitter	1	 $60.00 	 $60.00 	http://hobbyking.com/hobbyking/store/uh_viewItem.asp?idProduct=8992
ITG3200/ADXL345	1	 $65.00 	 $65.00 	http://www.sparkfun.com/products/10321
Component Shield	1	 $22.00 	 $22.00 	http://www.robotshop.ca/ghi-component-shield-v2.html
JST Sensor Cable	20	 $1.76 	 $35.20 	http://www.robotshop.ca/inex-jst3aa-sensor-cable.html

Hi Chris, Take a checkout of ours and tell me if you want to merge a bit where you think necessary, it looks like we're a bit further and if you have any experience writing control loops or quad code, the more help the better

lol, guess i responded too quickly, thank you for your suggestions

the esc code is depricated, we dont use it, the starting point is from the fez panda implementation right now. If logging is taken out ie(send in a null logger, or take out the write from the control loop) we have no GC hit at all given everything is declared up front, the telemetry data is for debugging. just because its abstract doesnt mean its heavy, it means its flexible. we have maxed out at 500hz, the config allows you to set the hz for each update whenever you want within the loop, you can set your imu, your radio and pid hz, we are still finding out what is the optimal times to run each

basically you read from one 3 axis gyro or 3 one axis gyro and from a 4 channel reciever and four escs which will be controlled via PWM

below is the simple data used by the reciever and gyro(s)

namespace Quad.Net.Avionics
{
    public class AircraftPrincipalAxes
    {
        /// <summary>
        /// http://en.wikipedia.org/wiki/Aircraft_principal_axes
        /// </summary>
        private int _pitchAngle;
        private int _rollAngle;
        private int _yawAngle;

        public AircraftPrincipalAxes(int pitchAngle, int rollAngle, int yawAngle)
        {
            _pitchAngle = pitchAngle;
            _rollAngle = rollAngle;
            _yawAngle = yawAngle;
        }

        public int PitchAngle
        {
            get { return _pitchAngle; }
        }

        public int RollAngle
        {
            get { return _rollAngle; }
        }

        public int YawAngle
        {
            get { return _yawAngle; }
        }

    }
}

using Quad.Net.Avionics;

namespace Quad.Net.Hardware.Radio
{
    public interface IRadio
    {
        int Throttle { get; }
        AircraftPrincipalAxes GetAxes();
    }
}

using Quad.Net.Avionics;

namespace Quad.Net.Hardware.Gyro
{
    public interface IGyro
    {
        AircraftPrincipalAxes GetReading();
    }
}

these classes would be tied to the events coming off those 6 or 8(gyro implementation specific) pieces of hardware and updating their values within the control loop

you beat me to it Chris, thanks.

As chris said there are a bunch of IMU's that cacn calculate speed, angle acceleration, but the simnplest is to start with a 3 axis gyro and then the aim is to get more complicated later, eventually implementing 5-9 degrees of freedom

Yea when i implemented your code i realzied I did that in my implementation, it can be remedied with a quick change to the control loop by calling the old update method explicitly and an alter of the GetReading() method not to call the update. I did a very quick and dirty with your implementation just as show of the style, the returning new AircraftPrinciplaAxes(...) each time is not efficient and can be remedied quick, but i didnt go into specifics there. If you make the change to the update and the return objects of AircraftPrinciplaAxes being held in memory and updating constantly GC will be exacctly what it s was in your old implementation