Making the Ada Drivers Library: Embedded Programming with Ada

Video in TIB AV-Portal: Making the Ada Drivers Library: Embedded Programming with Ada

Formal Metadata

Title
Making the Ada Drivers Library: Embedded Programming with Ada
Title of Series
Author
License
CC Attribution 2.0 Belgium:
You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor.
Identifiers
Publisher
Release Date
2018
Language
English

Content Metadata

Subject Area
Loading...
Pulse (signal processing) Context awareness Presentation of a group Code Multiplication sign View (database) Real-time operating system Ordinary differential equation Disk read-and-write head Perspective (visual) Computer programming Software bug Formal language Programmer (hardware) Fluid statics Different (Kate Ryan album) Cuboid Position operator God Physical system Programming language Constraint (mathematics) Software engineering Software developer Sampling (statistics) Bit Instance (computer science) Degree (graph theory) Proof theory Type theory Angle Telecommunication Chain Right angle Procedural programming Whiteboard Asynchronous Transfer Mode Point (geometry) Server (computing) Game controller Functional (mathematics) Implementation Open source Microcontroller Coprocessor Wave packet Power (physics) Goodness of fit Computer hardware Representation (politics) Energy level Compilation album Surjective function Demo (music) Information Interface (computing) Debugger Mathematical analysis Cartesian coordinate system Compiler Personal digital assistant Video game Library (computing)
Presentation of a group Code Texture mapping View (database) Multiplication sign Range (statistics) Design by contract Parameter (computer programming) Mereology Computer programming Software bug Bit rate Semiconductor memory Error message Descriptive statistics Position operator Exception handling Area Personal identification number Constraint (mathematics) Mapping View (database) File format Witt algebra Software developer Fitness function Range (statistics) Bit Instance (computer science) Type theory Arithmetic mean Befehlsprozessor Angle Auditory masking Telecommunication output Procedural programming Whiteboard Representation (politics) Resultant Point (geometry) Game controller Server (computing) Functional (mathematics) Real number Flash memory Device driver Microcontroller Field (computer science) Product (business) 2 (number) Peripheral Computer hardware Representation (politics) Energy level Macro (computer science) Address space Compilation album Surjective function Condition number Pairwise comparison Shift operator Information Interface (computing) Debugger Memory management Coma Berenices Core dump Cartesian coordinate system Preconditioner Compiler Pointer (computer programming) Software Personal digital assistant Enumerated type Computer hardware Read-only memory
Building Thread (computing) Beta function Drag (physics) Code State of matter Multiplication sign Real-time operating system Open set Function (mathematics) Mereology Computer programming Formal language Coefficient of determination Computer cluster Synchronization Computer configuration Square number File system Cuboid Diagram Descriptive statistics Physical system Area Touchscreen Electric generator Arm File format Block (periodic table) Keyboard shortcut Moment (mathematics) Electronic mailing list Sound effect Menu (computing) Bit Virtualization Instance (computer science) Flow separation Category of being Interrupt <Informatik> Configuration space Whiteboard Optical disc drive Middleware Sinc function Point (geometry) Implementation Game controller Link (knot theory) Open source Connectivity (graph theory) Device driver Microcontroller Login Computer Coprocessor Portable communications device Machine vision 2 (number) Revision control Wechselseitiger Ausschluss Profil (magazine) Computer hardware Representation (politics) Macro (computer science) Address space Computing platform Surjective function Task (computing) Computer architecture Multiplication Shift operator Demo (music) Information Key (cryptography) Interface (computing) Projective plane Debugger Planning Plastikkarte Coma Berenices Database Semaphore line Loop (music) Mixed reality Blog Speech synthesis Object (grammar) 5 (number) Communications protocol Family Abstraction Library (computing)
Arm Computer file Demo (music) Code Multiplication sign Robot Demo (music) Programmable read-only memory Source code Projective plane Directory service Computer programming Revision control Type theory Integrated development environment Read-only memory Chain Whiteboard Drum memory Library (computing) Library (computing) Data type
Presentation of a group Structural load Code View (database) Multiplication sign Source code Scanning tunneling microscope Beer stein Floppy disk 1 (number) Cloud computing Open set Mereology Stack (abstract data type) Computer programming Pointer (computer programming) Bit rate Semiconductor memory Data Encryption Standard Videoconferencing Computer file Keyboard shortcut Interior (topology) Sampling (statistics) Sound effect Bit Instance (computer science) Variable (mathematics) Complete metric space Sequence Category of being Proof theory Befehlsprozessor Telecommunication Chain Hill differential equation Convex hull Pattern language Whiteboard Optical disc drive Wide area network Slide rule Game controller Statistics Link (knot theory) Connectivity (graph theory) MIDI Letterpress printing Virtual machine Maxima and minima Device driver Parallel computing Graph coloring Twitter Revision control Computer hardware E-learning Ranking Computer worm Window Data type Execution unit Information Demo (music) Interface (computing) Debugger Projective plane Plastikkarte Cartesian coordinate system System call Compiler Inclusion map Kernel (computing) Integrated development environment Software Musical ensemble Abstraction Library (computing)
Point (geometry) Building Implementation Run time (program lifecycle phase) Computer file Code Multiplication sign Adaptive behavior Device driver Microcontroller Mereology Food energy Perspective (visual) Power (physics) Frequency Mathematics Latent heat Peripheral Linker (computing) Computer hardware Core dump Gamma function Task (computing) Physical system Scripting language Scaling (geometry) Weight Projective plane Database Bit Instance (computer science) Variable (mathematics) Oscillation Befehlsprozessor Kernel (computing) Vector space Personal digital assistant Interrupt <Informatik> Configuration space Codec Right angle Library (computing) Asynchronous Transfer Mode
Service (economics)
I don't want to spend too much time introducing people so feel free to just
say who you are okay to trying so good morning everybody I'm Fabian Sciuto software engineer at a decor so it requires the company that maintains and developed the open source compiler for ADA which is called Gannett ins based on the on GCC we developed a lot of other tools for software development as well and today I want to talk about how to use ADA in embedded programming in particular with a small microcontroller like you can find on this kind of of small box so before I start my presentation there will be a live demo I will try so please everybody if you can pray the god of life demo thank you very much so to begin with I will give you my like my view on the ADA philosophy or the ADA way of doing things which is in my opinion that programming is all about communication you have an application an ID a program in your head and you want to communicate it you want to communicate with your tools like the compiler because that's what is going to make your executable at the end you want to communicate with further tools like static analysis ie stuff like that you want to communicate with users of your API if you writing a library you want people to know how to use the library with your colleagues of course because they will read your code debug it etc and you even want to talk with communicate with that idiot that's what this really stupid piece of code but away it was me two months ago so that's something and jean-pierre talked about it but one of the main design goal of Veda is really based on the on the fact that we read code and we debug it more than we program actually and it's probably not something that we want to hear a lot because we would like to see ourselves as you know programmers developers we create stuff but actually the reality is that we spend a lot of time reading code so to put that into the context of embedded programming what is different for embedded programming it'sit's a bit difficult to explain there's a lot of things that are similar usually you will have the obvious which is you have a different tool chain you have a different processor etc but really what it comes down to in my opinion is that every bags cost you a lot more a lot more time to investigate because you have different tools you don't have for instance as much breakpoints as you want in your debugger not time to try a fix because you have to reprogram your embedded targets you maybe have some hardware to reconfigure if you make a mistake if there's a bag you can potentially destroy your hardware and that's an example that I will take later or even I don't mention it here but you can also an injured people or kill people in the example of aircrafts or trains stuff like that and updates are usually also very difficult to propagate if you if you have a project on on a board like this one it's very difficult to propagate an update once you have a bug in it and the other point that I will cover is the need of control so I guess my presentation is a good is a good follow-up to what jean-pierre said because I will also show the high level representation in Ada and how you can control the hardware representation so that's one point and the real-time constraints I will also quickly talk about tasking in real time in annada so let's get started to talk about programming in AD I will take the example of a sample matter so it's a little motor like this you can set an angle it's controlled via a electric signal with some pulses if you put a 1 millisecond pulses it will go 90 degrees to the left one point five millisecond is the natural position and two point five is ninety degrees to the right now what happens if you don't respect this constraint well here you are in the real world and there are real consequences to your Berg's which means you will destroy your server mode oh and of course that's that that's not something you want it cost money you will lose a lot of time so you want to avoid that so let's see how a des will help you to communicate the constraint of your system to avoid this kind of situation so if we take an example from any other language your interface is to control the the servo motor will probably look something like this so you a procedure Eneida is a function that doesn't return anything you say ok let the user set the angle the desired angle of the of the of the servo motor now if you are a really really good programmer you will do something like this you add comments right so as you can see you had some very very important information over here because otherwise you will have a failure and you will break your hardware so that's what you would do in most programming languages and as you can see this is not very practical so first the compiler and the other tools don't know about this constraint right because it's only in the comments and then if somebody decides to change the implementation and say ok I don't want to go from the 90 degrees to minus 90 I want to do a percentage I want to go from 0 to 100 well maybe the developer will forget to update the comment and users of the API we don't be will not be notified by this so in ada you really express what you want and you will define your own type and this is again in the in the perspective of what you were just saying that there's a lot of languages that claim strong typing but really strong typing is not that useful if you cannot create your own type and ADA gives you all the power to create your own types so now in practice what does it mean once you've said that well as we said there are the compilers the tools the users of the API everybody knows about this in practice what does it mean well let's have a look with with the compiler so in the use case really simple like this the compiler will be able to tell you okay this is really done you're just giving a wrong value so it will give you warning so that's a first mistake avoiding great then if we go to a more difficult example here we multiply jingle by two so it's more difficult to analyze in that case you will need to go to a static analyzer like code Pia and again the tool because it has more information will be able to give you more precise and more useful analysis so again the here the static analysis tool will tell you there's a high probability of any whore here the next tool is formal proof we spark so there will be a presentation this afternoon about about spark what what this gives you is a mathematical proof that there is no
error in your program so in that case there is an error so the tools will tell you so at this point you should catch most of your error but sometimes you don't have access to these tools so maybe someday we'll go through so the next step is to actually run your application and you will do that during the development usually use erewan and our debugger and as Jean Pierre already explained when there is such an error detected in an ADA program there will be an exception that is rate and once when you are running inside the debugger the exception will be code and so you stop before you are and you protect your hardware and then you can fix so you again you catch the bug very early so the next step is to actually catch the error inside the code itself so you you know it's just an exception stand out ADA exception so you can catch it like this and you again stop before doing something bad so you protect your hardware and you save money you save time etc etc the last chance is this procedure when an exception is not handled in a jar yeah this procedure will be called it's a very good name the last Chancellor and that's your last chance to do something about the situation usually when you when you when you go to this you're in really really bad situation so you probably want to shut down everything reset the board or maybe wait for you so input something either and so that's your last results after that there is no more protection so those checks that you the constraint that you put on the type and the checks that come with them they have some performance impact of course because there will be more code added to your binary there will be some comparison stuff like that it's very useful when you are in development in they begin because you want to catch the bug as early as possible and you can want to catch all of them but once you are in production maybe you want all the performances and you can remove everything and in that case it's up to you if you really want to dare running your application without any checks so another example of how you can express what you mean in an idea is contracts so there's also a presentation about contracts later on so just a quick example I like this example because it's very simple and this actually saves me a couple of times so we have a driver for the server alright and usually there are some hardware to initialize before you can actually control the the server matter so this is exactly what we described here we say to the user of our API that yet so it's a precondition of the of the procedure set angle it's something that must be true before you call the procedure and we say that the servo has been initialized when the condition is not true well it's the same story you have so the tools will be able to tell you it from this information and then the debugger will we'll be able to catch the exception you can catch it in the code as well and the last rinse under etc another a quick example that I really like about ADA because many people can relate to this if you use C or C++ for instance you will often see a set in C or C++ code for functions that take pointers as parameter say okay to check that a pointer is actually not new you need add that's one of the examples how you can express that you take a pointer okay but it should not be new and that's part of actually your your your interface in your API so now let's talk a little bit about hardware mapping so that's one of the things we need when we do embedded development we need usually a good control of the hardware representation about type and so as rompilla said in ada you always have the high-level view of your type and then you can control its representation so for instance here I say that my type servo angle should be represented in in the byte and I want 16 alignment if I use a small smaller value here are two small value the compiler will tell me okay it's not possible same thing if I somebody tries to increase the range and it doesn't fit in the in the in the size anymore there will be a compiler here so this is useful when addressing hardware it's also very useful in network communication to form packets the next really common practice in in embedded programming usually with small my controller microcontroller sorry like like you having in this kind of boards it's the memory mapped register so I don't know if you familiar with this with this notion I will try to describe it really quickly so this is a representation of your address space so that's all the memory I will do addresses that your that your CPU can can can read and write of course on small embedded processors like that you don't have the full memory or you never have the full memory used so you you will have some areas where you have viewed the flash it's the read-only memory that holds your your your program you have some areas where you have the RAM other areas will be allocated to peripherals what this means is that when the compilers when the CPU sorry reads or writes that from those addresses it will be exactly like talking to the peripheral so when you read a data from this address you receive data from the peripheral when you write you send data to a peripheral and so this is the kind of description that you will find in your hardware documentation so this is a virtual example it's not actually representing something real but it's really exactly like you would find in the documentation so here we have what what is called the memory mapped register so it's 8 bits and we can see that there are some fields inside those edits that are defined so the first four bits are reserved they are not used the fourth and fifth are used for the sense field and the six and seven are not used as well and the documentation will give will tell us what are the possible values and the meaning of those values for for the sense field in C usually you will have a drivers written with something like that so you will make more or less macros and beat-beat shifts and masks like you see here so as you
can see and you can probably guess that this is not really safe to do for instance if you want to put the value 1 which is a wrong value for this for this field you will don't know about it the compiler will not know also this is not very practical to write like you you have you need a special a special instruction to clear the field first and then set its value etc etc so now in Ada again what we will do is have the high level view and the low level representation of the time so first we declare an animation type so that's the the pin sense field that we saw before we declare its high level view which is there's three values disabled high and low we specified the hardware representation so the size will be true and the also the hardware representation of the different values next we go to the register itself again same thing we have the high level view and the low level view so we have the first reserved a field of the register we then define our sense field and the second result and as rompilla showed as well in this presentation here you define the hardware representation and so you define the exact position of each field and as you can see this is really exactly what is what is in the documentation to use this type well you declare and yo register and with this constrict here you say with address you tell the compiler that this variable should not be allocated on the stack or should not be allocated on the heap you specify yourself I know that there is an i/o registers address and that's how you specify it in Ada and then it's just you just assign the value of an enumeration and so you have all the checks that we mentioned before so this kind of representation can be a little bit difficult to write a bit little bit tedious so fortunately the you know I am the creator of the the cortex-m microcontroller they developed a format called SVD which is a hardware
description format so as you can see here it's a description of the different registers gives you the address gives you the different values etc etc and we developed so my colleague z1 developed a tool that will take this format and produce the the ADA representation that we saw here this will be generated from the description so this is really a great great way a great tool to start programming on microcontroller in EDA because most of the hardware representation will be automatically generated another example of EDA features that are really useful in the indie embedded area it's the tasking embedded inside the language so jean-pierre you already talked a little bit about this I have a blog post right here if you want more info on this I will just describe quickly a few stuff but there's more info over there so in EDA tasks or threads are a really native feature of the language and for the embedded market or the embedded projects there is actually a specific tasking profile which is a restriction about the big the big tasking features of Ada and it's called Ravens cow and this is really meant for real-time operating system and to give you real-time properties with Ada some of the features that are available you have a clock that will give you the system tick you can do delay so put a task in suspend the task for a given amount of time you have protected objects which are really something quite unique I think it's it's it's difficult to explain quickly but it's a mix of mutexes and semaphore and you can also do interrupts on laying with this you will see in the blog post I have an example how you you can really create an elegant interrupt handler and a driver for instance for our soil box using the protected object so gives you multiple things but mutual exclusion you can do synchronization between tasks so for instance if you have a task that produces data attack that consumes data you can have the task the consumer waits in a suspended state for the producer to actually give it data and all of this is really part of the language it's really safe to use because there are a lot of control over what you can do like you what you cannot the last point is as I said the interrupt on link so there's also as part of the ADA a language the constrict you to handle interrupts which is very very useful for embedded in microcontrollers so this is just a quick example of a task in ADA so you can see tasks it's a keyword of the language so here we declare the the body of the of the task and it's just basically a loop we do a delay so we suspend the task every time and we add 100 milliseconds so this will be at 10 Hertz it's a typical code that you would use to make a periodic task in it so now I will talk about the odorous library project this project we started in 2015 I think and so show you a few points it's a few more library so it's a library that will give you tools to support and to implement programs on microcontrollers like this one it's hardware inventory dependent so this is both a bad thing because it means we have to write stuff ourselves it's not provided by the vendors but on the other hand we can work on really focus on really having the most clean interfaces and and reusable code it's 100 percent written in Ada and hosted on github you can you can have a look so why we started this library well the first thing is that ADA as has a good properties to bind with other languages like C for instance but this usually does not apply very well to drivers provided by the vendors by the hardware vendors because they use as I said as I showed before they use a lot of macros and bit shift and stuff like that doesn't really apply very well to to to do a binding in Ada and the next point was also a way for us to actually use our tools and to show to have demos for people to show what what you can do with data and the last point of course it's it's really fun to do so that's a good way so quickly some some architecture aspect of the of the library in the library we have what we call components so what we define by component is a separate piece of hardware that is connected to your microcontroller using a standard protocol like I Square C spi uart extra this is special so that the drivers are for a piece that is external and most importantly it's it's working using standard protocol so the idea is that here you can change microcontroller you can go from cortex to an AVR or to whatever brands you want the driver will still be the same so for the components we want to have a very reusable code and portable code this is the quickly the list of what we support right now so we have some audio DAC some camera some what we call motion is a gyroscope accelerometer
etc etc touch panels and stuff like that the next layer that I want to talk about is the middleware so we don't have a lot here but I think we have some interesting things bitmap drawings so to use on the LCD screens you know if you know the adafruit gfx library it's pretty similar very simple drawing features we also have some file system support so we support the the fat format and also some kind of virtual fact system about the arm semi hosting feature and a small dog agility to filter on the logs debug this so this is more or less what it looks like so you've probably seen this kind of diagrams tons of time what's important to see here is that this part geez VD binding is generated by a tool this part over here the other way abstraction layer the components the middleware are all possible so really if you want to benefit from the idea drivers library and if you want to start programming your microcontroller in EDA you will have to focus only on this low-level driver parts if you are using a microcontroller that we don't already support of course speaking of supports this is the two platform that we support so far so with we have the the cortex-m architecture which is our version for microcontrollers and since last year we also started to support the first risk 5 microcontroller so I have here the list of boards that we support I will just spend a few seconds on them this is a really good option to start it's one of the bolts that we support the most so in stm32f4 5 this one is really cheap like 15 euros or something like that but you have everything you need there's a debugger and integrated a really powerful microcontrollers and and as I said that's one of the the bolts that we support the best you didn't have this one which is more or less the same but with an LCD screen and and touchscreen as well which is nice and then you have all the discovery family which adds new features this one is an SD card and an audio output this one is in the cortex m7 family so it's the new generation of of cortex-m microcontrollers more powerful there's an Ethernet port on here as well and again another codex m7 this is the open MV it's the bomb that I have right here it's an open source open hardware camera it's more or less like the Arduino of computer vision so it's a small microcontroller with just a camera around it we support that as well this is the crazy fly 2.0 it's really really small like it's the size of my hand quadrotor and again there's a small microcontroller on it I will I will show it a bit later as well this is the BBC micro beads will achieve as well like 15 of 13 euros there's a cortex m0 processor on it with Bluetooth Low Energy support so so far we have somewhat limited support for this but in the future we will probably focus on using this particular board as the reference platform to learn embedded programming in EDA and as I mentioned earlier we started to support the first risk 5 microcontroller so this is the high 5 one bought from Sky 5 the companies effect so what's next for the beta drag of library so first we want to focus on the the configuration and build system so I will show you quick list of what we have so far but it's a little bit complicated we use ugr key of project which is not very practical for beginners no documentation of course there is not never enough documentation we also have a plan to bring a really basic support out-of-the-box support for every possible cortex-m devices on the market so that's that's kinda nice Linux GPIO so I mentioned microcontroller so far but actually the components driver can also be used in on the Raspberry Pi for instance because you have I squared C protocols supported UART excetera so we want to have some kind of binding for being able to reuse the components driver in an idea rather sorry be able to use them on the Raspberry Pi the Avia platform so this is maybe not the most trendy platform at the moment but I think it would be really cool to have some support of a VR and the other ADA driver sir Barry Moore component of course there was never never enough there are so many components in the market USB stack so I mentioned that we support we have a lot of support for this team 52 the main block that we are missing right now we support for the USB so that's something I really would like to work on and to support in in a database library and there's on the BBC micro bit there's a Bluetooth low-energy microcontroller so it would be also nice to have some kind of Bluetooth stack on on this platform as well so now it's
time for the demo so I will I already prepared a few things so if you want to start programming embedded programming in ada you you can get one of the bolts that was listed before so for this demo I use the stm32f4 six nine just right here so beforehand I downloaded the tool chain so you can go to edit code come / community you will see that the community release of our tool chain so we want the arm elf version of the true chain that you can download here download it install the tools then you can download the ada travels library code so either you clone the project or you don't know the zip and there there we go so the demonstration is working okay so this is not programming studio I will start it here it's our IDE it's supporting ADA C C++ and Python I think so when you start GPS you can open a project project file so let's say this is the ADA type of library sources you go to the example directory and then you will have one sub directory for each of the bots that we support so for me it's
the four six nine so I go into this directory and here we have the different examples that are supported on this board so we take the draw example okay so this is as I said GPS our IDE so as
you can see over there you have your sources this is what it looks like you have support for code navigation so for instance if I want to if I want to see the definition of this color over here you can jump in in the code you have cut completion so if you want to change something to green things like that so like really modern ID features you can then compile your embedded projects so this is compiling all the the ada drivers library so you can see the components this is the cpu support hardware abstraction layer the theme 32 drivers I don't think I've enabled the parallel computation okay there we go one really nice feature of GPS as well is this view over here which gives you how much memory you are using a new application so we can see the we can see the the RAM for instance and you can have some details and see where what part of the other of the program uses most memory so you might think it's it's it's a lot of memory that we use over here but please keep in mind that we have the tasking environment and embedded so we have the the the stacks we have the kernel everything is embedded here so now that we have our program compiled I will just plug the USB ports of this bond let's go Tec I don't need this and I will have hope that there you can see them we have different shortcuts and this one is flash tube also this will make sure the the program is at the latest version so we compile it and then send the application to the to the Bob so that's why developing an embedded is slow and I have to reset it and this should work so it's drawing it's just a simple drawing example now if I want to debug my application I can use this pattern over here dip back on board and this will open at the beginning session yes this will open at the beginning session flash the application start gdb etc etc so I don't know if I mentioned it but the the Gounod compiler the natural chain is based on GCC and our debugger is based on gdb we contribute the idea support to gdb and then well it's again very common debugging session let me put wise it's I can put a breakpoint over here for instance continue Hey ah looks like you didn't pray enough I don't know maybe I'm not reaching this code want my drawing restart well okay so do you effect this should work it doesn't and then from from from this interface you have all the usual gdb features so you have the call stack up over here so we can see that it's waiting for some I squared C communication so maybe there's something wrong here we have the memory view you can watch.watch variables and all the really neat and usual debugging features so
that's it for the demo was more or less okay right next part I want to talk about some of the projects that were developed so either by me or my colleagues at a decor and also some people from the community so the first one I already kind of talked about it this was done by Anthony he was intern at a Toccoa at the time and he wrote he rewrote the full flight controller for this drone using a DES inspark proving some properties using using spark and formal proof this is a project that I made it's so since I controller a computer-controlled machine made with all the DVD players and floppy discs and this kind of stuff for all the project I give you a link if you want to have a look and have more information this was made by University in Spain I think so this is a LED pendulum so using the persistence rate in a persistence defect to draw text on on on the air so as you can see this is the the small contact same board that I talked about earlier this is another project by me so I used the open MV camera and I plugged it to a thermal printer so thermal printer is things that you will see in a supermarket or restaurants to print tickets credit card tickets or stuff like that and I used this to make an instant camera so you take a picture and we'll print grayscale not very not very beautiful but well it's fun at least next one is from my colleague Jerome he implemented the version of the version stein 3d engine in Ada so it's running on this one is the Coptics m7 but it's also running on Raspberry Pi a bare-metal it's running on different version of the Bob so here yes it's the Coptics m7 as you can see it's customized really really nice ADA advocacy over there this one again project by myself this one is a custom hardware actually I developed the ball as well and this is a sampler and sequencer so you can actually play there's an SD card on the backside you can play samples of music according to a pattern that you enter again if you follow the link you will probably find videos about this and the last thing I want to talk about is the microdata competition so for the last two years we organized a programming competition so a deca organised this competition so far it was focused on embedded software projects for the next edition we will maybe open it a little bit but it's not sure right now it's otherwise open to everyone there's about 8,000 euros in prize and so as I said we did not announce the the next competition yet but if you follow if you follow us on Twitter we will make the announcement over there and so my last slides are two example of projects so the winner from 2016 is Stephan Kyle with over here yeah he made so this is again the same bob as sure home use for the Vulcan Stein it's an STM 52 f7 and there's an Ethernet spot on it so he managed to program a network analyzer with this so you used the drivers library in part and then you made your own Ethernet driver and IP stack and this kind of okay okay and so you displayed the graphic and all the other statistics of the other Network and for 2017 we know I don't think he's over here I was Jonas and he made a brushless motor controller so the brushless motors are the ones used in in drones typically and so this is also custom hardware so Joan has designed this board and I wrote the driver for it using Ada and idea drivers library so that's it for my presentation I will take any question if you if you
have one but what I would like really to know is what are you going to make with data [Applause] okay so the quiz yeah we'll try to repeat the question the question is about the new change that we will do in the build system and about configuration of the library for your custom hardware right so so there's actually two parts that's something that we mentioned in the documentation and I I really just went really quickly over this in Ada you have the so dirty arrivals library and there's the runtime it is the the library that supports the tasking and these kind of things and usually that's where you will have most of the hardware dependent code so I don't know if it's the case for you what we will do with the next build system is we will try to as I said support all the all the codecs same peripherals sorry microcontrollers and we will also have some ways of configuring a few points in the in the in the in the drivers library so for instance what you will do is you say I want to start a new a database library project and you will specify which meet microcontroller you use and so you will have the linker script for this microcontroller you will have the vector files and stuff like that and you will also be able to configure for instance what is the external clock external oscillators and this kind of stuff inside the the wizard for the configuration that's what we have planned I don't know if that's what you are thinking about or okay good the exile I didn't see before I haven't looked at it how to change the clock to perspective microcontroller it seems it's okay so the question is about configuration of the system clerk and if you can turn it turn it off or change the frequency right so given the actual implementation of the Hovind scale runtime the runtime I was mentioning we do not support system what called CPU throttling so you can change the frequency of your CPU we do not support this right now mostly because your your time variables or your your clock variables will be you will have no sense if you change the frequency the speed of the clock so that's not something we support what you can do if you want to save energy is well first in the in the kernel so that implements the task inside the runtime when there is no task to run we put the CPU in weight mode so wait for interrupts that's so it's somewhat lower power mode and the next solution is to really shut down so if you have a stm32f4 you will have to shut down the CPU to save energy that's that's all we have so far okay yes a little bit so it's it's so the question is about the question is about the support of the bigger bigger bun blue right which which CPU is the running on this I guess it's made for Linux or okay I didn't know this so looks like there's an cortex a core and the cortex M so for the cortex a I would say you know it's really meant to run Linux so you should run Linux and that's what I was mentioning in the improvements that we want to do to support some of the Linux driver for I squared C and SPI etcetera for the cortex-m part I don't know I don't know this device in particular but you should be able to to support it with with with the odorous library there will probably be some adaptations to be to this specific hardware but yeah that should be doable okay
so thank you thank you [Applause]
Loading...
Feedback

Timings

  499 ms - page object

Version

AV-Portal 3.20.2 (36f6df173ce4850b467c9cb7af359cf1cdaed247)
hidden