
Meadow F7 micro board on pre-sale (bare metal .NET Standard 2.0) - pjmlp
https://store.wildernesslabs.co/
======
tasogare
The Kickstart page is way more informative:
[https://www.kickstarter.com/projects/meadow/meadow-full-
stac...](https://www.kickstarter.com/projects/meadow/meadow-full-stack-net-
standard-iot-platform/)

~~~
bryancostanich
Thanks! We're in the middle of a big website refresh with more information.

Also, you can find the new developer site here: [http://beta-
developer.wildernesslabs.co/](http://beta-developer.wildernesslabs.co/), which
has the Meadow docs. We haven't pushed it to the main site yet because we're
still missing a home page design. :)

------
snops
The Dotnet Micro Framework appears to be no longer developed by microsoft,
with the official repository being archived [1]. However the Nanoframework[2]
fork appears to be alive. Does anyone know which one this project is using?
It's unclear from both the OP and the Kickstarter link as well.

[1] [https://github.com/NETMF/netmf-
interpreter](https://github.com/NETMF/netmf-interpreter) [2]
[https://nanoframework.net/](https://nanoframework.net/)

~~~
bryancostanich
We're running full .NET via Mono. NanoFramework is just a re-write of the .NET
MicroFramework. That's basically .NET 1.1 from from almost 20 years ago. No
generics or beyond.

Meadow is very different. Full .NET means Generics, LINQ, etc., and all the
nugets. :)

~~~
stragies
I keep hearing from the Dev-Shops, that ".Net Core" will be replacing "Full
.Net" w.r.t. long-term support from Microsoft, and that .Net Projects should
be checked for availability of a migration path to .Net Core.

Is this a (future) concern for the F7M, and projects running on it?

Since it's IOT, these things can be expected to be found installed for much
longer than 5 years, so continuing long-term (security) support seems
important.

~~~
bryancostanich
Mono, with .NET 4.7.2 actually gives you the .NET Standard 2.0 API surface
area + other stuff. Eventually, the Mono and Core Runtimes will be merged and
we'll switch over to that. It's all clear as mud; but the point is; we'll
continue to be up to date.

------
shrubble
It looks pretty nice and the .Net part seems to be pretty good. However the
Omega 2+ runs Linux, has twice the Mhz and 4x RAM for much less money...
[https://onion.io/store/omega2p/](https://onion.io/store/omega2p/) . Perhaps
that is why it seems to be sold out at the moment.

~~~
sjburt
With that, you have to run Linux, which you might not want.

~~~
snagglegaggle
This is probably running ucLinux to run Mono. I think the bigger issue with
the Onion is you can't change the firmware (or at least I got the impression
the last time I looked).

~~~
stragies
Onion Omega2+ is available in `make menuconfig` on current OpenWRT git master.
I have not checked older builds.

------
Nelkins
Wilderness Labs has some really nice tutorials, if you know nothing about
electronics and want to start from the ground up:

[https://developer.wildernesslabs.co/Hardware/Tutorials/Elect...](https://developer.wildernesslabs.co/Hardware/Tutorials/Electronics/)

~~~
bryancostanich
Thanks! Our new developer web site is taking shape here: [http://beta-
developer.wildernesslabs.co/](http://beta-developer.wildernesslabs.co/)

Which is where you can find the Meadow docs!

------
tbyehl
This reminds me of how annoyed I was to learn that .NET Core doesn't support
ARMv6 (Pi Zero).

------
moron4hire
This is great. I have a rather large .NET Standard 2.0 library that I've built
for VR projects that would be a big boon in IoT devices. It has a large set of
unit-of-measure conversions and formatters, some Geospatial features for doing
math on LatLngs, audio format decoding, image format decoding, various
compression algorithm interfaces, type-safe HTTP requests, and a number of
statistical filtering systems such as Kalman filtering of kinematic vectors.
It'll be great to be able to reuse all of that code.

And if System.IO.Ports can some day get added to .NET Standard, I've got
serial port communication in there too.

The active .NET open source community has been very proactive about upgrading
to .NET Standard 2.0. There are a lot of things Microsoft "got right" with 2.0
that are making conversion from .NET Framework a lot easier. For example, my
own code (which numbers in the 50kloc range) only took a lite weekend to
convert, and most of that was just learning about the new project file format
(which is drastically simplified for the better, BTW).

Just wish Microsoft had made their Bluetooth stack a part of .NET Standard
instead of jamming it into UWP.

EDIT: I'm having a hard time finding an official spec sheet. Has anyone seen
it?

~~~
pjmlp
I got the news from their mailing list, apparently Meadow F7 will be a subject
talk at Ignite, maybe afterwards we get to know more about it.

------
znpy
With 16mb ram and 32mb flash, maybe it could run the Linux kernel:

\- the board is based on the STM32F7 chip

\-
[https://elinux.org/STM32#STM32F7_based](https://elinux.org/STM32#STM32F7_based)

------
londons_explore
.NET is a nice runtime... But I wonder if NodeJS might get more uptake since
there is a larger community of javascript/typescript developers out there.

I know hardcore embedded people will hate this idea, but sometimes you have to
take the massive performance and memory hit to tempt developers in who prefer
to get stuff done with powerful libraries than learn a new language and start
worrying about memory management...

~~~
learc83
Embedded systems often have real time constraints that don't mix well with
most garbage collectors.

That being said, there are plenty hobby (and commercial) projects where .NET
is perfect.

~~~
londons_explore
True, but one mans 'realtime' is very different than another.

Most microcontrollers today don't even have cycle-accurate memory access
guarantees, so it's impossible to do timing more accurate than tens of
nanoseconds.

Things requiring low latency and accurate timing always end up hardware
assisted (USB controllers, PWM hardware, UART serializers, and a million more
examples).

~~~
learc83
For the vast majority of realtime tasks accuracy of a few tens of nanoseconds
is fine, but random 50ms delays for GC aren't.

~~~
pjmlp
That is why Java variants for embedded soft real time deployments have
completely different kind of GC implementations like something as OpenJDK or
IBM J9, and expose regions and access to unamaged memory.

Likewise .NET's support for value types and low level programming also means
not everything needs to be GC-allocated.

~~~
learc83
That's all true. But at some point if you really need to avoid GC, you end up
writing in a subset of C# that is so limited, it's really just C.

Most people don't have those kinds of performance considerations. I use C# for
soft realtime all the time, but in the instances when I have done actual
realtime embedded work, I just used C.

------
learc83
I really liked the Netduino before they stopped making them. It was great for
building prototypes.

~~~
zgramana
Xamarin and Microsoft alum Bryan Costanich got some friends together to rescue
Netduino and “reboot” it.

They wanted to maintain that same sense of delight for .NET devs, but also
modernize the aging hardware platform and replace the restricted .NET Micro
Framework with full .NET Standard support on the software side.

Several friends from the old Xamarin docs team worked their magic on the
Wilderness docs site—which is why it’s so good.

------
garganzol
Is it interpreted or compiled?

~~~
bryancostanich
Today, we're still Beta and it's interpreted, but we're working on Ahead of
Time (AOT) compilation support right now!

------
skybrian
I thought I'd look at audio. Netduino.Foundation.Audio seems to have support
for playing a tone on a piezo speaker. Compared to Teensy audio, Axoloti, or
Bela, this seems pretty unsophisticated? But maybe I missed something?

~~~
unlinked_dll
Those are geared towards audio builders and this isn't.

------
toxicFork
How hard would it be to make a mobile phone with this?

------
fortran77
Checkmate, Linux! Now .NET is an operating system.

~~~
moron4hire
That's been true for a while. Singularity, CosmosOS, MOSA, SharpOS, just to
name the ones I personally know of:

[https://www.microsoft.com/en-
us/research/project/singularity...](https://www.microsoft.com/en-
us/research/project/singularity/) (no more active development from Microsoft,
but the source is Shared Source available)

[https://www.gocosmos.org/](https://www.gocosmos.org/) (still actively
developed)

[https://github.com/mosa/MOSA-Project](https://github.com/mosa/MOSA-Project)
(still actively developed)

[https://github.com/sharpos/SharpOS](https://github.com/sharpos/SharpOS)
(seems defunct)

