"Make With Ada" Competition

[rstofer]

When I look at the Ada runtime code for writing registers, it is not immediately obvious how it works.  I'm still thinking about how obvious the volatile pointers were when I first saw them.  Maybe the Ada code is the same kind of thing.  Once I understand it I will view it about the same as the pointers.  But right now, I have not a clue how it works.  Clearly, that's my failing because it does work.

Can you post an example of ADA code that accesses registers?

Here is an example from the file s-textio.adb:

Code: [Select]

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT RUN-TIME COMPONENTS                         --
--                                                                          --
--                       S Y S T E M . T E X T _ I O                        --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 1992-2016, Free Software Foundation, Inc.         --
--                                                                          --
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
-- terms of the  GNU General Public License as published  by the Free Soft- --
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
--                                                                          --
--                                                                          --
--                                                                          --
--                                                                          --
--                                                                          --
-- You should have received a copy of the GNU General Public License and    --
-- a copy of the GCC Runtime Library Exception along with this program;     --
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
-- <http://www.gnu.org/licenses/>.                                          --
--                                                                          --
-- GNAT was originally developed  by the GNAT team at  New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
--                                                                          --
------------------------------------------------------------------------------

--  Minimal version of Text_IO body for use on STM32F7x, using USART6.
--  Serial interface is available via the arduino port of the board:
--  PIN D0 (PC7 GPIO): USART6_RX
--  PIN D1 (PC6 GPIO): USART6_TX

with Interfaces; use Interfaces;

with Interfaces.Bit_Types;   use Interfaces.Bit_Types;
with Interfaces.STM32.RCC;   use Interfaces.STM32.RCC;
with Interfaces.STM32.GPIO;  use Interfaces.STM32.GPIO;
with Interfaces.STM32.USART; use Interfaces.STM32.USART;
with System.STM32;           use System.STM32;
with System.BB.Parameters;

package body System.Text_IO is

   Baudrate : constant := 115_200;
   --  Bitrate to use

   ----------------
   -- Initialize --
   ----------------

   procedure Initialize is
      use System.BB.Parameters;

      APB_Clock    : constant Positive := Positive (STM32.System_Clocks.PCLK2);
      Int_Divider  : constant Positive := (25 * APB_Clock) / (4 * Baudrate);
      Frac_Divider : constant Natural := Int_Divider rem 100;

   begin
      Initialized := True;

      RCC_Periph.APB2ENR.USART6EN := 1;
      RCC_Periph.AHB1ENR.GPIOCEN  := 1;

      GPIOC_Periph.MODER.Arr     (6 .. 7) := (Mode_AF,     Mode_AF);
      GPIOC_Periph.OSPEEDR.Arr   (6 .. 7) := (Speed_50MHz, Speed_50MHz);
      GPIOC_Periph.OTYPER.OT.Arr (6 .. 7) := (Push_Pull,   Push_Pull);
      GPIOC_Periph.PUPDR.Arr     (6 .. 7) := (Pull_Up,     Pull_Up);
      GPIOC_Periph.AFRL.Arr      (6 .. 7) := (AF_USART6,   AF_USART6);

      USART6_Periph.BRR :=
        (DIV_Fraction => UInt4  (((Frac_Divider * 16 + 50) / 100) mod 16),
         DIV_Mantissa => UInt12 (Int_Divider / 100),
         others => <>);
      USART6_Periph.CR1 :=
        (UE => 1,
         RE => 1,
         TE => 1,
         others => <>);
      USART6_Periph.CR2 := (others => <>);
      USART6_Periph.CR3 := (others => <>);
   end Initialize;

   -----------------
   -- Is_Tx_Ready --
   -----------------

   function Is_Tx_Ready return Boolean is
     (USART6_Periph.ISR.TC = 1);

   -----------------
   -- Is_Rx_Ready --
   -----------------

   function Is_Rx_Ready return Boolean is
     (USART6_Periph.ISR.RXNE = 1);

   ---------
   -- Get --
   ---------

   function Get return Character is (Character'Val (USART6_Periph.RDR.RDR));

   ---------
   -- Put --
   ---------

   procedure Put (C : Character) is
   begin
      USART6_Periph.TDR.TDR := Character'Pos (C);
   end Put;

   ----------------------------
   -- Use_Cr_Lf_For_New_Line --
   ----------------------------

   function Use_Cr_Lf_For_New_Line return Boolean is (True);

end System.Text_IO;


[FabienC]

Can you post an example of ADA code that accesses registers?

You can have a look here :
https://github.com/AdaCore/Ada_Drivers_Library/blob/master/ARM/STM32/drivers/stm32-dcmi.adb

and the registers are defined here:
https://github.com/AdaCore/Ada_Drivers_Library/blob/master/ARM/STM32/svd/stm32f40x/stm32_svd-dcmi.ads

Looks straightforward, if exceedingly verbose, to my eyes.

What do you find verbose? the code or the register definition?

The only thing that's not immediately obvious to me is "16#0#" -- is this the equivalent of C's 0x notation to denote hexadecimal?

Yes, 16#DEAD_CAFE# is the equivalent of 0xDEADCAFE in C.
But you can also have binary with : 2#0100_0011_1011_1000#.
(Another nice small feature of Ada IMHO)

[Sal Ammoniac]

What do you find verbose? the code or the register definition?

Both.

The only thing that's not immediately obvious to me is "16#0#" -- is this the equivalent of C's 0x notation to denote hexadecimal?

Yes, 16#DEAD_CAFE# is the equivalent of 0xDEADCAFE in C.

I prefer 0xCAFEBABE. 

[nctnico]

I could get used to the underscores to split long numbers!

[Bassman59]

The only thing that's not immediately obvious to me is "16#0#" -- is this the equivalent of C's 0x notation to denote hexadecimal?

Yes, 16#DEAD_CAFE# is the equivalent of 0xDEADCAFE in C.
But you can also have binary with : 2#0100_0011_1011_1000#.
(Another nice small feature of Ada IMHO)

That notion was one of the Ada features which was borrowed by the VHDL implementation team.

[Kalvin]

Here is a nice article of the numeric literals and numeric constants in Ada: "Gem #7: The Beauty of Numeric Literals in Ada"

http://www.adacore.com/adaanswers/gems/ada-gem-7/

There are examples on following topics:

- Showing numeric literals in different bases
- Showing exponent notation on different bases
- Explaining how numerical constants and rational numbers are evaluated during compilation time

[FabienC]

In case you missed it, I'm on embedded.fm podcast this week to talk about Ada and the competition.

http://embedded.fm/episodes/158

[C]

Check out "GNAT Programming Studio"


and where Verbose & language that allows easy parser pays you back even more,
make sure to watch the second video
GPS Demo - Smart Completion


Type more and get better programs that are easer to read while being more error free and saving time.


======
Been reading this thread and have seen some wrong info.

Some are complaining about "verbose"

Yet here you are at this site looking at, reading and using "verbose" code!!
===============

Compared to HP Pascal, Turbo Pascal was a very very poor compiler.
When you shift to a higher level language, the compiler has to get smarter.
type
  bit = [0.1]
var
 graphics_display = array[0..255,0..255] of bit;

Good compiler uses 8kb while bad compiler(turbo pascal Z80) uses 64kb. One fits in a Z80 while second is a fail. Said a second way fast used a byte and burns memory while the other requires a smarter compiler uses the binary logic instructions of CPU to do the job giving slower code with less memory use.

Most instructions on a Z80 are encoded in octal.

Type
  two_bit = [0..3]
  octal     = [0..7]
Instruction_type = packed record
 Ins_High : two_bit;
 Ins_Mid   : octal;
 ins_Low  : octal;
end;

A good compiler will pack that record to 8 bits in size while a bad will give 3 bytes.
With a good compiler you can add a case to the record for the 16 bit instructions.
The bad compiler forces you to add more code or do it a different way. The different way often is harder to read and check.

One question to ask is your compiler your friend that helps or something much less.

[CatalinaWOW]

Check out "GNAT Programming Studio"


and where Verbose & language that allows easy parser pays you back even more,
make sure to watch the second video
GPS Demo - Smart Completion


Type more and get better programs that are easer to read while being more error free and saving time.


======
Been reading this thread and have seen some wrong info.

Some are complaining about "verbose"

Yet here you are at this site looking at, reading and using "verbose" code!!
===============

Compared to HP Pascal, Turbo Pascal was a very very poor compiler.
When you shift to a higher level language, the compiler has to get smarter.
type
  bit = [0.1]
var
 graphics_display = array[0..255,0..255] of bit;

Good compiler uses 8kb while bad compiler(turbo pascal Z80) uses 64kb. One fits in a Z80 while second is a fail. Said a second way fast used a byte and burns memory while the other requires a smarter compiler uses the binary logic instructions of CPU to do the job giving slower code with less memory use.

Most instructions on a Z80 are encoded in octal.

Type
  two_bit = [0..3]
  octal     = [0..7]
Instruction_type = packed record
 Ins_High : two_bit;
 Ins_Mid   : octal;
 ins_Low  : octal;
end;

A good compiler will pack that record to 8 bits in size while a bad will give 3 bytes.
With a good compiler you can add a case to the record for the 16 bit instructions.
The bad compiler forces you to add more code or do it a different way. The different way often is harder to read and check.

One question to ask is your compiler your friend that helps or something much less.

Your definitions of good and bad compiler make assumptions about the proper figure of merit.  Small memory consumption good, no penalty for packing/unpacking bytes.  While that may be true in many cases, it is not always true.  There are many other possible figures of merit, and different applications and different people will value them differently.  Some of them include price, execution speed, error handling, coding environment, library availability, native variable types, available training and available target processors. 

One of my pet peeves about most languages as a modeler and analysis type is the lack of a complex variable type.  Fortran has it, and it can be achieved in C++ and in Ada through operator overloading.  The kludges implemented in other languages (CMUL(variable1,variable2) for example) are painful to read and difficult to decode.  Since most people don't need complex arithmetic for their applications (GUIs, bit bangers, compilers and the like) complex math is not part of most popular languages.   I have difficulty rating any of them as superior for my applications.

This is not to say that Turbo Pascal is a good compiler.  It doesn't have complex variables either, for example.   I will argue that it was the best compiler available for CP/M systems for many purposes at the time.  It was so good that I switched from another language that I was very comfortable with, to the in many ways strange Turbo Pascal because time to solution was so much faster.  It was several years before competitive options came along.

[rstofer]

Turbo Pascal is still available!  I used it a few years ago to code up, wait for it..., a maze solver!  I wanted a simple graphic display of the first and second pass.  I have a DOS style graphics window with boxes and the little robot wanders through the field.  Flood-fill is an interesting algorithm!

The videos above are excellent.  I have downloaded the Libre GNAT package twice and both times sat around wondering why I wasn't getting a download.  There is a link "GNAT Ada 2016" that doesn't look like a link and expands (see the little triangle?  I overlooked it twice!).  Then check the file boxes and you're good to go.

The IDE works well on my Win 10 desktop with Microsoft Wireless Mouse and not so well on my Surface Book with the Microsoft Arc Touch Mouse.  On the Book, I can't get the caret to place anywhere near where I want it.  I need to do some more work on this.  In any event, everything is fine on my desktop.

[C]

CatalinaWOW

Sorry typo in my last
A
  graphics_display = array[0..255,0..255] of bit;

Is compiler choice for size of array

graphics_display = packed array[0..255,0..255] of bit;

Tells compiler to make it small
Good compiler this becomes 8kb.
Bad compiler uses more and will not pack to actual size, for example turbo pascal Z80 uses 64kb

So The good compiler you have a choice, small memory at a loss of speed or large memory and gain of speed.

You have two things happening here
Memory alignment and padding of actual size.
The second example, the instruction set record shows a fail of bad compiler lack of smarts.
A forced alignment of byte size removes the need for the compiler to handle the 0 bit of a variable not being the 0 bit of a byte. Less code needed in compiler and you get three bytes for record size.
A forced size or padding to byte size again removes the need for some code in the compiler.

Removing the PACKED lets the size increase.

The good compiler gives you a choice that functions.
 
To me a good compiler gives you choices.


 

[westfw]

Compared to HP Pascal, Turbo Pascal was a very very poor compiler.

HP had a Z80 CP/M or 8086 MSDOS Pascal Compiler?  IIRC, the main competitors of Turbo Pascal involved P-code interpreters...

The videos above are excellent.

I'm not surprised.  I've run into AdaCore at several trade shows, and always been favorably impressed by their professionalism and enthusiasm (for Ada.)  Exactly the sort of compiler company I'd want to deal with, if I were using Ada, and if I could afford it...  The open source version and the contest are fine ideas.  It might be nice to have a non-viral version of the compiler be among the prizes...

16#DEAD_CAFE# is the equivalent of 0xDEADCAFE in C.

Seems reasonable; I bet it's nice and easy to parse, too :-)
One of the "shocking" things looking at Ada is that SO many modern languages have implemented relatively C-like syntax, it's really a bit disconcerting to see something so ... different.   I look at statements like:

      GPIOC_Periph.AFRL.Arr      (6 .. 7) := (AF_USART6,   AF_USART6);
      USART6_Periph.CR2 := (others => <>);

and I haven't really got a clue - they look very foreign and not at all intuitive.  But I suspect they wouldn't be bad at all once I get used to it  (cynically: "well, yeah, but at least "is begin" is much more intuitive than "{", right?")

[nctnico]

I guess that if you (like me) know your way around in VHDL then ADA is only a small step further.

[CatalinaWOW]

While Turbo Pascal had P-code interpreters for competition at the time, I was making a more general statement.  As far as I can remember, or could tell at the time, it was the best CP/M  natively hosted high level language period.  At the time I had paid hundreds of dollars (hobby/moonlight work 1980s dollars) for an IBM Fortran compiler and for the Microsoft family of compilers (Basic, Fortran, COBOL (!!!!) and the associated Assembler).   Working off of 8 inch floppy drives, the high price commercial compilers had a one hour turn around, and no IDE.  So you used your favorite editor, submitted the code, watched the lights flash for a long time, eventually got code to load and try.  There was an off ramp about a half hour in if the parser found syntax errors.  Most of an hour before you could see if your code worked.  Turbo Pascal was $39.95, had an IDE, generated executable code in well under 5 minutes and had enough extensions on the teaching language to let you get at the hardware bits if you needed to.  GCC and its ilk was more than a decade in the future, and the early incarnations of GCC were not friendly to those who didn't breath it full time.  Turbo Pascal had warts, and yes memory usage was one, but it was a bush in a field of grass.  Now there are trees and the bush looks small, but it ruled the era.

There might have been (probably were) better cross compilers running on PDP-8s, PDP-11s, HP 1000s or the IBM 370s or Burroughs 8700s, but that wasn't the real world for most people who weren't being paid to do microprocessor development.  Even for those of us who were, many of our employers didn't look fondly on doing things other than what we were paid to do, so our home fun was restricted to the compilers hosted on the one of the microcomputers of the time.

[C]

Compared to HP Pascal, Turbo Pascal was a very very poor compiler.

HP had a Z80 CP/M or 8086 MSDOS Pascal Compiler?  IIRC, the main competitors of Turbo Pascal involved P-code interpreters...

I have no idea, Think there was a HP Pascal for MSDOS.

Pascal cross compiler for about all microprocessors.
1980 HP64000 A microprocessor development system.
https://en.wikipedia.org/wiki/HP_64000
Probably created for use in one or more HP divisions internal use then sold to public starting in 1980.

I used HP Pascal on a 9826 series 200 which was 68000 based.
Pascal was foundation for all software on this series computers. From documents I have, almost no assembly source was used.


Think about that P-code a bit.
Java & .net are newer versions of P-code.
The interpreters make for easer debug while not preventing compile to native code.
 
I think a lot of people do not know how into computers HP was back then. They created CPU chips & modules and the software needed.

[boz]

Hey guys, some of use still use pascal, go and find someone elses lawn to piss on 

[Sal Ammoniac]

For embedded C development I use Eclipse+CDT and GCC. CDT is the component that ties Eclipse, GCC, and the hardware debugger interface together and makes it all work.

Is there an equivalent of CDT that would let me use Eclipse to do embedded development in Ada on Cortex-M MCUs?

[rstofer]

I don't know the right answer but Ada is compiled using GCC.  Since Eclipse usually uses a Makefile, what difference does it make what language is being written?
The AdaCore IDE is quite nice but there is a certain synergy of using Eclipse as the IDE for all kinds of projects.  I haven't tried it with Ada or Fortran but, given a Makefile, it shouldn't matter.

[nctnico]

For embedded C development I use Eclipse+CDT and GCC. CDT is the component that ties Eclipse, GCC, and the hardware debugger interface together and makes it all work.

Is there an equivalent of CDT that would let me use Eclipse to do embedded development in Ada on Cortex-M MCUs?

I've seen an Ada plugin for Eclipse on Adacore.com . I don't know if they got to debugging but I suspect GDB should understand Ada too.

[Kalvin]

Here is an overview of the tools supported by Adacore:
http://www.adacore.com/gnatpro/toolsuite/

Information about the Programming IDE:
http://www.adacore.com/gnatpro/toolsuite/gps/
- Supports at least Ada, C, C++

Information about the Visual Debugger:
http://www.adacore.com/gnatpro/toolsuite/debugger/
- Ability to debug at source and machine levels
- Multi-language support: Ada, C and C++

Debugging with GDB:
http://docs.adacore.com/gdb-docs/html/gdb.html
- Supports Ada, C, C++ and other languages

[Sal Ammoniac]

 

(note that their "pro" version has a modified license...)
("Pricing for GNAT Pro subscriptions starts at $15,000"

That's steep. And I thought Keil and IAR at around $5000 a seat were expensive...

At that price I doubt there's going to be many companies currently developing in C switching over, or even considering it. Only companies with deep pockets (like government contractors) are going to be willing to take the risk of moving to a new language and new development platform.

AdaCore would probably do better in the long run by bootstrapping their user base with a commercial product in the $1500 range. Give companies an incentive to consider switching, not a disincentive. 

[autobot]

There is a very uncomfortable number of truths in that fqa.

After trying haskell

I'm curious: in the context of embedded systems(either large mcu or mpu), do you think functional programming either in in c++(what's possible) or in haskell, are a good way to produce highly reliable code  ?

[rstofer]

I have an OPINION...  It's probably wrong but here goes:  I don't want the compiler to do anything that I don't explicitly tell it to do.  I don't want objects created and destroyed, I don't even want a heap in memory.  I want simple structures and generic C.  I absolutely do not want the advanced features of C++.  For embedded programming, they don't bring anything to the dance.

I don't know anything about Haskell or why I would want to use it.  There are probably a thousand language variants and I can't conceive of being able to check them all.  Furthermore, I'm just about of the opinion that the only compiler I want to use is GCC.  Why?  Because it's tested on millions of lines of code by thousands of programmers every single day!  Just building Linux is a huge deal!  Anything that can build a complete OS (not just a toy RTOS) is the kind of toolchain I want to use.

I might be willing to negotiate on the heap after I review the heap manager.  Garbage collection is a complicated issue!

I'm talking only about embedded programming.  If the program is intended to cure world hunger, use C++, of Java if you don't mind waiting...


I am going to try Ada and I would like to try Oberon (derived from Modula 2 which was derived from Pascal) but I am still anticipating simple, clean code.

[FabienC]

For those who wants more info on Ada for embedded, here's an article from Jerome and myself https://community.arm.com/groups/embedded/blog/2016/07/08/ada-driver-library

[rstofer]

Success!  I got the LED Demo running on my STM32 F4 Discovery board.  It pays to use the proper board when first starting up!

This is the board that works:
http://www.digikey.com/product-detail/en/stmicroelectronics/STM32F407G-DISC1/497-16287-ND/5824404

It has about 80 IO lines to play with plus another 20 assorted Vcc, Gnd and Misc. lines.

Since the ST-Link V2 adapter is built in, there is nothing else to buy.