Octave¶
GNU Octave est un logiciel libre de langage de programmation scientifique et mathématique. Il permet de faire de la manipulation de données et de réaliser des graphiques. Les commandes Matlab sont compatibles.
Il existe pour différents systèmes d'exploitations : Linux, Windows, etc.
Quelques infos : https://www.gnu.org/software/octave/about
Pour l'installer : https://www.gnu.org/software/octave/download
Site de package pour Octave : https://octave.sourceforge.io/packages.php
Quelques commandes¶
- clear : effacer les données stockées dans "l'espace de travail"
Premiers pas pour tracer des courbes¶
- Préparer un fichier pour les abscisses "x" et un fichier pour les ordonnées "y" de la forme :
x1 x2 x3 ...
- Sauvegarder ces fichiers dans un répertoire.
- Ouvrir Octave et entrer dans ce répertoire dans le "Navigateur de Fichiers".
- Utiliser la commande load, pour charger les fichiers d'abscisses et d'ordonnées et les attribuer à des variables :
x = load('nom_fichier_x'); y = load('nom_fichier_y'); - La commande "whos" permet d'afficher la liste des variables en mémoire, leur format et leur taille.
- Pour tracer une courbe :
plot(x,y) - Pour l'exporter au format SVG :
print -deps nom_du_fichier.svg -dsvg
Toutes les commandes pour tracer des courbes : https://octave.org/doc/v4.4.0/Printing-and-Saving-Plots.html
Tracer une courbe à partir d'un fichier .CSV¶
t = csvread('nom_du_fichier.csv')
p = fileread('nom_du_fichier.csv')
t(i,j)
t(1:n,j)
t(:,j)
plot(t(1:n,1), t(1:n,2))
Modifier le format d'affichage des données¶
Exemples :
>> format long
>> pi
ans = 3.141592653589793
>> format short
>> pi
ans = 3.1416
-> affichage au format "long", c'est-à-dire avec 15 chiffres significatifs ou "short" avec 4 chiffres significatifs.
Il existe aussi les affichages "short", "shortE", "longG", etc. Cf doc de MatLab : https://fr.mathworks.com/help/matlab/ref/format.html
Installer un paquet https://wiki.octave.org/Category:Octave_Forge¶
pkg install -forge nom_du_paquet
Utilisation du paquet IO¶
Installation :
pkg install -forge io
Chargement : pour pouvoir utiliser les fonctions de IO
pkg load io
Utilisation du paquet DataFrame¶
Installation :
pkg install -forge dataframe
Paquet permettant de manipuler les CSV ... à tester !
Instructions :
https://wiki.octave.org/wiki/index.php?title=Dataframe_package&mobileaction=toggle_view_desktop
Script d'analyse des données du Voltcraft¶
Ce script analyse_tableau.m est utilisé ici Voltcraft_Energy_Logger_4000
On le retrouve ici avec des commentaires supplémentaires dans le but d'apprendre à se servir d'Octave de manière générale.
Il fonctionne, mais il est loin d'être parfait ! Il manque, par exemple, la possibilité de changer l'intervalle de temps à étudier sans être obligé de redémarrer le script. Aussi, il utilise une fonction bien pratique ("strmatch") mais qui est obsolète.
- Nettoyage de la mémoire et de l'affichage :
clear all; close all; clc;
- Format d'affichage court des nombres :
format short;
- Chargement du paquet "IO" pour pouvoir utiliser la commande "csv2cell" :
pkg load io;
- La fonction "input" avec l'argument 's' permet de rentrer une chaîne de caractère, ici le nom (exact) du fichier .CSV à traiter et le type de séparateur :
nom_csv = input('Entrer le nom du tableau .csv : ','s'); separateur = input('Quel séparateur ? (normalement ";") ', 's');
- Utilisation d'une fonction importante pour ce script "csv2cell", qui permet de convertir un tableau CSV en un tableau de cellules afin de pouvoir y faire les opérations suivantes :
tableau = csv2cell(nom_csv, separateur); %LA fonction clé !
- La fonction "size" renvoie le nombre de lignes du tableau :
taille = size(tableau); %mesure la taille du tableau
- Manipulation pour retirer la première ligne du tableau qui contient les en-têtes en refaisant un tableau à partir de la ligne 2 jusqu'à la fin ("2:taille(1,1)") et avec toutes les colonnes ("1:6") :
tableau = tableau(2:taille(1,1),1:6);
- Pour information, affichage des données de la première et de la dernière ligne du tableau avec la fonction "printf" pour afficher du texte et la fonction "disp" pour afficher une donnée :
printf('\n Première ligne du tableau : '); disp(tableau(1, :)); printf('\n Dernière ligne du tableau : '); disp(tableau((taille(1,1)-1), :)); printf('\n');
- Réutilisation de la fonction "input" pour rentrer l'intervalle de temps que l'on veut étudier :
temps_debut = input("A partir de ? (format = jj/mm/aaaa hh:mm) : ",'s'); temps_fin = input("Jusqu'à ? (format = jj/mm/aaaa hh:mm) : ",'s');
- Extraction de la première colonne contenant la date et l'heure dans le tableau temps_tableau afin d'y faire des manipulations :
temps_tableau=tableau(:,1);
- Utilisation de la fonction "strmatch" qui cherche à quelle position (le numéro de la ligne) du tableau temps_debut = temps_tableau et temps_fin = temps_tableau. C'est l'autre fonction importante de ce script.
pos_debut=strmatch(temps_debut, temps_tableau); pos_fin=strmatch(temps_fin, temps_tableau);
- Test de la fonction "strncmp" pour remplacer la fonction "strmatch" qui est obsolète ... PAS ENCORE AU POINT !
%pos_debut_test=strncmp(temps_debut, temps_tableau, 16); %pos_fin_test=strncmp(temps_fin, temps_tableau, 16); pos_debut_test=strcmp(temps_debut, temps_tableau); pos_fin_test=strcmp(temps_fin, temps_tableau);
- Utilisation de la fonction "char" pour convertir les données de "temps_tableau" en caractère ASCII, avec comme argument les positions de début et de fin souhaitées :
temps_char=char(temps_tableau(pos_debut:pos_fin,1));
- Séparation du tableau "temps_char" en colonnes individuelles pour le jour, mois, année, heure et minute, et conversion en décimal en utilisant l'astuce "-48" :
jj=(temps_char(:,1) - 48) * 10 + temps_char(:,2) - 48; mm=(temps_char(:,4) - 48) * 10 + temps_char(:,5) - 48; aaaa=(temps_char(:,7) - 48) * 1000 + (temps_char(:,8) - 48) * 100 + (temps_char(:,9) - 48) * 10 + temps_char(:,10) - 48; hh=(temps_char(:,12) - 48) * 10 + temps_char(:,13) - 48; min=(temps_char(:,15) - 48) * 10 + temps_char(:,16) - 48;
- Calcul pour convertir le temps en minutes et soustraction pour avoir un graphique qui démarre à t = 0 :
x_minutes=aaaa*525600 + mm*43800 + jj*1440 + hh*60 + min; x_minutes=x_minutes - x_minutes(1,1); %temps en minutes depuis le démarrage, pour le graphique
- Traitement des 5 autres colonnes : conversion des données du tableau cell->double et extraction par colonne entre pos_debut et pos_fin :
tension_V=cell2mat(tableau(pos_debut:pos_fin,2)); %tension en volt V courant_A=cell2mat(tableau(pos_debut:pos_fin,3)); %courant en ampère A cos_phi=cell2mat(tableau(pos_debut:pos_fin,4)); %cos(phi) ou "facteur de puissance" puissance_W=cell2mat(tableau(pos_debut:pos_fin,5)); %puissance consommée P = U * I * cos(phi) puissance_VA=cell2mat(tableau(pos_debut:pos_fin,6)); %puissance apparente P = U * I
- Toutes les données sont extraites et mises en forme, il ne reste qu'à choisir ce que l'on souhaite tracer avec la fonction "plot".
- Affichage d'un menu pour que l'utilisateur puisse choisir ce qu'il souhaite tracer :
printf('\n\t Choix des données à tracer : \n\n'); printf('Tension V \t\t\t\t\t -> 1\n'); printf('Courant A \t\t\t\t\t -> 2\n'); printf('Facteur de puissance (cos(phi)) \t\t -> 3\n'); printf('Puissance consommée (P = U * I * cos(phi)) \t -> 4\n'); printf('Puissance apparente (P = U * I) \t\t -> 5\n'); printf('Pour quitter ce menu \t\t\t -> 0\n'); printf('\n\t');
- Demande à l'utilisateur de rentrer un chiffre en fonction de son choix avec la fonction "input" :
choix=input('Choix : ');
- Boucle "while" et fonction "switch case" pour tracer les courbes à la volée et les sauvegarder en .SVG en fonction du choix. Utilisation de la fonction "plot" pour tracer, "title" pour légender les courbes, et "print" avec l'argument "-dsvg" pour exporter le tracé en .SVG. Si l'utilisateur rentre le choix "0", cela sort de la boucle. S'il ne rentre pas un chiffre compris entre 0 et 6, le script reste dans la boucle et affiche un message invitant à rentrer un chiffre "correct".
while choix ~= 0, switch choix case 1 plot(x_minutes, tension_V); title('Tension');xlabel('Temps (minutes)');ylabel('Tension (V)'); print ('tension', '-dsvg'); case 2 plot(x_minutes, courant_A); title('Courant');xlabel('Temps (minutes)');ylabel('Courant (A)'); print ('courant', '-dsvg'); case 3 plot(x_minutes, cos_phi); title('Facteur de puissance');xlabel('Temps (minutes)');ylabel('Cos(Phi)'); print ('cos_phi', '-dsvg'); case 4 plot(x_minutes, puissance_W); title('Puissance consommée P = U x I x cos(Phi)');xlabel('Temps (minutes)');ylabel('Puissance (W)'); print ('P_consommee', '-dsvg'); case 5 plot(x_minutes, puissance_VA); title('Puissance apparente P = U x I');xlabel('Temps (minutes)');ylabel('Puissance (VA)'); print ('P_apparente', '-dsvg'); otherwise printf('Rentrez un choix entre 1 et 5 ! \n'); end choix=input('Autres données à tracer : '); end
- Une fois sorti de la boucle, la fonction "close" permet de fermer le graphique et de sortir du script :
close;