Post by Stéphane RivièreUne 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 ;)
Post by Stéphane RivièrePS
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
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.
Post by Stéphane RivièreUne 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.
Post by Stéphane RivièreJ'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
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 ;)
Post by Stéphane RivièreJ'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.
Post by Stéphane RivièreEnfin, 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...
Post by Stéphane RivièreRust, 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.
Post by Stéphane RivièreTu 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.
Post by Stéphane RivièreÉ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.
Post by Stéphane RivièreL'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).