Discussion :

[theophiledmt]

Bonjour à tous,

Dans le cadre d'un projet de développement d'un logiciel de benchmark, je dispose de deux programmes : l'un codé en C et l'autre codé en Python.

Le programme en C contient l'ensemble des fonctions permettant de réaliser les mesures, les tests et appeler des librairies de crypto que l'on souhaite évaluer (rapidité d'exécution, nombre de cycle de processeur). Le programme en C, une fois compilé, sera envoyé à la mémoire Flash d'un microcontrôleur avant d'être exécuté. Le point obscure et dont je ne vois pas comment procéder, c'est que pour chaque mesure effectuée, il va falloir récupérer des informations (configurations de la mesure ou du test). J'ai pensé utiliser une fonction qui se chargerait à chaque fois de remplir une structure et que cette même fonction retournerait l'adresse du pointeur sur cette structure.

Voici mon code en C ci-dessous:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
typedef struct
{
  char typeAlgo[20];
  char mode[20];
  uint8_t keyLength;
  uint8_t bufferSize;
  uint8_t nbBuffer;
  char nameAlgo[20];
  char measurementTarget[20];
}BenchDataConfig;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
BenchDataConfig *Display(char* TYPE_ALGO, char* MODE, uint8_t KEY_LENGTH, uint8_t BUFFER_SIZE, uint8_t NB_BUFFER, char* ALGO, char* MEASUREMENT_TARGET)
{
  /* Dynamic allocation and init the structure */
  BenchDataConfig *config = (BenchDataConfig*) malloc(sizeof(BenchDataConfig));
 
  /* Store each argument in the structure */
  config->typeAlgo = TYPE_ALGO;
  config->mode = MODE;
  config->keyLength = KEY_LENGTH;
  config->bufferSize = BUFFER_SIZE;
  config->nbBuffer = NB_BUFFER;
  config->nameAlgo = ALGO;
  config->measurementTarget = MEASUREMENT_TARGET;
 
  /* Return the adress of the structure pointer */
  return config;
}

Le programme en Python va se charger de compiler, charger le code C en mémoire flash du microcontrôleur puis d'exécuter le code chargé en flash.
Juste avant l'exécution du code, on lance une lecture du port série pour récupérer chaque mesure.

Ce que j'aimerai faire, c'est récupérer chaque configuration via l'adresse du pointeur sur la structure en C et ce depuis Python.

J'ai cherché sur Internet mais malheureusement je n'ai rien trouvé là-dessus.

Merci d'avance pour vos retours

[Sve@r]

Bonjour

Il y a à priori 2 façons de voir les choses

1. soit tu as deux programmes indépendants (écrits en C, Python, php ou autre on s'en fout) et tu veux les faire communiquer => il te faudra alors passer par des outils de communication inter-processus (pipes, sockets)
2. soit tu veux vraiment attaquer un code C depuis Python en les mettant dans le même programme. Dans ce cas, tu peux te tourner vers Cython

Accessoirement je pense que c'est plutôt un sujet plus Python que C.

[dalfab]

Bonjour,

Je verrais un troisième cas. J'ai l'impression que les langages s'utilisent sur des machines différentes. Le C dans l'embarqué, et le Python qui serait sur un host. Dans ce cas les moyens de communications entre les deux applications seraient RS232, USB, Ethernet, Bluetooth, ...

[theophiledmt]

Bonjour à vous,

Tout d'abord merci pour vos retours

Si je peux apporter d'autres informations, cela vous permettra probablement d'y voir plus clair.

Mon programme Python sera le programme à l'origine de chacune des actions. Il réalisera les étapes suivantes :

1) Ouvrir deux fichiers : un pour récupérer les mesures et leur identifiant, l'autre pour récupérer les informations de configuration propres à chaque mesure.

2) Configuration et lecture du port série (port série connecté en USART avec une board équipée d'un microcontrôleur).

3) Pilotage d'un IDE (tels que: IAR, Keil, etc) pour compiler, importer le code C dans la flash avant exécution.

4) Exécution du code C. La configuration et la lecture du port série permet de récupérer une trame de ce type :
<YAML> Mesure n°X
<YAML> Valeur mesure X: xxx
<YAML> Mesure n°X + 1
<YAML> Valeur mesure X + 1: xxx

A l'aide d'un petit bout de code, j'écris chaque ligne récupérée sur le port série en séquentiel (dans un fichier .yaml).

4-bis (ou 4')) Récupération des informations de configuration de la mesure. Il faudrait que je parvienne à récupérer les informations contenues dans ma structure en C (et ce pour chaque test en faisant un nouvel appel de la fonction de remplissage) dont le code est embarqué. Le but serait de communiquer ces informations au code Python qui récupérerait chaque information pour les stocker dans une mini database.

Plusieurs questions me viennent à l'esprit :

- Faut-il que j'utilise de la programmation asynchrone pour récupérer puis écrire chaque information (une fois récupérée) ?

- Comment (en Python et à partir de l'adresse d'un pointeur sur structure) accéder à la valeur de chaque variable associée à cette structure ? Est-ce possible ?

Merci d'avance pour vos retours, je vais me pencher sur l'utilisation de sockets et de pipes

[Sve@r]

4-bis (ou 4')) Récupération des informations de configuration de la mesure. Il faudrait que je parvienne à récupérer les informations contenues dans ma structure en C (et ce pour chaque test en faisant un nouvel appel de la fonction de remplissage) dont le code est embarqué.

Tout ce que tu as expliqué ne change rien. Tu as différents programmes qui doivent communiquer, il te faut passer par des outils de communication inter processus. Le plus basique reste le fichier. P1 (programme 1) écrit dans le fichier et P2 vient lire son contenu. Sinon il y en a de plus complexes mais qui permettent en retour des actions plus fines telles que synchronisation, communication inter-machines, etc.
Ici https://docs.python.org/fr/3.5/library/ipc.html une liste d'outils Python pour communiquer

Le but serait de communiquer ces informations au code Python qui récupérerait chaque information pour les stocker dans une mini database.

On peut se demander pourquoi ce ne serait pas le C qui irait stocker les informations en bdd. Ou pourquoi ce ne serait pas Python qui irait récupérer les information de configuration de la mesure.

Faut-il que j'utilise de la programmation asynchrone pour récupérer puis écrire chaque information (une fois récupérée) ?

Je ne pense pas. L'asynchrone permet à un programme qui a plusieurs tâches T1 T2 T3 qui ont toutes une attente diverse (ex T1 attend une info venue du disque) de travailler sur T2 pendant que T1 attend ladite info. Un bon exemple d'asynchrone est le serveur restauration rapide. Un client C1 lui demande un burger qui met 2mn à cuirer et un C2 lui demande un soda qui met 2s à couler. Pendant que le burger cuit il peut servir des sodas.
En plus l'asynchrone n'est qu'une optimisation. Ce qui se fait avec l'asynchrone peut se faire aussi sans. Rien n'empêche le serveur de glander 2mn à attendre le burger de C1 avant d'aller faire couler le soda de C2 (c'est d'ailleurs ce qui se passe dans la vraie vie).

- Comment (en Python et à partir de l'adresse d'un pointeur sur structure) accéder à la valeur de chaque variable associée à cette structure ? Est-ce possible ?

Non. La base des procesuss est d'être indépendants. Ils ont leur propre zone mémoire inaccessible. Tu ne pourrais même pas le faire en C. La seule chose que tu peux faire, c'est écrire un programme Python qui appelle des fonctions C avec Cython. Là comme c'est le même programme, Python a alors accès aux variables du C.

je vais me pencher sur l'utilisation de sockets et de pipes

Sous Unix/Linux il existe aussi les IPC (Inter Procesuss Communication) dans lequel on trouve la file de message (une espèce de télésiège dans lequel P1 écrit un truc qui restera jusqu'à ce que P2 vienne le lire) ou la mémoire partagée (un espace de RAM connu et accessible par les deux processus). Sauf que les IPC sont accessibles depuis le C qui contient des fonctions d'accès mais je n'ai pas trouvé l'équivalent de ces fonctions dans Python. Mais quelque chose me dit qu'il doit exister une librairie pour ça.