Anthony Jaguenaud a écrit 1956 commentaires

Sauf que l’agence de sécurité aéronautique américaine a délégué la certification à Boing… ne cherchait pas de conflit d’intérêt ou d’indépendance, c’est la sécurité des passagers qui prime…

Il faut que tu installes les headers du noyau.

Par contre, je suis intéressé par le résultat du lspci.

Sur ma machine Virtuelle :

$ lspci
00:00.0 Host bridge: Intel Corporation 440FX - 82441FX PMC [Natoma] (rev 02)
00:01.0 ISA bridge: Intel Corporation 82371SB PIIX3 ISA [Natoma/Triton II]
00:01.1 IDE interface: Intel Corporation 82371AB/EB/MB PIIX4 IDE (rev 01)
00:02.0 VGA compatible controller: InnoTek Systemberatung GmbH VirtualBox Graphics Adapter
00:03.0 Ethernet controller: Intel Corporation 82540EM Gigabit Ethernet Controller (rev 02)
00:04.0 System peripheral: InnoTek Systemberatung GmbH VirtualBox Guest Service
00:05.0 Multimedia audio controller: Intel Corporation 82801AA AC'97 Audio Controller (rev 01)
00:06.0 USB controller: Apple Inc. KeyLargo/Intrepid USB
00:07.0 Bridge: Intel Corporation 82371AB/EB/MB PIIX4 ACPI (rev 08)
$

Il liste tous ce que le noyau détecte, mais ça ne veut pas dire qu’il sache les prendre en compte.

A priori elle n'est pas reconnu.

Oups

Il faut compiler le driver et le charger avec modprobe.

Non, n’importe quelle carte sur le BUS PCI doit donner son vendorID et son ID. C’est une fois en possession de cette information que le noyau peut charger le bon driver.

Si la carte n’est pas reconnu :

• Vérifier qu’elle est correctement enfoncée dans le connecteur PCI.
• Changer la carte de slot au cas où une soudure ait sautée (peu probable)
• La remplacer par une carte que tu sais fonctionner.
• Vérifier si la carte est reconnue sur un autre PC (Windows)
  • Oui :
  • Redémarrer avec un live CD linux et refaire un lspci.

Voila mes idées là, maintenant, tout de suite.

Bonne chance.

Et le java ? La téléréalité ? :-p

---->[]

Ok, je ne pensais pas. Merci d’améliorer ma culture.

Non, si ta source est plus petite que str, le dernier caractère ne sera pas écrit… et rien ne prouve qu’il vaille '\0'.

Je vois un cas d’usage dont il ne faut pas abuser pour la lecture…

  int n = 50;
  char str[n];

  …
  // Si len(source) >= 50, il n’y a pas la place pour le caractère
  // terminal. Donc on peut l’ajouter directement.
  // Par contre, attention à la compréhension du code.
  strncpy(str, source, n)[n-1] = '\0';
  …

J’ai pas tout saisi, mais un petit man join pourra peut-être t’aider.

Pour maîtriser le temps Réel, il faut voir ça comme de l’échantillonnage en fréquence. Il te manque une donnée : le temps de réponse voulue.

Question 1 : À la réception du message au bout de combien de temps, l’action doit être réalisée ?

Question 2 : À la lecture du message, en combien de temps l’action est réalisée ?

À partir de là, tu peux déterminer et prouver que ton logiciel répond en temps et en heure.

Dans ton exemple, la réponse à la question 2 est : 4s.

Avec 4s de traitement, ta période ne peut descendre en dessous de 4s (voir un poil plus).
Disons 5s. Donc, tu peux garantir que le traitement sera réaliser 10s après la réception. Des fois ce sera 4,1s des fois 9,1s. Mais toujours moins de 10s.

Si tu n’as pas cette problématique de temps de réponse voulu, j’aurais tendance à utiliser des solutions bloquante de type : select pour la lecture et communication inter thread pour prévenir en sécurité de la réception. Cette solution sera sûrement plus réactive, mais le temps non garanti.

Question : As-tu vraiment besoin de la maîtrise de ton temps réel pour ton application ? Tu ne donne pas beaucoup de détail (OS ou Bare metal), plateforme, etc.

Si tu as un CPU multi cœur par exemple, et que tu peux dédier un cœur à ça, alors, tu peux faire un thread bloquant qui va te garantir une réponse en moins de 5s. Mais ton cœur n’est pas disponible pour autre chose… c’est un choix de design à faire.

Ton problème c’est que soit c’est les clients qui payent le journal, donc le journal fait plaisir à ses clients, donc est partial. La solution c’est de payer un impôt pour la presse ? Non, car le journal serait à la solde de l’État…

Il n’y a pas de solution !

Même chose pour moi, à la différence que le sujet était un mot de passe que j’ai longtemps utilisé (je l’utilise même encore sur linuxfr). Mais aucun compte important, mail, achat en ligne, etc. n’utilise ce mot de passe.

Une bare machine ?

Je ne connaissais pas l’expression.

Ce qui n'est d'ailleurs pas juste un concept d'école : les premières ébauches du système de contrôle-commande des centrales nucléaires 1400MW de EDF étaient basées sur une bare machine Ada (fin des années 80).

Aucune idée, à la fin des années 80 j’étais encore au lycée.

Ce que j’aime dans la pyboard, que je trouve aussi très moderne c’est son système de boot.
La carte contient une flash qui est formatée, le firmware démarre, et cherche un fichier boot.py, il l’exécute. Celui-ci cherche ensuite un fichier main.py. Il est déconseillé de modifier le boot.py car il initialise notamment la communication avec l’ordinateur quand la carte est connectée en USB.

D’ailleurs, en USB, la pyboard s’enregistre comme une clé USB, ce qui permet de modifier les fichiers python, mais aussi de créer des sous répertoire, etc. La carte s’enregistre aussi comme console série, en l’ouvrant on a un interpréteur python exécuté directement sur la carte. Très intéressant en phase de dév. et de test.

Vous aurez compris, je suis fan.

Salut,
Comme répondu au dessus, il faut faire tourné l’exécutable sur la cible. Il faudra un minimum de code comme le boot, et il faut aussi linker statiquement toutes les bibliothèques nécessaire à l’interpréteur. Il faut entre autre réimplémenter certaines fonctions de base comme l’allocation mémoire, etc.

Je pense qu’un bon exemple est μpython, tu as une carte utilisant cette solution la pyboard. Je n’ai pas regardé comment c’est implémenté, mais le code est là.

Par contre, tu n’as pas vraiment un OS, juste une plateforme pour exécuter du code python.

Je passe J à 50.

$ ./a.out
$

Es-tu sûr que c’est le comportement attendu ?

En ajoutant le calcul réel de la racine carré :

$ ./a.out
Approximation 1 of square root of 5.000000 is 5.000000
Approximation 2 of square root of 5.000000 is 3.000000
Approximation 3 of square root of 5.000000 is 2.333333
Approximation 4 of square root of 5.000000 is 2.238095
Approximation 5 of square root of 5.000000 is 2.236069
Approximation 6 of square root of 5.000000 is 2.236068
Approximation 7 of square root of 5.000000 is 2.236068
Approximation 8 of square root of 5.000000 is 2.236068
Approximation 9 of square root of 5.000000 is 2.236068
Approximation 10 of square root of 5.000000 is 2.236068
sqrt(5.000000) = 2.236068
$

Ton calcul semble correct. Le seul truc que je n’aime pas c’est ton if (condition1) puis if (!condition1)
Pourquoi ne pas utiliser if … else ? De plus, tu ne choisi pas ce que tu fais pour n == 0.

Pour ta question, oui tu pourrais y arriver différemment… en récursif par exemple. Mais en C, dans ce cas, je pense la solution itérative plus pertinente.

Non, ils peuvent y aller ensemble, les parties qui ont besoin d’être exclusives sont protégées par des mutex.
Je parlais des interruptions matérielles, c’est à dire, quand une carte d’extension à besoin de l’attention du CPU. Par exemple la réception d’un message réseau qui doit être transféré dans la RAM avant qu’un autre n’arrive.

Pour le reste, beaucoup de chose vont dépendre de l’OS concerné. Il y a plein d’implémentation possible, en fonction du besoin de ton OS. Les OS généraliste sont réentrant, un petit OS dans l’embarqué ne le sera pas forcément.

Après, je n’ai pas les compétences pour te détailler l’implémentation de ces mécanismes dans Linux.

Si j’ai bien suivi, voici ton source de départ

#include <stdio.h>

#ifndef N

#define N 5

#endif

#ifndef J

#define J 3

#endif

int main(void){
  double n = N;
  int j = J;

  /* Écrire ton programme ici */

  return 0;
}

Qu’est-ce que tu attends de nous, si c’est de t’écrire le programme, je ne le ferai pas. Ça va me prendre 2 minutes, et ne te servir à rien.

Je préfère y passer plus de temps et répondre à de vrai interrogation pour t’aider à avancer avec ton propre cerveau qui est surement capable de résoudre ce problème.

Sur ta première question, tu peux voir les #define comme de la définition de constante, donc double n = N <=> double n = 5.

1 / Quand on ne peut attaquer les idées, on attaque l'homme. Bravo à vous.
…
4 / En 1992, … pour rediriger la colère des imbéciles vers l'élysée, et épargner Bruxelles.

Hum, les attaques ad-hominem sont mal contre toi, mais toi tu peux en faire ?

Quand on est sous IT (sous interruption), un certain nombres de choses sont bloqués, les interruptions moins prioritaire ne s’active plus, etc.
Dans un système aussi complexe que les systèmes d’aujourd’hui Linux/Windows/Haïku/etc. On essaye de faire le moins de traitement possible sous IT. La solution en général, c’est de créer des threads légés noyau. Ces derniers tente de prendre un sémaphore de type mutex, et sont bloqués. Lors de l’arrivé d’une IT, le code de l’interruption va libérer le sémaphore et sortir. L’ordonnanceur va voir qu’une tâche très prioritaire vient d’être libéré et l’exécuter immédiatement.

Je n’ai jamais donné d’argent, mais du temps pour des rapports de bug ou petite contribution, ça compte ?

Ce qu’on appelle noyau, c’est la partie du système d’exploitation qui gère la machine. Généralement, tout est en RAM. Certains driver peuvent être sur le disque dur et être chargés à la volée, comme un driver de tablette graphique.

Le noyau gère ta RAM, l’organisation de tes disques, il ordonnance tes processus, gère les verrous, etc.

Pour résumer, le noyau fait l’interface entre le logiciel et les composants de l’ordinateur.

Tu devrais commencer par la gestion d’un ordinateur, le sujet est vaste, et il se complexifie au fil des années.

Salut,
Ça fonctionne comme ça depuis les années 80 et probablement même avant.

Quand tu fais l’instruction int 80h, tu déclenches une interruption logicielle. Le CPU va regarder la table d’interruption, et exécuter le code à l’adresse indiquée dans la table.
C’est presque comme si tu appelais une fonction via un pointeur dans une globale. La principale différence, c’est que l’instruction int modifie les flags du CPU, et permet de sortir du mode utilisateur pour passer dans le mode superviseur. Il y a une instruction spéciale pour le retour qui restitue les flags du CPU.

Comme il y a un unique point d’entrée, la première chose à faire et de savoir quel service tu veux utiliser. Le paramètre est (il me semble) dans le registe AX (EAX, RAX). En fonction du service, les autres paramètres sont rangé dans les autres registres.

Si tu trouves des vieux livres sur le DOS et les PC d’avant. Ça te donnera une idée de ce qui se passe, à la protection mémoire et quelques autres trucs près.

Salut,
Tu as un compte ancien, 2 février 2004 (15 ans)… si ce n’est pas indiscret, pourquoi fermer ton compte ?

Un lien sur la traumatologie des pratiques sportive là(pdf) je suis toujours effaré par la proportion d’accident chez les footeux.