Question structure de données

[DrPi]

Bonjour,

Je code une librairie qui s'interface sur une API (twain) qui permet à
l'application de découvrir les capacités du matériel à l'exécution.

Une capacité a un type de base parmi les suivants :

type t_TWTY is (TWTY_INT8,
TWTY_INT16,
TWTY_INT32,

TWTY_UINT8,
TWTY_UINT16,
TWTY_UINT32,

TWTY_BOOL,

TWTY_FIX32,

TWTY_FRAME,

TWTY_STR32,
TWTY_STR64,
TWTY_STR128,
TWTY_STR255,
TWTY_HANDLE
);

Donc, une donnée sur 8bits signés ou sur 16bits signés ou...

Par dessus le type de base, il y a le type de conteneur :

type t_ConType is (TWON_ARRAY,
TWON_ENUMERATION,
TWON_ONEVALUE,
TWON_RANGE,
);

Donc, une donnée unique ou un tableau de données ou...

Comme je crée une librairie de haut niveau, je voudrais une abstraction
supplémentaire du type de données. Par exemple, une capacité de type
TWON_ONEVALUE / TWTY_UINT32 pourrait correspondre à un bit-mask de
fonctionnalités possibles (record de booléens - 1 bit par booléen).

Il y a des capacités prédéfinies par la documentation de l'API twain.
Mais la plupart des capacités sont à découvrir "à la volée".

Le but est que la librairie construise une structure de données
utilisable par l'application.

Je ne vois pas comment coder ça intelligemment en Ada (je saurais le
faire à la C).

Je suis preneur de toute information pouvant m'éclairer ;)

Nicolas

[J-P. Rosen]

Hmmm... Je ne comprends pas bien ce que tu veux faire (je suppose que
les autres du groupe non plus, sinon tu aurais déjà eu des réponses ;-))

Peux-tu préciser un peu, ou dire comment tu le ferais en C?

--
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
https://www.adalog.fr https://www.adacontrol.fr

[DrPi]

Le 05/10/2023 à 13:28, J-P. Rosen a écrit :
> Hmmm... Je ne comprends pas bien ce que tu veux faire (je suppose que
> les autres du groupe non plus, sinon tu aurais déjà eu des réponses ;-))
>

C'est ce que je me suis dit aussi.

> Peux-tu préciser un peu, ou dire comment tu le ferais en C?

J'y réfléchis.
C'est toujours compliqué d'expliquer des problèmes complexes. En ce
moment, je n'ai pas le temps de me pencher sur la question. Mais mon
cerveau y travaille tout seul en tâche de fond ;)
Quand ça sera mûr, je reposterai ici.

Merci de m'avoir lu.

[Stéphane Rivière]

Pas sûr de comprendre ton besoin (Twain ? c'est du scan ça, non ?) mais,
par exemple, si l'idée est d'examiner le hardware, 'capacité' par
'capacité', on pourrait imaginer :

Une première structure dans un conteneur, stockant les 'capacités'.

Dans cette structure, tu as un type qui pointe sur un second conteneur
qui décrit chaque 'capacité'.

Dans cette nouvelle structure tu as des types pour décrire les éléments
communs à toutes les 'capacités' et un type vers...

Un troisième conteneur, dont le type est clé-valeur pour enregistrer
toutes les caps spécifiques à cette 'capacité'.

Tu disposes alors de trois conteneurs structurants mais qui s'adapteront
à toutes les 'capacités' présentes et futures.

Ada à de très beaux conteneurs¹ et le résultat est beau et puissant.

Je ne suis pas si je suis très clair mais j'aurais tenté de faire le
canard en plastique².


¹ Et le compilo Ada super fort pour relever une erreur de logique dans
les itérations, je me suis fait avoir dernièrement comme un nigaud,
merci aux copains de m'avoir ouvert les yeux :).


² https://fr.wikipedia.org/wiki/M%C3%A9thode_du_canard_en_plastique





Je

--
Stéphane Rivière
Ile d'Oléron - France

[DrPi]

Le 07/10/2023 à 09:47, Stéphane Rivière a écrit :
>
> Pas sûr de comprendre ton besoin (Twain ? c'est du scan ça, non ?) mais,
> par exemple, si l'idée est d'examiner le hardware, 'capacité' par
> 'capacité', on pourrait imaginer :
>
> Une première structure dans un conteneur, stockant les 'capacités'.
>
> Dans cette structure, tu as un type qui pointe sur un second conteneur
> qui décrit chaque 'capacité'.
>
> Dans cette nouvelle structure tu as des types pour décrire les éléments
> communs à toutes les 'capacités' et un type vers...
>
> Un troisième conteneur, dont le type est clé-valeur pour enregistrer
> toutes les caps spécifiques à cette 'capacité'.
>
> Tu disposes alors de trois conteneurs structurants mais qui s'adapteront
> à toutes les 'capacités' présentes et futures.
>

J'avais dans l'idée de créer une classe pour le 2eme conteneur et
une/des classe(s) héritée(s) du 2eme conteneur pour le 3eme conteneur.

Mon problème se situe au niveau du 3eme conteneur. Je ne sais pas quels
"éléments" mettre dans les classes.

> Ada à de très beaux conteneurs¹ et le résultat est beau et puissant.
>

Ca c'est une bonne idée.
Je ne sais pas pourquoi mais j'étais focalisé sur l'utilisation des
types de base du langage (array, record...).
Utiliser aussi des conteneurs (vector, map...) est sûrement la solution.

> Je ne suis pas si je suis très clair mais j'aurais tenté de faire le
> canard en plastique².

Je fais ça parfois avec des collègues et en général c'est très efficace.
Je ne savais pas que ça s'appelle "méthode du canard en plastique".

>
>
> ¹ Et le compilo Ada super fort pour relever une erreur de logique dans
> les itérations, je me suis fait avoir dernièrement comme un nigaud,
> merci aux copains de m'avoir ouvert les yeux :).
>

Qu'est-ce que tu entends par "erreur de logique dans les itérations" ?

[Stéphane Rivière]

>> Ada à de très beaux conteneurs¹ et le résultat est beau et puissant.
>>
> Ca c'est une bonne idée.
> Je ne sais pas pourquoi mais j'étais focalisé sur l'utilisation des
> types de base du langage (array, record...).
> Utiliser aussi des conteneurs (vector, map...) est sûrement la solution.

Dynamisme, souplesse, ça manque un peu d'exemples dès qu'on dépasse le
conteneur qui ne contient qu'un type de base mais je peux te passer des
exemples plus complexes (voir déjà un exemple d'instanciation plus bas).
À priori vecteur dans ton cas.

> Je fais ça parfois avec des collègues et en général c'est très efficace.
> Je ne savais pas que ça s'appelle "méthode du canard en plastique".

Méthodologie efficace pour tout problème qui fait face à un biais de
confirmation (la personne a la solution devant son nez mais ne la voit
pas car elle est scotchée dans un raisonnement d'habitude, ou qu'elle
est fatiguée, etc. - c'est typique des erreurs de pilotage, CFIT, etc.)

> Qu'est-ce que tu entends par "erreur de logique dans les itérations" ?

J'étends un code existant depuis deux ans, qui gaze façon coucou suisse,
historiquement capable de traiter une DB, soudainement étendu par mes
soins à 'n' DB.

Pour ce faire, à la fin de chaque traitement de DB, je dois alors
effacer le conteneur ayant enregistré le dictionnaire de données,
enregistré dans un conteneur nommé Schema.

Alors c'est le drame.

L'erreur : "attempt to tamper with cursors" (quand même :)

================================================

Dans l'ads j'ai :

---------------------------------
type Schema_Line is record
Command : Schema_Command;
Name : String;
Attribute : String;
Comment : String;
end record;

package Schema_Lines_List is new Ada.Containers.Vectors (Index_Type
=> Natural, Element_Type => Schema_Line);

private

Schema : Schema_Lines_List.Vector;
---------------------------------

Dans l'adb, je m'en sert à chaque nouvelle DB à ouvrir/créer pour
recueillir tout le schéma de la DB. Mais à la fin du traitement d'une
DB, je souhaite vider cette liste pour une éventuelle autre DB... Dans
la fonction de finalisation, j'ai tout essayé, genre :


---------------------------------
C : Schema_Lines_List.Cursor := Schema.First;
Next : Schema_Lines_List.Cursor;
use Schema_Lines_List; -- < obligatoire pour gérer les opérateurs
begin

-- D'abord la procédure normale :
Schema.Clear;

-- Puis une manip de Jeffrey Carter (en sauvegardant le Curseur
pour tromper le compilo)
loop
exit when C = Schema_Lines_List.No_Element;
declare
begin
Next := Schema_Lines_List.Next (C);
Schema.Delete (Position => C);
C := Next;
end;
end loop;

-- À l'envers pour éviter le déférencement (sic, cf les
relations entre les curseurs, index et les élements, c'est très très lié)
for J in reverse 1 .. Schema.Last_Index loop
Schema.Delete (J);
end loop;

-- Et même un simple Delete_Last
Schema.Delete_Last;
---------------------------------

Dans tous les cas, j'ai :

-------------------------------------------------------------------------------------
Exception time : 20230907-155408
Program uptime : 0h0 0m0 0s
Program build DT stamp : build 2023-09-07 15:53:58
Program name & version : testapi v0.7
Library name & version : v22 v0.1
Start directory : /home/sr/opt/v22/bin
Home directory : /home/sr
Ada mem. alloc. (bytes): Ada Cur: [ 12540 ] Max: [ 19672 ]
All mem. alloc. (bytes): All Cur: [ 15335424 ] Max: [ 15335424 ]

raised PROGRAM_ERROR :

v22.Sql.Schema_Lines_List.Implementation.TC_Check: attempt to tamper
with cursors

================================================

J'y passe des heures à codouiller des workarounds quand
l'excellentissime Gautier (De Montmollin) d'un coup d’œil, "trouve la
panne" (située ailleurs, dans une autre procédure), je le cite :


Hum, en effet, en lisant le code, ça a peu de chances de marcher. Il
faut remercier GNAT pour transformer le "peu de chances" en "aucune
chance" :-)

807 et suivants:

for I of Schema loop
...

-- Finalize
if I = Schema.Last_Element then
Finalize_Loop;
-- Update database schema version
Set_Config (DB, "Schema_Version", DB_Version);
end if;
end loop;

================================================


Dans Finalize_Loop il y a l'appel à l'effacement de tous les éléments du
conteneur Schema alors qu'on est dans une boucle for I of Schema loop

Big up for Gautier et le compilateur¹, deux amis bienveillants :)

[Stéphane Rivière]

> Mon problème se situe au niveau du 3eme conteneur. Je ne sais pas
> quels "éléments" mettre dans les classes.

Des classes sont-elles nécessaires ? Le premier conteneur contient le
type du second conteneur qui contient lui-même le type du troisième
conteneur.

Tu peux faire toutes les recherches que tu souhaites en itérant à la
vitesse de la ram, vu que ça va pas faire de gros volumes...

Le premier conteneur peut contenir des capacités (si j'ai bien compris) :

hardisk
ram
network
...
printers
scanners
...
details : type du second conteneur


le second conteneur pourrait contenir

name (sda1, eth0, <printer-name>, ...)
extended name
state (ready, up, down, not connected, etc.
caps : 1To, 64Go, 1Gbps, etc...
extended caps : NVMe, SSD, DDR5, copper, fiber, satellite, B&W printer,
Duplex scanner, etc...
...
extended caps : type du troisième conteneur


le troisième conteneur pourrait contenir

key
value

Et là, tu mets le fourre-tout des caps particulières de ton hardware,
périphérique, pilote magique, etc...


Une classe pour l'ensemble pourquoi pas (quoique un paquetage standard
me semblerait suffisant, à moins que tu souhaites manipuler plusieurs
ensembles à la fois) mais pourquoi plusieurs classes pour chaque niveau
de conteneur ?


PS

J'ai été voir ton site, 1) j'aime bien la résistance en 'macramé' (une
22 ohms 5% a priori :) 2) et la réflexion de... "mais y'a pas mieux que
le C dans ma vie de dev ?

Une remarque très juste : "La courbe d'apprentissage est vraiment
raide. Le langage est vraiment complet. Du coup, ça rend son
apprentissage plus long. Et chaque version d'Ada en rajoute une couche.
Mais plus j'avance dans mon apprentissage, plus je trouve le langage
intéressant."

J'ai appris Ada ainsi : d'abord comme une sorte de 'Super Pascal', puis
ensuite, j'ai lu le RM (super lecture, la mère de toutes les lectures,
on y découvre des perles) et aussi tout ce qu'à produit Jean-Pierre
(beaucoup de communications) et l'autre mère de toutes les lectures :

https://fr.wikibooks.org/wiki/M%C3%A9thodes_de_g%C3%A9nie_logiciel_avec_Ada

J'ai eu la chance de trouver une version papier, d'occasion, en très bon
état, planquée tout en haut d'une étagère, à peine visible (mais je
connaissais la couverture) dans un coin poussiéreux de l'ancien Gibert
Jeunes. Celle-là, elle m'attendait !

J'ai appris "bout par bout", sans me soucier de tout comprendre
d'un coup, en fonction de mes besoins (et je n'ai toujours pas tout
compris, loin de là).

Et puis la communauté Ada est extrêmement bienveillante. Ça aide pour
progresser.

Enfin, la productivité de Ada est simplement phénoménale. Et le nombre
de lignes actives pour un problème donné étonnamment faible. Ada est,
sur la totalité d'une application) beaucoup moins verbeux que le C ou le
C++ :)

Rust, j'ai regardé la syntaxe, regardé à nouveau, puis j'ai... euh...
écarquillé les yeux façon hiboux (chercher rust ugly syntax, y'a du lourd)


Tu peux pratiquer Ada également sur AVR¹ ou STM32, ainsi que plein
d'autres microcontrôleurs... Une soluce ici avec gnatstudio et le
débuggueur intégré fonctionnel (dev sur uP sans debugger, je sais pas
faire).

¹https://github.com/sowebio/adam-doc


Étant électronicien à la base (numérique, radio, microcontrôleurs), au
niveau FPGA/VHDL (que je connais pas), j'aimerai bien savoir sur quelle
base (raisonnablement économique) je pourrais me fonder pour m'initier
(en VHDL impérativement, pas du chinois, préférablement de l'européen
mais je sais que je rêve, avec un environnement de préférence libre et,
à défaut, sans procédure de licence de dingue. Et sous Linux pour
"simplifier" le choix :)

L'idée serait de pouvoir me composer un FPGA avec un bloc
"microprocesseur" compatible avec un compilo Ada et du hardware rapide
(décodeur I/Q, PLL et autre blocs fonctionnels ou coder ne suffit plus).

[DrPi]

Le 08/10/2023 à 10:54, Stéphane Rivière a écrit :
>
>
> Dynamisme, souplesse, ça manque un peu d'exemples dès qu'on dépasse le
> conteneur qui ne contient qu'un type de base mais je peux te passer des
> exemples plus complexes (voir déjà un exemple d'instanciation plus bas).
> À priori vecteur dans ton cas.
>

C'est vrai que les exemples un peu évolués sont plutôt rares.

>> Je fais ça parfois avec des collègues et en général c'est très
>> efficace. Je ne savais pas que ça s'appelle "méthode du canard en
>> plastique".
>
> Méthodologie efficace pour tout problème qui fait face à un biais de
> confirmation (la personne a la solution devant son nez mais ne la voit
> pas car elle est scotchée dans un raisonnement d'habitude, ou qu'elle
> est fatiguée, etc. - c'est typique des erreurs de pilotage, CFIT, etc.)

Exactement. Quand tu écris une connerie, tu peux relire autant de fois
que tu veux, tu reliras toujours ce que tu penses avoir écrit, non pas
ce que tu as réellement écrit.

>
>> Qu'est-ce que tu entends par "erreur de logique dans les itérations" ?
>
> J'étends un code existant depuis deux ans, qui gaze façon coucou suisse,
> historiquement capable de traiter une DB, soudainement étendu par mes
> soins à 'n' DB.
>
> Pour ce faire, à la fin de chaque traitement de DB, je dois alors
> effacer le conteneur ayant enregistré le dictionnaire de données,
> enregistré dans un conteneur nommé Schema.
>
> Alors c'est le drame.
>
> L'erreur : "attempt to tamper with cursors" (quand même :)

Autant faire les choses bien ;)

> ================================================
>
> Dans l'ads j'ai :
>
> ---------------------------------
> type Schema_Line is record
>       Command : Schema_Command;
>       Name : String;
>       Attribute : String;
>       Comment : String;
>    end record;
>

Ah, tiens, je croyais qu'on ne peux pas mettre des String non bornées
dans un record.

> Dans Finalize_Loop il y a l'appel à l'effacement de tous les éléments du
> conteneur Schema alors qu'on est dans une boucle for I of Schema loop
>
> Big up for Gautier et le compilateur¹, deux amis bienveillants :)
>

+1 Pour le compilateur. Et pour Gautier aussi bien sûr ;)

[DrPi]

Le 08/10/2023 à 11:34, Stéphane Rivière a écrit :
> Une classe pour l'ensemble pourquoi pas (quoique un paquetage standard
> me semblerait suffisant, à moins que tu souhaites manipuler plusieurs
> ensembles à la fois) mais pourquoi plusieurs classes pour chaque niveau
> de conteneur ?
>

Je vais y réfléchir. Je suis comme une machine à vapeur. Le temps de
chauffe est long ;)

>
> PS
>
> J'ai été voir ton site, 1) j'aime bien la résistance en 'macramé' (une
> 22 ohms 5% a priori :)

C'est bien ça :)
C'est ma femme qui l'a crochetée à ma demande.

2) et la réflexion de... "mais y'a pas mieux que
> le C dans ma vie de dev ?
>

Ah oui, ça c'est un peu comme un rêve. Au boulot, j'utilise QNX comme
OS. C'est génial. Les drivers sont des applications comme les autres
avec "juste" le droit d'accéder au matériel en plus. Du coup le système
est hyper stable. Sauf que les applications sont écrites en C. Un jour
j'ai pris conscience du coté aberrant de la chose et c'est à partir de
là que j'ai commencé à apprendre Ada.
En fait, alors que je faisais fausse route avec Rust, j'ai vu une pub
pour GNAT Pro pour QNX sur le WEB. J'ai contacté Adacore, bien discuté,
et je me suis dit que je devais essayer Ada avant de tenter la demande
d'achat de GNAT Pro à ma hiérarchie. C'est comme ça que j'ai commencé à
apprendre Ada à la maison.
Je me suis dit que je pourrais aussi utiliser Ada sur micro-contrôlleur
mais là, je suis resté sur ma faim. Pour moi, les runtime existantes, en
tout cas celles que je connais, ne sont adaptées à l'usage que
j'aimerais en faire.

> Une remarque très juste : "La courbe d'apprentissage est vraiment
> raide. Le langage est vraiment complet. Du coup, ça rend son
> apprentissage plus long. Et chaque version d'Ada en rajoute une couche.
> Mais plus j'avance dans mon apprentissage, plus je trouve le langage
> intéressant."

Tout à fait.

> J'ai appris Ada ainsi : d'abord comme une sorte de 'Super Pascal', puis
> ensuite, j'ai lu le RM (super lecture, la mère de toutes les lectures,
> on y découvre des perles) et aussi tout ce qu'à produit Jean-Pierre
> (beaucoup de communications) et l'autre mère de toutes les lectures :
>
> https://fr.wikibooks.org/wiki/M%C3%A9thodes_de_g%C3%A9nie_logiciel_avec_Ada

Je l'ai lu aussi. Très instructif. Merci Jean-Pierre ;)

>
> J'ai eu la chance de trouver une version papier, d'occasion, en très bon
> état, planquée tout en haut d'une étagère, à peine visible (mais je
> connaissais la couverture) dans un coin poussiéreux de l'ancien Gibert
> Jeunes. Celle-là, elle m'attendait !
>
> J'ai appris "bout par bout", sans me soucier de tout comprendre
> d'un coup, en fonction de mes besoins (et je n'ai toujours pas tout
> compris, loin de là).
>
> Et puis la communauté Ada est extrêmement bienveillante. Ça aide pour
> progresser.

Oui, il y a des personnes très compétentes sur les newsgroups.
Je suis également abonné à des rooms Matrix mais la qualité des échanges
n'est pas du tout la même.

> Enfin, la productivité de Ada est simplement phénoménale. Et le nombre
> de lignes actives pour un problème donné étonnamment faible. Ada est,
> sur la totalité d'une application) beaucoup moins verbeux que le C ou le
> C++ :)

Pas pour moi. Du moins, pas encore. J'ai trop de lacunes, principalement
à cause de ma mauvaise mémoire. Il y a tellement de choses à retenir...
que je lis... et oublie...
Mais à force d'y revenir, ça finit par rentrer dans ma tête :)

Genre, récemment, j'ai voulu utiliser un "private package". Je le code,
je fais le "with" qui va bien et le compilo m'envoie paître. Je
comprends que je n'ai pas le droit de faire un "with" dans la partie
publique de la spécification du package qui l'utilise. Mais je veux m'en
servir dans la partie privée uniquement. Normal, il est privé. Et je ne
peux pas mettre le "with" dans la partie privée de la spécification
alors je me dis m... je ne peux m'en servir que dans le "package body".
Et ce n'est pas ce que je veux. Alors je défais tout et je refais
autrement en me disant que tant pis. Mais je me dis aussi que cette
limitation est bizarre. Ca n'est pas dans l'esprit du langage. Alors je
me mets à chercher et je finis par trouver le précieux "private with"
(pas facile à trouver). Et je recode tout comme je le voulais en me
maudissant parce que je me suis souvenu que je l'avais déjà lu quelque
part...

> Rust, j'ai regardé la syntaxe, regardé à nouveau, puis j'ai... euh...
> écarquillé les yeux façon hiboux (chercher rust ugly syntax, y'a du lourd)

Je suis d'accord. C'est abominable.

> Tu peux pratiquer Ada également sur AVR¹ ou STM32, ainsi que plein
> d'autres microcontrôleurs... Une soluce ici avec gnatstudio et le
> débuggueur intégré fonctionnel (dev sur uP sans debugger, je sais pas
> faire).

Sur micro-contrôlleur, à part en baremetal, c'est pas vraiment
utilisable pour ce que j'aimerais en faire.
Il y a longtemps que je ne fais plus de baremetal sur µP. J'utilise
toujours tout un tas de tâches pour bien séparer la gestion des divers
éléments logiciels/matériels. Une des grosses limitations des runtimes
sur µP, c'est l'impossibilité d'utiliser un timeout dans une tâche. Et
ça c'est rédhibitoire. Quand le hardware ne répond pas, il faut le
gérer. Certes, il y a moyen de contourner le problème à peu près
correctement mais cela complexifie beaucoup le programme. Et ça reste de
l'à peu près. Le modèle de "tasking" de Ada est vraiment intéressant. Si
je change de langage, c'est pour me simplifier la vie, pas pour la
complexifier.

> Étant électronicien à la base (numérique, radio, microcontrôleurs), au
> niveau FPGA/VHDL (que je connais pas), j'aimerai bien savoir sur quelle
> base (raisonnablement économique) je pourrais me fonder pour m'initier
> (en VHDL impérativement, pas du chinois, préférablement de l'européen
> mais je sais que je rêve, avec un environnement de préférence libre et,
> à défaut, sans procédure de licence de dingue. Et sous Linux pour
> "simplifier" le choix :)

J'adore les FPGAs ! :)
Vu que l'on est hors sujet, je vais essayer d'être bref.

Des puces FPGA européennes, y a pas. Il y a essentiellement de
l'américain et du chinois. Pour les puces américaines, il y a AMD
(anciennement Xilinx) et Intel (anciennement Altera). Intel va
externaliser sa branche FPGA vers une nouvelle société dont on ne sait
encore rien.

je n'ai encore jamais fait d'open source avec les FPGA. Je suis le sujet
d'un peu loin, mes connaissances sont donc réduites/pas à jour sur le sujet.
Pour la chaîne de développement open source, malheureusement, c'est le
verilog qui est omniprésent. Verilog, c'est l'équivalent du C en
FPGA/Asic (VHDL est l'équivalent de Ada). Mais tu dois déjà savoir ça.
Donc, hors verilog, point de salut. Il y a des moulinettes pour
transposer du VHDL en verilog. Mais c'est loin d'être parfait. D'autant
plus que VHDL est un langage complexe et les dernières normes (VHDL-2008
et VHDL-2019) ne sont pas ou peu supportées. Ca s'améliore doucement.
Coté, simulateur, il y a GHDL (écrit en Ada) et nvc. A priori, nvc a un
support de VHDL plus complet que GHDL. Par contre, GHDL est aussi
utilisé pour faire de la synthèse (en transposant en verilog ?), une des
étapes pour implémenter le code dans la puce.
Coté outil de synthèse et placement/routage, il y a yosys (verilog).
Yosys supporte certaines puces ICE40 de Lattice Semiconductor et
quelques puces Xilinx. A savoir que le support des puces est fait
entièrement à partir de reverse engineering. C'est un processus très
long, ce qui explique pourquoi il y a peu de puces supportées. Sans
parler des problèmes de légalité du procédé.
Plus d'infos sur le site de Yosys.
Renesas (japon) a une gamme de petits FPGA intéressants qui utilise
nativement une chaîne de développement open source (Yosys ?). Je leur ai
demandé, il y a 2 ou 3 ans, si le VHDL est supporté. Réponse : Ca va
venir. Apparemment, les puces se font désirer.

Hors open source, les principaux fabricants de FPGA fournissent une
chaîne de développement complète gratuite pour certains de leurs
composants. Je n'utilise pas les FPGA de Intel, donc je ne peux rien
dire. Chez Lattice, il me semble que les outils sont entièrement
gratuits, quelque soit le composant utilisé. A vérifier, je n'ai pas une
grande expérience avec cette marque (mais les composants sont très
intéressants). Pour AMD, l'outil (Vivado en version WEBPACK) est gratuit
pour certains composants choisis par le fabricant. Pour les autres
composants, il faut l'outil payant (plusieurs milliers d'euros). Vivado
existe en version Linux. Chez les autres fabricants, je ne sais pas.
Windows est toujours supporté. Linux ? Mach OS, jamais.

De mon point de vue, pour débuter, commence avec les outils du fabricant.
Aujourd'hui, plein de fabricants de cartes vendent des cartes avec un
FPGA, comme ils vendent des cartes avec un µP. Choisis un carte avec un
FPGA simple et fais toi la main dessus. Ensuite, passe en open source.
Le sujet est complexe. On ne maîtrise pas le développement d'un code
FPGA aussi simplement qu'un code de programmation classique. Autant ne
pas ajouter de difficultés au départ.

> L'idée serait de pouvoir me composer un FPGA avec un bloc
> "microprocesseur" compatible avec un compilo Ada et du hardware rapide
> (décodeur I/Q, PLL et autre blocs fonctionnels ou coder ne suffit plus).
>

Là, tu as 2 voies possibles.
- Le FPGA simple dans lequel tu vas instancier un coeur micro-contrôleur
(au choix).
- Le SOC qui est l'association d'un micro-contrôleur/microprocesseur et
d'un FPGA. Là, le choix est limité entre ARM et RISC-V. En ARM, c'est
soit un micro-contrôleur (Cortex-M), soit un microprocesseur (Cortex-A).
Avec un microprocesseur, tu peux faire tourner un OS (en général Linux)
donc Ada full runtime.
Je ne recommande pas non plus de débuter par un SOC. La complexité de
mise en oeuvre est élevée.

Bon ben voilà, j'ai pas réussi à faire court.
C'est avec plaisir que je continuerais la discussion par e-mail ou sur
Matrix (@drpi:matrix.org).

[Stéphane Rivière]

> Je vais y réfléchir. Je suis comme une machine à vapeur. Le temps de
> chauffe est long ;)

J'avoue être un peu pareil ;)

> C'est bien ça :)
> C'est ma femme  qui l'a crochetée à ma demande.

Nan ? Sériously ? C'est une blague ? Elle est très douée !

> En fait, alors que je faisais fausse route avec Rust, j'ai vu une pub

Ce que j'aime bien avec Rust, c'est que son fond de commerce est bien et
qu'Adacore est liée à la fondation de la rouille, donc ça fait connaître
Ada...

> pour GNAT Pro pour QNX sur le WEB. J'ai contacté Adacore, bien discuté,
> et je me suis dit que je devais essayer Ada avant de tenter la demande
> d'achat de GNAT Pro à ma hiérarchie. C'est comme ça que j'ai commencé à
> apprendre Ada à la maison.

:)

Convaincre ta hiérarchie pourrait passer par un truc assez simple : le
porte monnaie : passer du C/C++ à Ada c'est /3 MINIMUM (c'est du vécu)
le premier livrable client.

> limitation est bizarre. Ca n'est pas dans l'esprit du langage. Alors je
> me mets à chercher et je finis par trouver le précieux "private with"

Ada est plein de ce genre de choses. Il faudrait écrire une compilation
de "use cases" pour les cas qui le méritent...

> correctement mais cela complexifie beaucoup le programme. Et ça reste de
> l'à peu près. Le modèle de "tasking" de Ada est vraiment intéressant. Si
> je change de langage, c'est pour me simplifier la vie, pas pour la
> complexifier.

J'avoue que sur mes uP 8 bits, j'en suis pas là. Pas d'OS, une boucle
infinie dans le main, des machines à états partout, des buffers partout
et une gestion soignée des interruptions. Old school quoi :()

> Des puces FPGA européennes, y a pas. Il y a essentiellement de
> l'américain et du chinois. Pour les puces américaines, il y a AMD
> (anciennement Xilinx) et Intel (anciennement Altera). Intel va

Ah d'ac, les deux gros ont été repris par les deux très gros... J'étais
même pas au courant...

> Pour la chaîne de développement open source, malheureusement, c'est le

.../...

> Bon ben voilà, j'ai pas réussi à faire court.

Ok, merci, t'étais pas vraiment HS avec le VHDL... Ça reste un sacré
truc... Je sauve ton message !

> C'est avec plaisir que je continuerais la discussion par e-mail ou sur

À l'occase. Faut que je creuse. J'aurais tellement souhaité y arriver
par le VHDL. Après une machine virtuelle Windows, pourquoi pas :()

[Stéphane Rivière]

>> ================================================
>>
>> Dans l'ads j'ai :
>>
>> ---------------------------------
>> type Schema_Line is record
>>        Command : Schema_Command;
>>        Name : String;
>>        Attribute : String;
>>        Comment : String;
>>     end record;
>>
> Ah, tiens, je croyais qu'on ne peux pas mettre des String non bornées
> dans un record.

"techniquement", c'est en fait un pointeur car... Oublié de préciser que
dans ce contexte, les premières lignes de v22.ads sont :


with UXStrings; use UXStrings;
subtype String is UXString;

(UXString étant fondé sur de l'Unbounded_String à 4 octets)

C'est sale mais tellement bon.


Comme évoqué lors d'une discussion sur la ml Ada-France avec
Jean-Pierre, qui me disait fort justement :

C'est une mauvaise idée que d'appeler un type utilisateur "String", ou
de n'importe quel autre nom défini dans Standard. Comme Standard est
implicitement le parent de toutes les autres unités, les types y sont
toujours directement visibles, et préférés aux types synonymes que l'on
pourrait croire directement visibles par une clause "use". Ca crée
souvent des confusions, et ça peut jouer dans ton cas.


J'argumentais alors :

Oui, tu as raison bien sûr.

L'idée de Pascal (Blady) est de rendre Gnoga compatible UTF-8 (avec
UXString) sans reprendre toutes les sources. Je trouve que le résultat
est si efficace que j'ai adopté sa technique pour notre nouveau
framework v22, qui utilise Gnoga. Le portage v20 > v22 avec cette astuce
a profondément simplifié le code et sa mise en œuvre.

Je sais bien que ton conseil est le bon. Voici ma justification foireuse
: en pratique on ne manipule plus qu'un unique type String, UTF-8,
Unbounded, avec une API standard et ça règle une fois pour toute le pb
des strings dans Ada. Le framework v22 masque tout. L'utilisateur est
dans le confort.

C'est non conforme aux bonnes pratiques et sous-optimal du coté de la
mémoire. En pratique, ça impacte peu coté ram (v22 implémente des
goodies Gnatcoll qui permettent de regarder ça de près) et je n'ai pas
constaté d'effet de bord, hormis le cas qui fait l'objet de ce message.

Aurais-je du utiliser le type de base UXString ? Certainement. Mais avec
Gnoga utilisant ce subtype String, je reste uniforme. Et je ne voulais
pas non plus forker Gnoga pour remettre partout le type UXString. C'est
typiquement un compromis...


J'obtenais l'absolution de Jean-Pierre :

OK, je comprends. Du moment que la décision de conception est justifiée...



Précisions (autre extrait) :

On peut bien sûr continuer d'accéder à l'ex type prédéfini String par
Standard.String.

En passant, UXString v3 est un bonheur qui m'a permis de porter sans
aucun effort un framework complet vers l'UTF-8. L'API est standard, on a
l'opérateur de concaténation &¹ et on a plus besoin d'initialiser les
strings littérales avec l'opérateur +. L'usage est donc transparent et
ça rend la manip de strings UTF-8 aussi naturelle en Ada qu'en Python
(désolé pour la comparaison).

C'est aussi idéal quand on s'interface avec des DB en UTF-8 et, bien
sûr, c'était le propos initial, quand on dev pour le Web. C'est stable,
véloce, compatible Zanyblue (internationalisation). La conso mémoire
résultante est insignifiante en pratique. Merci Pascal :).
https://github.com/Blady-Com/UXStrings

¹ On est loin de certains packages de Strings UTF-8 à l'API non
conventionnelle et sans l'opérateur de concaténation &.


Pour ma part, UXStrings devrait être dans le RM et Pascal décoré de la
plus haute distinction Ada : la médaille "In strong typing we trust" ;)

[DrPi]

>> Ah, tiens, je croyais qu'on ne peux pas mettre des String non bornées
>> dans un record.
>
> "techniquement", c'est en fait un pointeur car... Oublié de préciser que
> dans ce contexte, les premières lignes de v22.ads sont :
>
>
>    with UXStrings; use UXStrings;
>    subtype String is UXString;
>
> (UXString étant fondé sur de l'Unbounded_String à 4 octets)
>
> C'est sale mais tellement bon.

Oh le vilain :p

J'ai cru que je devais revoir toutes mes bases... Ouf !

> On peut bien sûr continuer d'accéder à l'ex type prédéfini String par
> Standard.String.

Oui, j'ai retenu que les types de bases sont accessibles avec le package
"Standard".

>
> En passant, UXString v3 est un bonheur qui m'a permis de porter sans
> aucun effort un framework complet vers l'UTF-8. L'API est standard, on a
> l'opérateur de concaténation &¹ et on a plus besoin d'initialiser les
> strings littérales avec l'opérateur +. L'usage est donc transparent et
> ça rend la manip de strings UTF-8 aussi naturelle en Ada qu'en Python
> (désolé pour la comparaison).
>
> C'est aussi idéal quand on s'interface avec des DB en UTF-8 et, bien
> sûr, c'était le propos initial, quand on dev pour le Web. C'est stable,
> véloce, compatible Zanyblue (internationalisation). La conso mémoire
> résultante est insignifiante en pratique. Merci Pascal :).
> https://github.com/Blady-Com/UXStrings
>
> ¹ On est loin de certains packages de Strings UTF-8 à l'API non
> conventionnelle et sans l'opérateur de concaténation &.

Il faut que je retienne ça.
J'ai déjà posé la question de la gestion de l'UTF-8 sur c.l.ada mais je
n'ai pas eu une réponse unanime loin de là. Chacun y va de sa méthode.
Je suis resté dans l'expectative.

> Pour ma part, UXStrings devrait être dans le RM et Pascal décoré de la
> plus haute distinction Ada : la médaille "In strong typing we trust" ;)

Y a plus qu'à demander à l'ISO ;)

[DrPi]

Le 09/10/2023 à 09:43, Stéphane Rivière a écrit :
>
>> Je vais y réfléchir. Je suis comme une machine à vapeur. Le temps de
>> chauffe est long ;)
>
> J'avoue être un peu pareil ;)
>
>> C'est bien ça :)
>> C'est ma femme  qui l'a crochetée à ma demande.
>
> Nan ? Sériously ? C'est une blague ? Elle est très douée !

C'est rien comparé à ce qu'elle fait habituellement.

>> En fait, alors que je faisais fausse route avec Rust, j'ai vu une pub
>
> Ce que j'aime bien avec Rust, c'est que son fond de commerce est bien et
> qu'Adacore est liée à la fondation de la rouille, donc ça fait connaître
> Ada...

Mais il y a tellement de moutons...

> Convaincre ta hiérarchie pourrait passer par un truc assez simple : le
> porte monnaie : passer du C/C++ à Ada c'est /3 MINIMUM (c'est du vécu)
> le premier livrable client.

Oui mais il y a un obstacle important : Mes collègues.
Autant je suis toujours à la recherche d'améliorations possibles. Autant
eux sont confortablement installés dans leurs habitudes et il est très
difficile de les faire changer. Voire impossible.

>> limitation est bizarre. Ca n'est pas dans l'esprit du langage. Alors
>> je me mets à chercher et je finis par trouver le précieux "private with"
>
> Ada est plein de ce genre de choses. Il faudrait écrire une compilation
> de "use cases" pour les cas qui le méritent...

Un "Ada cheat sheet". Tu commences quand ? :p

> J'avoue que sur mes uP 8 bits, j'en suis pas là. Pas d'OS, une boucle
> infinie dans le main, des machines à états partout, des buffers partout
> et une gestion soignée des interruptions. Old school quoi :()

Je faisais ça il y a 30 ans avec 256 octets de RAM et une Eeprom dont le
temps d'effacement/programmation était d'environ 30 à 40mn (et sans
debugger bien sûr). Ca s'est amélioré petit à petit.
Maintenant, c'est l’opulence.

>> Des puces FPGA européennes, y a pas. Il y a essentiellement de
>> l'américain et du chinois. Pour les puces américaines, il y a AMD
>> (anciennement Xilinx) et Intel (anciennement Altera). Intel va
>
> Ah d'ac, les deux gros ont été repris par les deux très gros... J'étais
> même pas au courant...

Intel a acheté Altera il y 9 ans environ et vient d'annoncer vouloir
l'externaliser dans une nouvelle société.
AMD a acheté Xilinx plus récemment (début 2022).

> Ok, merci, t'étais pas vraiment HS avec le VHDL... Ça reste un sacré
> truc... Je sauve ton message !

Merci ;)

>> C'est avec plaisir que je continuerais la discussion par e-mail ou sur
>
> À l'occase. Faut que je creuse. J'aurais tellement souhaité y arriver
> par le VHDL. Après une machine virtuelle Windows, pourquoi pas :()

Encore une fois, pour se faire la main, il faut aller au plus simple :
Une carte toute faite et les outils du fabricant.

Un bon fabricant de cartes parmi d'autres (à prix accessibles) :
https://digilent.com/shop/fpga-boards/development-boards/introductory-boards/

Pas besoin de machine virtuelle, l'outil Xilinx existe en version Linux
(gratuit). C'est celui qui a le meilleur support de VHDL (ça s'est bien
amélioré récemment) en gratuit.

Une fois que tu commences à être à l'aise, tu vois quelle direction tu
veux prendre.

Nicolas

[J-P. Rosen]

Le 09/10/2023 à 20:10, DrPi a écrit :
>> Ada est plein de ce genre de choses. Il faudrait écrire une
>> compilation de "use cases" pour les cas qui le méritent...
> Un "Ada cheat sheet". Tu commences quand ? :p

On avait commencé un truc comme ça au niveau Ada-France, mais les
participants ont été pris par d'autres occupations (comme de bosser pour
pouvoir manger).

Si il y a des volontaires, Ada-France peut aider.

[Thomas]

Le 07/10/2023 à 23:16, DrPi a écrit :
> Le 07/10/2023 à 09:47, Stéphane Rivière a écrit :
>
>> Je ne suis pas si je suis très clair mais j'aurais tenté de faire le
>> canard en plastique².

> Je fais ça parfois avec des collègues et en général c'est très efficace.
> Je ne savais pas que ça s'appelle "méthode du canard en plastique".

Moi je fais plus simple que ça :
- j’écris au forum avec la ferme intention de poster,
- je me relis autant qu'il faut(*) pour m'assurer que les gens
comprendront bien ce que j'ai écrit,
- la plupart du temps, j'aurai trouvé une solution à mes pbs avant d'en
arriver à poster effectivement.

(*) Si je suis trop fatigué, je manque de patience et je poste avant
d'avoir été au bout de la démarche. Et ensuite je regrette en voyant les
réponses.

Ce que je trouve très agaçant sur le moment, c’est d’écrire
"inutilement" (que je crois), d'autant plus que j’écris très lentement.
Mais il est possible que ça ait un rôle positif dans le processus, du
fait que je réfléchis énormément plus vite que j’écris, donc entre le
début et la fin de l’écriture d'un msg j'ai le temps de penser à plein
de choses.


--
RAPID maintainer
http://savannah.nongnu.org/projects/rapid/

[Stéphane Rivière]

> Si il y a des volontaires, Ada-France peut aider.

Ces temps-ci Ada=Bosser donc manger ok... En tant que bricoleur, j'ai
effectivement du chercher certaines choses évidentes pour des Adaïstes
aguerris.

Des trucs débiles comme, dans un body, l'ordre de visibilité des
sous-programmes (internes au body, non déclarés dans la spec, du début à
la fin du source...

A
B appelle A, ça marche, mais si appelle C c'est non
C

Il suffit alors (j'ai tenté sans y croire mais ça marche) de déclarer C
limite juste au dessus de B et ça suffit pour rendre C visible pour B

Les conteneurs vecteurs itérant sur des records (les seuls exemples sont
généralement sur des entiers ou d'autres types simples).

La récupération automatique des lignes de code à partir des adresses
lors d'une exception...

L'exemple commenté d'un GPR un peu cossu

Etc...

Des bonnes pratiques pour les nouveaux aussi... Certaines conventions ne
sont pas écrites...

[Stéphane Rivière]

> Y a plus qu'à demander à l'ISO ;)

Si UXStrings gaze avec Gnoga, et c'est le cas, ça marchera avec
n'importe quoi d'autre. Donc, pour ma part, Ada, les strints et UTF-8,
c'est réglé, affaire suivante :)

[Stéphane Rivière]

.
> Oui mais il y a un obstacle important : Mes collègues.

Pour paraphraser : le logiciel est une affaire trop sérieuse pour être
confiée à des informaticiens.

> Je faisais ça il y a 30 ans avec 256 octets de RAM et une Eeprom dont le
> temps d'effacement/programmation était d'environ 30 à 40mn (et sans
> debugger bien sûr). Ca s'est amélioré petit à petit.
> Maintenant, c'est l’opulence.

C'est clair, et je vois qu'on vient du même monde. J'ai encore, je ne
sais pourquoi, mon micro-barbecue à UV... et de quoi programmer des 2716 :()

> Un bon fabricant de cartes parmi d'autres (à prix accessibles) :
> https://digilent.com/shop/fpga-boards/development-boards/introductory-boards/
>
> Pas besoin de machine virtuelle, l'outil Xilinx existe en version Linux
> (gratuit). C'est celui qui a le meilleur support de VHDL (ça s'est bien
> amélioré récemment) en gratuit.

Donc Linux + VHDL + prix très abordables visiblement. What else ? :)

Quand tu vois les perfs du jouet conseillé...

https://digilent.com/shop/basys-3-artix-7-fpga-trainer-board-recommended-for-introductory-users/

Merci Nicolas !

[DrPi]

Le 10/10/2023 à 12:53, Stéphane Rivière a écrit :
> .
>> Oui mais il y a un obstacle important : Mes collègues.
>
> Pour paraphraser : le logiciel est une affaire trop sérieuse pour être
> confiée à des informaticiens.

J'aime bien cette phrase ;)

>> Maintenant, c'est l’opulence.
>
> C'est clair, et je vois qu'on vient du même monde. J'ai encore, je ne
> sais pourquoi, mon micro-barbecue à UV... et de quoi programmer des 2716
> :()

Tu ouvres un musée ? :p

>> Un bon fabricant de cartes parmi d'autres (à prix accessibles) :
>> https://digilent.com/shop/fpga-boards/development-boards/introductory-boards/
>>
>> Pas besoin de machine virtuelle, l'outil Xilinx existe en version
>> Linux (gratuit). C'est celui qui a le meilleur support de VHDL (ça
>> s'est bien amélioré récemment) en gratuit.
>
> Donc Linux + VHDL + prix très abordables visiblement. What else ? :)

Ah non, pas Linux. Eventuellement µCLinux.

>
> Quand tu vois les perfs du jouet conseillé...
>
> https://digilent.com/shop/basys-3-artix-7-fpga-trainer-board-recommended-for-introductory-users/
>
> Merci Nicolas !
>

De rien :)

[DrPi]

Tout pareil ! ;)