News for hackers. Stuff that matters.
Re:Discover the world of microcontrollers through Rust by pjc50 on Sunday September 17, 2017 @03:34PM (#15271272)
Microcontrollers have got a lot more accessible since Arduino. There's lots of beginner material out there, although admittedly not on Medium. (Unsurprisingly, the people involved prefer a more bare metal approach and put it on blogs or forums instead)

The tooling is nearly always C, so it's interesting to see Rust moving into this space. Memory management is not so much of an issue, but multitasking correctness is; perhaps there will be some new micro-RTOS framework with provably correct interrupt handling. (We have sel4, but that's not quite the same thing)

As you get more low level, the tutorials get sparser. You move into FPGAs, where you have a choice of two languages with 1970s design principles, or third-party tools which work despite the manufacturer's total closedness. As you go deeper into actual IC design, nobody will attempt it without supervision from someone experienced to tell you all the little tricks. And then there's analog IC design, which is basically black magic.

Re:Discover the world of microcontrollers through Rust by askvictor on Sunday September 17, 2017 @05:55PM (#15271910)
> The tooling is nearly always C

With the esp8266 and low end arm controllers, there has been an explosion of languages for embedded applications; micropython, lua, es, basic, even lisp. Particularly for beginners, this is a good thing. Having said that, the dev environments are somewhat lacking at this stage, and I'm wondering if we'll soon be at a point where they'll be enough resources to just put Linux or other OS straight onto the microcontroller.

Re:Discover the world of microcontrollers through Rust by StavrosK on Sunday September 17, 2017 @09:23PM (#15272728)
Yes, but the ecosystem is so heavily geared towards C there that if you want to do anything non-trivial, you'll need to use C anyway.

I wonder how easily one can link C libraries with MicroPython, that'd be the best of both worlds.

Re:Discover the world of microcontrollers through Rust by kronos29296 on Monday September 18, 2017 @05:54AM (#15274540)
Shouldn't be too hard considering that the entire thing is written in C.
Re:Discover the world of microcontrollers through Rust by johnny22 on Thursday September 21, 2017 @06:12PM (#15307802)
you can also use inline assembly on certain platforms. (last i checked anyways)
Re:Discover the world of microcontrollers through Rust by ZenoArrow on Sunday September 17, 2017 @06:16PM (#15271996)
> "You move into FPGAs, where you have a choice of two languages with 1970s design principles"

I'm assuming you're referring to VHDL and Verilog. There are plenty of other hardware definition languages out there. Chisel, CλaSH, MyHDL, etc... Can see a more complete list here:

https://en.wikipedia.org/wiki/Hardware_description_language

Re:Discover the world of microcontrollers through Rust by ATsch on Sunday September 17, 2017 @06:26PM (#15272038)
Sure, those languages might exist as a design document somewhere, but you are not going to have a lot of luck finding an FPGA vendor that actually supports them.
Re:Discover the world of microcontrollers through Rust by petra on Sunday September 17, 2017 @06:32PM (#15272062)
Chisel compiles to verilog, so you don't need vendor support.
Re:Discover the world of microcontrollers through Rust by ZenoArrow on Sunday September 17, 2017 @07:53PM (#15272370)
Similarly, CλaSH and MyHDL also compile to Verilog (or VHDL).
Re:Discover the world of microcontrollers through Rust by ATsch on Monday September 18, 2017 @08:16PM (#15280818)
Oh, that's pretty cool. I might look into that then.
Re:Discover the world of microcontrollers through Rust by Bromskloss on Sunday September 17, 2017 @03:48PM (#15271343)
Also in this stack, one step below using an Arduino, would be to use existing microcontrollers (or other ICs), but design your own circuit board. In contrast to IC design, this is something you can do on a hobbyist budget. Actually, if you don't etch the board yourself, but have it made and mailed, all you need is soldering equipment to populate the board with the components.
Re:Discover the world of microcontrollers through Rust by kirrent on Sunday September 17, 2017 @07:55PM (#15272380)
I've got the equipment to do hot air soldering, and I flatter myself that I've gotten pretty good at some fine SMD work, but these days I rarely bother. The premium on a service like macrofab.com usually is less than the money I waste on spare parts I accidentally destroy and postage from many different distributors.
Re:Discover the world of microcontrollers through Rust by 66o on Monday September 18, 2017 @04:15AM (#15274165)
Can not thank you enough for that comment. I was looking for a local shop that could assemble a couple of prototypes for me and the quotes they provided were at least 3-4 times what macrofab shows me.
Re:Discover the world of microcontrollers through Rust by StavrosK on Monday September 18, 2017 @06:45AM (#15274733)
Any cheap China-based alternatives?
Re:Discover the world of microcontrollers through Rust by pjmlp on Monday September 18, 2017 @03:14AM (#15273917)
C++, Oberon, Ada, Java, Pascal and Basic are also an option

https://www.mikroe.com/products/#compilers-software

http://www.astrobe.com/default.htm

http://www.microej.com/resources/supported-platforms/

http://www.adacore.com/press/8-bit-avr-microcontroller/

As for source for information, for me it used to be the Elektor magazine, available in a few languages.

Up to a few years, it was still common to occasionally see Pascal listings on it.

But you are right, the embedded culture is mostly C, and using alternatives, even C++, tends to end in culture clash, as Dan Saks referred to it in his CppCon 2016 talk.

Re:Discover the world of microcontrollers through Rust by awelkie on Sunday September 17, 2017 @04:07PM (#15271441)
What kinds of things would you want proven correct about your code's interrupt handling?
Re:Discover the world of microcontrollers through Rust by pjc50 on Sunday September 17, 2017 @04:26PM (#15271521)
Mostly whether the mechanism for passing data to and from the main program is sound; but also whether things like interrupt priority make sense and whether your re-trigger handling or re-entrancy are going to work properly (an interrupt happens while you're in the handler for the same interrupt). It might be sufficient simply to have a good set of primitives for this, rather than an actual proof.

Basically whether it's going to deadlock or miss interrupts. Deadlock is immediate disaster, but at least the JTAG will help you .. if the device hasn't self-destructed. Missing interrupts is worse because it's extremely hard to debug.

Forcing DMA to behave would also be great, although this isn't strictly a microcontroller issue. I've seen a few war stories where people are trying to debug memory corruption where the program is completely correct - but some other device has simply DMA'd over it. I think this was involved in https://googleprojectzero.blogspot.co.uk/2017/04/over-air-ex... too.

Re:Discover the world of microcontrollers through Rust by awelkie on Sunday September 17, 2017 @06:34PM (#15272068)
I believe rust's safety guarantees are enough to ensure the soundness of passing data to/from interrupt contexts and interrupt handler re-entrancy. See rtfm[0] for an example and a good explanation. I think DMA handling can be made safe by using the right abstractions, and then you'd just need to trust that any piece of code that accesses the memory uses the abstraction instead of accessing it directly.

Checking interrupt priorities sounds like an interesting problem. What is the state of the art in deadlock prevention? It would also be cool if you could tell the compiler "I need this interrupt handler to return in less than n clock cycles." I wonder if someone could write a rust compiler plugin to check that.

[0]: http://blog.japaric.io/fearless-concurrency/

Re:Discover the world of microcontrollers through Rust by petra on Sunday September 17, 2017 @04:44PM (#15271600)
Top 10 Causes of Nasty Firmware Bugs

https://embeddedgurus.com/blog/2010/12/top-10-causes-of-nast...

it would be great if all those would be easy issues, or solved.

Re:Discover the world of microcontrollers through Rust by vanderZwan on Sunday September 17, 2017 @05:11PM (#15271716)
> The tooling is nearly always C, so it's interesting to see Rust moving into this space. Memory management is not so much of an issue, but multitasking correctness is; perhaps there will be some new micro-RTOS framework with provably correct interrupt handling.

Give Céu a look[0]. It was specifically designed for embedded computing, and compiles to C, making it very easy to interface with existing libraries. It requires no manual memory management, and has very nice structured synchronous reactive concurrency primitives.

(EDIT: I realise that multitasking and concurrency aren't quite the same thing; it also has experimental interrupt support though)

Here's a made-up example for Arduino (for which it has support out of the box[1]). It creates two concurrent fading LEDs at different frequencies, and resetting at the push of a button:

    #include "arduino/arduino.ceu"
    
    input  int PIN_02; // button input
    output int PWM_05; // LED outputs, remember that pins 5 and 6
    output int PWM_06; // have a higher PWM frequency on the UNO
    
    // a code block that concurrently fades an LED in and out
    // `pin`   the output pin of the LED
    // `min`   min value of the fade
    // `max`   max value of the fade
    // `delay`   number of milliseconds to wait between increasing/decreasing `analogWrite`
    code/await Fade_forever(var u8 pin, var u8 min, var u8 max, var uint delay) -> void do
      loop do
        var int i;
        loop i in [min->max] do // fade in loop
          if pin == 5 then
            emit PWM_05(i);
          else/if pin == 6 then
            emit PWM_06(i);
          end
          await delay ms;
        end
        loop i in [min<-max] do // fade out loop
          if pin == 5 then
            emit PWM_05(i);
          else/if pin == 6 then
            emit PWM_06(i);
          end
          await delay ms;
        end
      end
    end
    
    loop do //endless loop
      // if *any* of these three code blocks (trails) end, all of the remaining trails in
      // a `par/or` are aborted and code resumes (in this case, the loop restarts).
      // By comparison, a `par/and` construct would require *all* of the trails to
      // terminate before continuing.
      par/or do
        await PIN_02; // .. meaning that if a button is pressed, we reset the loop
      with
        // fade the LED at pin 5 quickly between 64 and 192
        await Fade_forever(5, 64, 192, 5)
      with
        // fade the LED at pin 6 slowly between 0 and 255
        // note that because it fades over almost twice range (255 vs 128)
        // but not exact, it's around eight times slower, not four, and it
        // will slowly go out of sync. 
        // We can push the button to reset however!
        await Fade_forever(5, 0, 255, 20)
    end
[0] http://ceu-lang.org/, http://fsantanna.github.io/ceu/out/manual/v0.20/

[1] https://github.com/fsantanna/ceu-arduino

Re:Discover the world of microcontrollers through Rust by theWatcher37 on Sunday September 17, 2017 @03:37PM (#15271290)
Can confirm, in my emag applications class I had tools from "black magic something something" company printed on the top.