Pierre/shipheart-qt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
shipheart-qt/config_capteur.qml
T

2556 lines
140 KiB
QML
Raw Permalink Blame History

//========================================================================================================================================================================
// CONFIG_CAPTEUR.QML
// Ce fichier traite la configuration d'un capteur. La page permet notamment de :
// - Modifier la config du capteur (ou de le créer la première fois),
// - Supprimer le capteur
// La page est appelée depuis la page config_capteurs.qml, en cliquant sur le capteur à modifier (ou sur le '+' en vue d'une création)
//========================================================================================================================================================================
import QtQuick 2.12
import QtQuick.Controls 2.12
import QtQml.Models
import qt.koriolan.shipheart 1.0
import"fonctions.js" as Fonctions
Shipheart_page {
id: page_config_capteur
// Mis en forme :
readonly property double pourcentage_largeur_colonne_gauche: 0.75
readonly property int espace_colonnes_principales: 20
readonly property double pourcentage_largeur_labels_formulaire: 0.5
readonly property double pourcentage_largeur_unites_formulaire: 0.1
readonly property double pourcentage_hauteur_ligne_haut: 1
readonly property int affichage_hauteur_utile: shipheart_hauteur_page - shipheart_hauteur_bandeau_haut - shipheart_hauteur_bandeau_bas
readonly property int espace_lignes_principales: 20
readonly property int hauteur_ligne_formulaire: 60
readonly property int hauteur_bouton_droit: 80
readonly property double pourcentage_bandeau_bas_largeur_zone_retour: 1
// Timings :
readonly property int periode_init_raffraichissement_parametres: 1 // En ms
readonly property int periode_raffraichissement_parametres: 1000 // En ms
readonly property int step_timer_appui_long: 30 // en ms
// Affichage :
property bool flag_init: true // Permet de bloquer certains affichage tant que l'init n'est pas terminée
// Données :
property int valeur_timer_appui_long: 0
property int id_capteur: 0
property int adresse_module: -1
property int type_entrees : 0
property string entrees: ""
property int nb_entrees: 0
property int nb_libelles: 0
property int entree_en_cours: 0
property int mode_entrees: 0
property int priorite_affichage_accueil: 0
property int id_famille: 0
property int id_variable: 0
property string liste_valeurs_textes: ""
property bool flag_affichage_mode_entrees: false
property bool flag_affichage_offset: false
property bool flag_nmea: false // Il est positionné dès qu'on "touche" à un paramètre NMEA pour demander une mise à jour NMEA
// Modèles :
// Note : les modèles chargés dans 'main.qml' n'ont pas à être rechargés dans les pages suivantes
//===========================================================
// Signaux :
//===========================================================
//----------------------------------------------------------------------------------
// Connexion au signal de la page 'config_capteur_calcule_booleen.qml' :
Connections {
target: stackView.currentItem // Pointe sur la page active de StackView (qui sera créée... bientôt, ou pas)
ignoreUnknownSignals: true // Permet de ne pas déclencher d'erreur AVANT que la page ne soit créée par un StackView.push()
// -----------------------------------------------
// Fonction d'enregistrement des nouvelles data :
// -----------------------------------------------
function onEnregistrer_config_capteur_calcule_booleen(new_entrees)
{
if (type_entrees === shipheart_capteur_type_entrees_calculee_booleen) // Normalement, ça n'arivera que dans ce cas mais...
{
champ_formulaire_Entrees.model.set(champ_formulaire_Entrees.currentIndex, {"entrees": new_entrees} );
}
}
}
//===========================================================
// Timer periode raffraichissement parametres :
//===========================================================
Timer {
id: timer_raffraichissement_parametres
interval: periode_init_raffraichissement_parametres
triggeredOnStart: false
running: true
repeat: true
onTriggered: {
if (interval == periode_init_raffraichissement_parametres) { // Premier passage, 1ms après le premier chargement
interval = periode_raffraichissement_parametres;
init_page();
}
else {
}
}
}
//===========================================================
// Timer pour gérer les appuis longs :
//===========================================================
Timer {
id: timer_appui_long
interval: step_timer_appui_long
triggeredOnStart: false
repeat: true
onTriggered: {
if (valeur_timer_appui_long < shipheart_mouse_press_and_hold_interval_tres_long) valeur_timer_appui_long+= step_timer_appui_long;
else // Le fait de ne pas utilise le OnPressandHold permet d'être sût que la sortie se fait au même moment que la fin du comptage (sinon, on peut avoir de petits décalages)
{
timer_appui_long.running = false;
valeur_timer_appui_long = 0;
// Suppression du capteur :
if (mousearea_bouton_supprimer.pressed)
{
if (check_avant_suppression() !== -1)
{
shipheart_clic();
suppression_capteur(); // Mise à jour des données saisies dans la BDD et reconfiguration par l'application pour prise en compte.
timer_tempo_reconfiguration.restart(); // Lancement du timer pour attendre la fin de la reconfiguration
}
}
}
}
}
// Titre de la page :
Shipheart_titre_1 {titre: (id_capteur === 0) ? qsTr("Création d'un capteur") : qsTr("Configuration du capteur"); hauteur: shipheart_hauteur_bandeau_haut}
//-------------------------------------------------------
// Ecran Haut - Gauche :
//-------------------------------------------------------
Rectangle {
id: zone_affichage_haut_gauche
x: 0
y: shipheart_hauteur_bandeau_haut;
width: (shipheart_largeur_page * pourcentage_largeur_colonne_gauche) - (espace_colonnes_principales / 2)
height: (affichage_hauteur_utile * pourcentage_hauteur_ligne_haut) - (espace_lignes_principales / 2);
color: "transparent"
//=========================
// Liste des champs :
//=========================
ListView {
id: grille_principale
width: parent.width
height: parent.height
snapMode: GridView.SnapToRow // L'arret de l'affichage se fera sur une rangée entière
clip: true // Nécessaire pour que les Delegates s'arretent à l'intérieur de la GridView
model: modele_grille_principale
footer: Rectangle { // Permet de dégager la place suffisante en fin de GridView pour accéder même au dernier élément lorsque que clavier est déplié
height: shipheart_hauteur_clavier
color: "transparent"
}
ObjectModel {
id: modele_grille_principale
//-------------------------------------------------------------------------------
// Ligne de formulaire : Nom
Rectangle {
id: ligne_nom
width: (shipheart_largeur_page * pourcentage_largeur_colonne_gauche) - (espace_colonnes_principales / 2)
height: visible ? hauteur_ligne_formulaire : 0
color: "transparent"
Shipheart_formulaire_label {
text: qsTr("Nom du capteur")
width: parent.width * pourcentage_largeur_labels_formulaire
couleur: (champ_formulaire_Nom.text !== "")
? shipheart_formulaire_couleur_texte_par_defaut
: shipheart_formulaire_couleur_texte_en_erreur
}
Shipheart_formulaire_textfield {
id: champ_formulaire_Nom
width: parent.width * (1 - pourcentage_largeur_labels_formulaire)
x: parent.width * pourcentage_largeur_labels_formulaire
}
Shipheart_formulaire_ligne_separation {
haut_bas_hautbas: shipheart_formulaire_ligne_separation_basse
}
}
//-------------------------------------------------------------------------------
// Ligne de formulaire : Type_entrees
Rectangle {
id: ligne_type_entrees
width: (shipheart_largeur_page * pourcentage_largeur_colonne_gauche) - (espace_colonnes_principales / 2)
height: visible ? hauteur_ligne_formulaire : 0
color: "transparent"
Shipheart_formulaire_label {
text: qsTr("Type de capteur")
width: parent.width * pourcentage_largeur_labels_formulaire
couleur: (champ_formulaire_Type_entrees.currentIndex !== 0)
? shipheart_formulaire_couleur_texte_par_defaut
: shipheart_formulaire_couleur_texte_en_erreur
}
Shipheart_formulaire_combobox {
id: champ_formulaire_Type_entrees
model: ListModel { }
width: parent.width * (1 - pourcentage_largeur_labels_formulaire)
onActivated: {
shipheart_clic();
if (type_entrees !== champ_formulaire_Type_entrees.model.get(champ_formulaire_Type_entrees.currentIndex).valeur)
{
type_entrees = champ_formulaire_Type_entrees.model.get(champ_formulaire_Type_entrees.currentIndex).valeur;
adresse_module = -1;
entrees = "";
mode_entrees = 0;
mise_a_jour_module_entrees();
}
}
}
Shipheart_formulaire_ligne_separation {
haut_bas_hautbas: shipheart_formulaire_ligne_separation_basse
}
}
//-------------------------------------------------------------------------------
// Ligne de formulaire : Adresse_module
Rectangle {
id: ligne_module_entrees
width: (shipheart_largeur_page * pourcentage_largeur_colonne_gauche) - (espace_colonnes_principales / 2)
height: visible ? hauteur_ligne_formulaire : 0
color: "transparent"
visible: (champ_formulaire_Type_entrees.currentIndex !== 0)
&& (type_entrees < shipheart_capteur_type_entrees_calculee_booleen)
Shipheart_formulaire_label {
text: qsTr("Module")
width: parent.width * pourcentage_largeur_labels_formulaire
couleur: (champ_formulaire_Adresse_module.currentIndex !== 0)
? shipheart_formulaire_couleur_texte_par_defaut
: shipheart_formulaire_couleur_texte_en_erreur
}
Shipheart_formulaire_combobox {
id: champ_formulaire_Adresse_module
model: ListModel { }
width: parent.width * (1 - pourcentage_largeur_labels_formulaire)
onActivated: {
shipheart_clic();
if (adresse_module !== champ_formulaire_Adresse_module.model.get(champ_formulaire_Adresse_module.currentIndex).valeur)
{
adresse_module = champ_formulaire_Adresse_module.model.get(champ_formulaire_Adresse_module.currentIndex).valeur;
entrees = "";
mode_entrees = 0;
mise_a_jour_entrees();
}
}
}
Shipheart_formulaire_ligne_separation {
haut_bas_hautbas: shipheart_formulaire_ligne_separation_basse
}
}
//-------------------------------------------------------------------------------
// Ligne de formulaire : Entrees
Rectangle {
id: ligne_entrees
width: (shipheart_largeur_page * pourcentage_largeur_colonne_gauche) - (espace_colonnes_principales / 2)
height: visible ? (champ_formulaire_Entrees.height + 10) : 0
color: "transparent"
visible: ligne_module_entrees.visible
&& (champ_formulaire_Adresse_module.currentIndex !== 0)
&& (type_entrees < shipheart_capteur_type_entrees_calculee_booleen)
Shipheart_formulaire_label {
text: qsTr("Affectation")
width: parent.width * pourcentage_largeur_labels_formulaire
couleur: ( (champ_formulaire_Entrees.currentIndex !== 0) || ((type_entrees === shipheart_capteur_type_entrees_aux) && (nb_entrees > 0)) )
? shipheart_formulaire_couleur_texte_par_defaut
: shipheart_formulaire_couleur_texte_en_erreur
}
Shipheart_formulaire_combobox {
id: champ_formulaire_Entrees
visible: (type_entrees !== shipheart_capteur_type_entrees_aux) // On n'affiche pas dans le cas d'entrées AUX.
model: ListModel { }
width: parent.width * (1 - pourcentage_largeur_labels_formulaire)
onActivated: {
shipheart_clic();
entrees = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).entrees;
if (flag_affichage_mode_entrees) mise_a_jour_mode_entrees(); // Cas "normal" où le Mode_entree doit être traité
else mise_a_jour_famille(); // Si pas de Mode_entree, on passe directement à la Famille.
}
}
Shipheart_formulaire_ligne_separation {
visible: (type_entrees !== shipheart_capteur_type_entrees_aux) // On n'affiche pas dans le cas d'entrées AUX.
haut_bas_hautbas: shipheart_formulaire_ligne_separation_basse
}
}
// Cas particulier des entrées AUX :
Rectangle {
id: ligne_entrees_aux
width: (shipheart_largeur_page * pourcentage_largeur_colonne_gauche) - (espace_colonnes_principales / 2)
height: visible ? ( hauteur_ligne_formulaire * (Math.trunc((shipheart_capteur_max_nombre_entrees_aux-1) / 4) + 1) ) : 0
color: "transparent"
visible: ligne_entrees.visible
&& (type_entrees === shipheart_capteur_type_entrees_aux)
GridView {
id: entrees_aux_grid
width: parent.width
height: parent.height
anchors.verticalCenter: parent.verticalCenter;
cellWidth: (shipheart_capteur_max_nombre_entrees_aux < 4) ? (width / shipheart_capteur_max_nombre_entrees_aux) : (width / 4) // On exclus le cas où shipheart_capteur_max_nombre_entrees_aux=0...
cellHeight: height / (Math.trunc((shipheart_capteur_max_nombre_entrees_aux-1) / 4) + 1)
snapMode: GridView.SnapToRow // L'arret de l'affichage se fera sur une rangée entière
clip: true // Nécessaire pour que les Delegates s'arretent à l'intérieur de la GridView
model: ListModel { }
delegate: Rectangle {
width: entrees_aux_grid.cellWidth - 5
height: entrees_aux_grid.cellHeight - 5
radius: shipheart_rayon_bouton
color: couleur_gris_tres_fonce_transparent
Text {
anchors.fill: parent
horizontalAlignment: Qt.AlignHCenter
verticalAlignment: Qt.AlignVCenter
text: (model.no_entree_aux === 0) ? qsTr("%1 : Non définie").arg(model.no) : qsTr("%1 : %2").arg(model.no).arg(model.libelle)
color: (model.no_entree_aux === 0) ? couleur_gris_tres_pale_transparent : couleur_blanc_casse
font.pixelSize: 15
wrapMode: Label.Wrap
}
/* Text {
anchors.fill: parent
horizontalAlignment: Qt.AlignHCenter
verticalAlignment: Qt.AlignBottom
bottomPadding: 5
text: qsTr("Première entrée du capteur")
color: (model.no_entree_aux === 0) ? couleur_gris_tres_pale : couleur_blanc_casse
font.pixelSize: 10
visible: model.no === 1
}
*/
MouseArea {
id: mouse_area_entree_aux
anchors.fill: parent
onClicked: {
shipheart_clic();
entree_en_cours = model.no;
boite_selection_entree_aux.nom_equipement = Fonctions.nom_type_equipement(shipheart_source_mesure_capteur);
boite_selection_entree_aux.open();
}
}
}
ScrollBar.vertical: ScrollBar { }
}
Shipheart_formulaire_ligne_separation {
haut_bas_hautbas: shipheart_formulaire_ligne_separation_basse
}
}
//-------------------------------------------------------------------------------
// Ligne de formulaire : Mode_entrees
Rectangle {
id: ligne_mode_entrees
width: (shipheart_largeur_page * pourcentage_largeur_colonne_gauche) - (espace_colonnes_principales / 2)
height: visible ? hauteur_ligne_formulaire : 0
color: "transparent"
visible: ligne_entrees.visible
&& ( (champ_formulaire_Entrees.currentIndex !== 0) ||
((type_entrees === shipheart_capteur_type_entrees_aux) && (nb_entrees > 0)) )
&& flag_affichage_mode_entrees
&& (type_entrees < shipheart_capteur_type_entrees_calculee_booleen)
Shipheart_formulaire_label {
text: qsTr("Mode du capteur")
width: parent.width * pourcentage_largeur_labels_formulaire
couleur: ((champ_formulaire_Mode_entrees.currentIndex !== 0) || (type_entrees === shipheart_capteur_type_entrees_aux)) // Pour les entrées AUX, le cas de Mode_entrees=0 est Valide car corrrespond au mode NORMAL
? shipheart_formulaire_couleur_texte_par_defaut
: shipheart_formulaire_couleur_texte_en_erreur
}
Shipheart_formulaire_combobox {
id: champ_formulaire_Mode_entrees
model: ListModel { }
width: parent.width * (1 - pourcentage_largeur_labels_formulaire)
onActivated: {
shipheart_clic();
mode_entrees = champ_formulaire_Mode_entrees.model.get(champ_formulaire_Mode_entrees.currentIndex).valeur;
mise_a_jour_famille();
mise_a_jour_unite();
}
}
Shipheart_formulaire_ligne_separation {
haut_bas_hautbas: shipheart_formulaire_ligne_separation_basse
}
}
//-------------------------------------------------------------------------------
// Ligne de formulaire : Famille
Rectangle {
id: ligne_famille
width: (shipheart_largeur_page * pourcentage_largeur_colonne_gauche) - (espace_colonnes_principales / 2)
height: visible ? hauteur_ligne_formulaire : 0
color: "transparent"
visible: (type_entrees >= shipheart_capteur_type_entrees_calculee_booleen) ||
( ligne_entrees.visible
// && (champ_formulaire_Entrees.currentIndex !== 0)
&& ( (champ_formulaire_Entrees.currentIndex !== 0) ||
((type_entrees === shipheart_capteur_type_entrees_aux) && (nb_entrees > 0)) )
&& ( (champ_formulaire_Mode_entrees.currentIndex !== 0)
|| (type_entrees === shipheart_capteur_type_entrees_aux) // Pour les entrées AUX, le cas de Mode_entrees=0 est Valide car corrrespond au mode NORMAL
|| (!flag_affichage_mode_entrees) ) )
Shipheart_formulaire_label {
text: qsTr("Groupe de capteurs")
width: parent.width * pourcentage_largeur_labels_formulaire
couleur: (champ_formulaire_Famille.currentIndex !== 0)
? shipheart_formulaire_couleur_texte_par_defaut
: shipheart_formulaire_couleur_texte_en_erreur
}
Shipheart_formulaire_combobox {
id: champ_formulaire_Famille
model: ListModel { }
width: parent.width * (1 - pourcentage_largeur_labels_formulaire)
onActivated: {
shipheart_clic();
if ( (type_entrees === shipheart_capteur_type_entrees_aux) || (type_entrees === shipheart_capteur_type_entrees_calculee_booleen) )
{
mise_a_jour_libelles();
}
}
}
Shipheart_formulaire_ligne_separation {
haut_bas_hautbas: shipheart_formulaire_ligne_separation_basse
}
}
//-------------------------------------------------------------------------------
// Lignes de formulaire : Libelles des valeurs discrètes
ListView {
id: liste_libelles
visible: ligne_famille.visible
&& (champ_formulaire_Famille.currentIndex !== 0)
&& ( (type_entrees === shipheart_capteur_type_entrees_aux)
|| (type_entrees === shipheart_capteur_type_entrees_calculee_booleen) )
width: (shipheart_largeur_page * pourcentage_largeur_colonne_gauche) - (espace_colonnes_principales / 2)
height: (hauteur_ligne_formulaire * nb_libelles)
snapMode: GridView.SnapToRow // L'arret de l'affichage se fera sur une rangée entière
clip: true // Nécessaire pour que les Delegates s'arretent à l'intérieur de la GridView
model: ListModel {}
delegate: Rectangle {
width: liste_libelles.width
height: (liste_libelles.height / nb_libelles)
color: "transparent"
Rectangle {
width: liste_libelles.width
height: hauteur_ligne_formulaire
color: "transparent"
Shipheart_formulaire_label {
text: qsTr("Libellé du capteur pour la valeur %1").arg(valeur)
width: parent.width * pourcentage_largeur_labels_formulaire
couleur: shipheart_formulaire_couleur_texte_par_defaut
}
Shipheart_formulaire_textfield {
id: libelle_entrees
width: parent.width * (1 - pourcentage_largeur_labels_formulaire)
x: parent.width * pourcentage_largeur_labels_formulaire
text: libelle
placeholderText: valeur // Permet de faire apparaitre la valeur par défaut
onEditingFinished: {
liste_libelles.model.set(valeur, {"libelle": text}); // Mémorisation de la valeur entrée dans le TextField
}
}
Shipheart_formulaire_ligne_separation {
haut_bas_hautbas: shipheart_formulaire_ligne_separation_basse
}
}
}
ScrollBar.vertical: ScrollBar {}
}
//-------------------------------------------------------------------------------
// Ligne de formulaire : Masquage
Rectangle {
id: ligne_masquage
width: (shipheart_largeur_page * pourcentage_largeur_colonne_gauche) - (espace_colonnes_principales / 2)
height: visible ? hauteur_ligne_formulaire : 0
color: "transparent"
visible: ligne_famille.visible
&& (champ_formulaire_Famille.currentIndex !== 0)
Shipheart_formulaire_label {
text: qsTr("Masquer sur la page Capteurs")
width: parent.width * pourcentage_largeur_labels_formulaire
}
Shipheart_formulaire_checkbox {
id: champ_formulaire_Masquage
width: parent.width * (1 - pourcentage_largeur_labels_formulaire)
onCheckedChanged: {
shipheart_clic();
}
}
Shipheart_formulaire_ligne_separation {
haut_bas_hautbas: shipheart_formulaire_ligne_separation_basse
}
}
}
}
}
//-------------------------------------------------------
// Ecran Droite :
//-------------------------------------------------------
Rectangle {
id: zone_affichage_droite
x: zone_affichage_haut_gauche.width + espace_colonnes_principales
y: shipheart_hauteur_bandeau_haut;
width: (shipheart_largeur_page * (1 - pourcentage_largeur_colonne_gauche)) - (espace_colonnes_principales / 2)
height: (affichage_hauteur_utile * pourcentage_hauteur_ligne_haut) - (espace_lignes_principales / 2);
color: "transparent"
Column {
anchors.fill: parent
spacing: 10
//-------------------------------------------------------
// Bouton Enregistrer/créer :
//-------------------------------------------------------
Rectangle {
id: bouton_enregistrer_creer
width: parent.width
height: hauteur_bouton_droit
color: shipheart_couleur_fond_bouton
radius: shipheart_rayon_bouton
visible:
!clavier.active && // Si le clavier est déplié, // SDIR #255
// Note: ligne revalidée pour 3.4.10 car la saisie des libellés de texte est perdue si on enregistre avant de sortir du focus OU de replier le clavier.
(champ_formulaire_Nom.text !== "") // ... ou si le nom est vide,
&& (champ_formulaire_Type_entrees.currentIndex !== 0) // ... ou si aucune affectation à un capteur n'a été faite,
&& ( (type_entrees >= shipheart_capteur_type_entrees_calculee_booleen) // ... ou ce n'est pas un capteur calculé
|| ( (champ_formulaire_Adresse_module.currentIndex !== 0)
&& ( (champ_formulaire_Entrees.currentIndex !== 0) ||
((type_entrees === shipheart_capteur_type_entrees_aux) && (nb_entrees > 0)) ) // ... et aucune Entrée sélectionnée
&& ((champ_formulaire_Mode_entrees.currentIndex !== 0) // ... ou aucun Mode sélectionné
|| (type_entrees === shipheart_capteur_type_entrees_aux) // Sauf pour les entrées AUX, le cas de Mode_entrees=0 est Valide car corrrespond au mode NORMAL
|| (!flag_affichage_mode_entrees) ) ) ) // Sauf si pas besoin de Mode
&& (champ_formulaire_Famille.currentIndex !== 0) // ... ou si aucune affectation à un groupe n'a été faite, on n'autorise pas la'enregistrement/création.
Text {
anchors {
verticalCenter: parent.verticalCenter
horizontalCenter: parent.horizontalCenter
}
font.pixelSize: 20
text: (id_capteur === 0) ? qsTr("Créer le capteur") : qsTr("Enregistrer")
color: couleur_blanc_casse
}
MouseArea {
anchors.fill: parent
onClicked: {
shipheart_clic();
if (id_capteur !== 0) mise_a_jour_capteur(); // Mise à jour des données saisies dans la BDD et reconfiguration par l'application pour prise en compte.
else creation_capteur();
timer_tempo_reconfiguration.restart();
}
}
}
//-------------------------------------------------------
// Bouton d'accès à l'équation
// NB : On donne l'accès à l'équation même si le capteur n'est pas encore créé MAIS que toutes les conditions de création sont réunies.
// Dans ce cas, on effectue la création automatiquement avant de donner l'accès à l'équation.
//-------------------------------------------------------
Rectangle {
width: parent.width
height: hauteur_bouton_droit
color: shipheart_couleur_fond_bouton
radius: shipheart_rayon_bouton
visible: bouton_enregistrer_creer.visible
&& (type_entrees >= shipheart_capteur_type_entrees_calculee_booleen)
Text {
anchors {
verticalCenter: parent.verticalCenter
horizontalCenter: parent.horizontalCenter
}
font.pixelSize: 20
text: qsTr("Equation")
color: couleur_blanc_casse
}
MouseArea {
anchors.fill: parent
onClicked: {
shipheart_clic();
if (id_capteur === 0) creation_capteur(); // Si le capteur n'a pas encore été créé et qu'on demande l'éccès à l'équation, on commence par créer le capteur (sinon, on ne peut pas affecter les conditions à un ID_Capteur...)
stackView.push("config_capteur_calcule_booleen.qml", {"id_capteur": id_capteur})
}
}
}
//-------------------------------------------------------
// Bouton de suppression
//-------------------------------------------------------
Rectangle {
width: parent.width
height: hauteur_bouton_droit
color: shipheart_couleur_fond_bouton
radius: shipheart_rayon_bouton
visible: bouton_enregistrer_creer.visible && (id_capteur !== 0)
Rectangle { // Barre grandissante pour montrer durée d'appui vs tempo nécessaire :
width: (valeur_timer_appui_long / shipheart_mouse_press_and_hold_interval_tres_long) * parent.width
height: parent.height
color: couleur_rouge_transparent
radius: shipheart_rayon_bouton
visible: mousearea_bouton_supprimer.pressed
}
Text {
anchors {
verticalCenter: parent.verticalCenter
horizontalCenter: parent.horizontalCenter
}
font.pixelSize: 20
text: qsTr("Supprimer")
color: couleur_blanc_casse
}
MouseArea {
id: mousearea_bouton_supprimer
anchors.fill: parent
onPressed: { // Déclenché lors de l'appui inital
timer_appui_long.running = true;
valeur_timer_appui_long = 0;
shipheart_clic();
}
onClicked: { // Déclenché si l'appui n'a pas été suffisement long pour avoir un Press&Hold :
timer_appui_long.running = false;
valeur_timer_appui_long = 0;
}
onExited: { // Déclenché si le doigt sort de la zone du bouton (sinon, on continue à compter alors qu'on est sorti de la zone et même relaché le doigt !!)
timer_appui_long.running = false;
valeur_timer_appui_long = 0;
}
}
}
//-------------------------------------------------------
// Bouton Etalonnage :
//-------------------------------------------------------
Rectangle {
width: parent.width
height: hauteur_bouton_droit
color: shipheart_couleur_fond_bouton
radius: shipheart_rayon_bouton
visible: flag_affichage_offset && bouton_enregistrer_creer.visible
Text {
anchors {
verticalCenter: parent.verticalCenter
horizontalCenter: parent.horizontalCenter
}
font.pixelSize: 20
text: qsTr("Etalonner")
color: couleur_blanc_casse
}
MouseArea {
anchors.fill: parent
onClicked: {
shipheart_clic();
stackView.push("etalonnage_capteur.qml", {"id_capteur": id_capteur})
}
}
}
//-------------------------------------------------------
// Timer de reconfiguration :
//-------------------------------------------------------
Timer {
id: timer_tempo_reconfiguration
interval: 250 // Cette tempo n'est utilisée que pour le premier cycle
triggeredOnStart: false
running: false
repeat: true
onTriggered: {
if (bdd.check_fin_configuration())
{
timer_tempo_reconfiguration.stop();
stackView.pop(); // Retour à la page de config des capteurs
}
else timer_tempo_reconfiguration.interval = 100 // Tempo plus courte pour les lectures suivantes
}
}
}
}
//-------------------------------------------------------
// Bandeau bas :
//-------------------------------------------------------
Row {
x: 0
y: shipheart_hauteur_page - shipheart_hauteur_bandeau_bas;
width: shipheart_largeur_page;
height: shipheart_hauteur_bandeau_bas;
spacing: 5
padding: 5
//.................................................
// Bouton retournb_entrees
//.................................................
Rectangle {
id: bandeau_bas_zone_retour
width: (parent.width * pourcentage_bandeau_bas_largeur_zone_retour) - (2 * parent.padding)
height: shipheart_hauteur_bandeau_bas - parent.topPadding - parent.bottomPadding;
radius: shipheart_rayon_bouton
color: shipheart_couleur_fond_bouton
Image {
source: "/images/icone_retour.png"
sourceSize.height: 30
anchors {
verticalCenter: parent.verticalCenter
horizontalCenter: parent.horizontalCenter
}
}
MouseArea { // Zone d'interaction. On est obligé de la mettre dans la grille pour que Rectangle et MouseArea soient frères ou parent/enfant ET qu'on n'occupe qu'un espace dans la grille.
id: mouse_area_bandeau_bas_zone_retour
anchors.fill: parent
onClicked: {
shipheart_clic();
stackView.pop()
}
}
}
}
//-------------------------------------------------------
// Boite de sélection entrée aux :
//-------------------------------------------------------
Shipheart_boite_dialogue_entrees_aux {
id: boite_selection_entree_aux
boutonAnnuler: true
boutonAnnulerTexte: "Annuler"
onClicked: {
if (bouton === shipheart_boite_dialogue_bouton_1)
{
var groupe = recherche_groupe_entree_aux(no_entree - 1);
if (modele_entrees_aux.get(groupe).valeurs.get((no_entree - 1) % 4).no_entree === entree_en_cours) // Si on reclique sur l'entrée déjà affectée, on supprime l'affectation.
{
entrees_aux_grid.model.set((entree_en_cours - 1), {"no_entree_aux" : 0, "libelle": ""});
modele_entrees_aux.get(groupe).valeurs.set(((no_entree - 1) % 4), {"used": 0, "no_entree": 0});
nb_entrees --;
}
else // Si on clique sur une autre entrée...
{
// ... on vérifie si le n° était déjà affecté à une entrée aux. Si oui, on supprime cette affectation avant de créer la nouvelle :
var i = entrees_aux_grid.model.get(entree_en_cours - 1).no_entree_aux;
if (i !== 0)
{
var g = recherche_groupe_entree_aux(i - 1);
modele_entrees_aux.get(g).valeurs.set(((i - 1) % 4), {"used": 0, "no_entree": 0});
nb_entrees --;
}
// On met ensuite à jour la nouvelle affectation :
entrees_aux_grid.model.set((entree_en_cours - 1), {"no_entree_aux" : no_entree, "libelle": "AUX INPUT " + no_entree });
modele_entrees_aux.get(groupe).valeurs.set(((no_entree - 1) % 4), {"used": 1, "no_entree": entree_en_cours});
nb_entrees ++;
}
if (flag_affichage_mode_entrees) mise_a_jour_mode_entrees(); // Cas "normal" où le Mode_entree doit être traité
else mise_a_jour_famille(); // Si pas de Mode_entree, on passe directement à la Famille.
boite_selection_entree_aux.close();
}
}
}
ListModel {
id: modele_entrees_aux
}
//-------------------------------------------------------
// Boite d'info :
//-------------------------------------------------------
Shipheart_boite_dialogue {
id: boite_information
}
//===========================================================
// Busy Indicator :
//===========================================================
Shipheart_busy_indicator {
id: busy_indicator
running: timer_tempo_reconfiguration.running
}
// Note : il est inutile de prévoir un Mousearea pour sortir de l'économiseur sur cette page puisqu'il
// est systématiquement bloqué pour toutes les pages lancées depuis 'Paramètres Avancés'.
//=============================================================================================================
// Init de la page
//=============================================================================================================
function init_page()
{
var req, res;
var i;
//console.log("Id du capteur = " + id_capteur);
//---------------------------------------------------------------------------------------
// Caractéristiques du capteur en cours :
//---------------------------------------------------------------------------------------
champ_formulaire_Nom.text = "";
if (id_capteur > 0) // Cas d'une modification de capteur existant :
{
req = 'SELECT Nom, ';
req += ' Adresse_module, ';
req += ' Type_entrees, ';
req += ' Entrees, ';
req += ' Mode_entrees, ';
req += ' Priorite_affichage_accueil, ';
req += ' ID_Famille, ';
req += ' ID_Variable, ';
req += ' Liste_valeurs_textes ';
req += ' FROM TB_Capteurs ';
req += ' WHERE Cle_primaire=' + id_capteur + ' ';
//console.log("Requête = [ " + req + "; ]");
res = bdd.requete_unique(req);
// Récupération des données :
i = 0;
champ_formulaire_Nom.text = res[i ++];
adresse_module = Number(res[i ++]);
type_entrees = Number(res[i ++]);
entrees = res[i ++];
mode_entrees = Number(res[i ++]);
priorite_affichage_accueil = Number(res[i ++]);
id_famille = Number(res[i ++]);
id_variable = Number(res[i ++]);
liste_valeurs_textes = res[i ++];
// Cas particulier d'un capteur sur entrée NMEA :
if (type_entrees === shipheart_capteur_type_entrees_nmea) flag_nmea = true;
// Traitement de Masquage :
if (priorite_affichage_accueil <= 0) champ_formulaire_Masquage.checked = true;
else champ_formulaire_Masquage.checked = false;
// Cas particulier d'accès au réglage de l'offset pour PAT uniquement :
if ((type_entrees === shipheart_capteur_type_entrees_predefinie) && (entrees === shipheart_capteur_predefini_pat + "")) flag_affichage_offset = true;
}
// Remplissage des différents modèles, dasn l'ordre des priorités :
mise_a_jour_type_entrees();
flag_init = false; // Indique que l'init est terminée
}
//=============================================================================================================
// MAJ du type d'entrées
//=============================================================================================================
function mise_a_jour_type_entrees()
{
var i;
//---------------------------------------------------------------------------------------
// Type d'entrée :
//---------------------------------------------------------------------------------------
// Effacement du modèle et premier enregistrement avec 'Non défini' :
champ_formulaire_Type_entrees.model.clear();
champ_formulaire_Type_entrees.model.append( {
"valeur": 0,
"texte": qsTr("Non défini"),
"actif": true });
champ_formulaire_Type_entrees.model.append( {
"valeur": shipheart_capteur_type_entrees_aux,
"texte": qsTr("Entrées Auxiliaires (AUX INPUTS)"),
"actif": true });
champ_formulaire_Type_entrees.model.append( {
"valeur": shipheart_capteur_type_entrees_level_sensor,
"texte": qsTr("Entrées Niveau (LEVEL SENSORS)"),
"actif": true });
champ_formulaire_Type_entrees.model.append( {
"valeur": shipheart_capteur_type_entrees_volt,
"texte": qsTr("Entrées Tension (VOLTAGE INPUTS)"),
"actif": true });
champ_formulaire_Type_entrees.model.append( {
"valeur": shipheart_capteur_type_entrees_ow,
"texte": qsTr("Capteurs de température (ONE WIRE)"),
"actif": true });
champ_formulaire_Type_entrees.model.append( {
"valeur": shipheart_capteur_type_entrees_nmea,
"texte": qsTr("Entrées NMEA2000"),
"actif": true });
champ_formulaire_Type_entrees.model.append( {
"valeur": shipheart_capteur_type_entrees_predefinie,
"texte": qsTr("Capteurs sur modules"),
"actif": true });
champ_formulaire_Type_entrees.model.append( {
"valeur": shipheart_capteur_type_entrees_calculee_booleen,
"texte": qsTr("Calculé (conditions logiques)"),
"actif": true });
/* champ_formulaire_Type_entrees.model.append( {
"valeur": shipheart_capteur_type_entrees_calculee_numerique,
"texte": qsTr("Calculé (valeur numérique)"),
"actif": true });
*/
// Mise à jour de l'index courant du modèle champ_formulaire_Type_entrees :
i = recherche_index_valeur_modele(type_entrees, champ_formulaire_Type_entrees.model, "Type_entrees");
if (i === -1) champ_formulaire_Type_entrees.currentIndex = recherche_index_valeur_modele(0, champ_formulaire_Type_entrees.model, "Type_entrees");
else champ_formulaire_Type_entrees.currentIndex = i;
// Appel du remplissage des modèles de niveau inférieur si cela est possible :
if (type_entrees !== 0)
{
mise_a_jour_module_entrees();
}
}
//=============================================================================================================
// MAJ du module d'entrées
//=============================================================================================================
function mise_a_jour_module_entrees()
{
var req, res;
var nb;
var i;
var flag_valide;
// Effacement du modèle :
champ_formulaire_Adresse_module.model.clear();
champ_formulaire_Adresse_module.model.append({"valeur": -1, "texte": qsTr("Non défini"), "actif": true });
champ_formulaire_Adresse_module.currentIndex = 0; // Par défaut
// Remplissage du modèle avec les modules en config :
req = 'SELECT Adresse_k_bus, Type FROM TB_Modules_config ORDER BY Adresse_k_bus';
nb = bdd.requete(req);
//console.log("Requête = [ " + req + "; ]");
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
flag_valide = false;
switch(Number(res[1])) // Type de module
{
//--------------------------------------
case shipheart_type_module_shipbase:
flag_valide = true; // Tous les types sont accessibles sur ShiBase donc inutile de tester...
break;
//--------------------------------------
case shipheart_type_module_shippower812:
case shipheart_type_module_shipBS:
case shipheart_type_module_shippower4AC:
case shipheart_type_module_shippower8DC:
if (type_entrees === shipheart_capteur_type_entrees_predefinie) flag_valide = true;
else flag_valide = false;
break;
//--------------------------------------
default:
flag_valide = false; // Le type est inconnu donc, dans le doute, on ne donne pas accès à ce module
break;
}
// Ajout de l'entrée dans le modèle si le module est considéré comme compatible avec le type d'entrée sélectionné:
if (flag_valide)
{
champ_formulaire_Adresse_module.model.append({
"valeur": Number(res[0]),
"texte": "@" + res[0] + " - " + Fonctions.nom_type_module(Number(res[1])),
"actif": true
});
// Mise à jour de l'index du mdoèle si l'on est sur l'entrée en cours :
if (Number(res[0]) === adresse_module) champ_formulaire_Adresse_module.currentIndex = (i+1);
}
}
}
// Si le Type_entrées est != de ENTREES_PREDEFINIES, on est sûr qu'il n'y aura que ShipBase (pour le moment au moins...) :
if (type_entrees !== shipheart_capteur_type_entrees_predefinie) adresse_module = 0;
// Mise à jour de l'index courant du modèle champ_formulaire_Module_entrees :
i = recherche_index_valeur_modele(adresse_module, champ_formulaire_Adresse_module.model, "adresse_module");
if (i === -1) champ_formulaire_Adresse_module.currentIndex = recherche_index_valeur_modele(-1, champ_formulaire_Adresse_module.model, "adresse_module");
else champ_formulaire_Adresse_module.currentIndex = i;
// Appel du remplissage des modèles de niveau inférieur si cela est possible :
if (adresse_module >= 0) mise_a_jour_entrees();
}
//=============================================================================================================
// MAJ des Entrées
//=============================================================================================================
function mise_a_jour_entrees()
{
var req, res;
var nb;
var i, j;
var chaines_entrees;
var no;
//---------------------------------------------------------------------------------------
// Mise à jour du modèle des entrées :
//
// Pour tous les types à l'exception de ENTREES AUX, on utilise le modèle 'champ_formulaire_Entrees' qui pointe vers une ComboBox.
// Ce modèle comprend donc une liste de choix parmi lesquel il faut en sélectionner 1.
// Pour le type ENTREES AUX, on utilise 2 modèles dédié :
// - 'entrees_aux_grid' qui contient les entrées du capteur (le nombre est le max possible, soit 4 a priori).
// - 'modele_entrees_aux' qui contient les 32 entrées AUX de ShipBase (et, demain, celles du module sélectionné...).
champ_formulaire_Entrees.model.clear();
champ_formulaire_Entrees.model.append({"entrees": "", "texte": qsTr("Non défini"), "actif": true });
champ_formulaire_Entrees.currentIndex = 0; // Si aucune entrée n'est trouvée (cas d'une création par exemple), l'index est égal à 0
switch(type_entrees)
{
//----------------------------------------
// Entrées AUX :
//----------------------------------------
case shipheart_capteur_type_entrees_aux:
var val;
// Entrées AUX du capteur :
entrees_aux_grid.model.clear();
chaines_entrees = entrees.split(';');
if (entrees !== "") nb_entrees = chaines_entrees.length // Si la chaine est vide, le split renvoi 1... Exactement comme dans le cas où il y a une seule valeur...
else nb_entrees = 0;
for (i = 0; i < shipheart_capteur_max_nombre_entrees_aux; i ++)
{
if (i < nb_entrees) val = Number(chaines_entrees[i]);
else val = 0;
entrees_aux_grid.model.append( { "no": (i + 1),
"no_entree_aux" : val,
"libelle": (val === 0) ? "FFFFF" : "AUX INPUT " + val });
}
//---------------------------------------------------------------------------------------
// Entrées auxiliaires physiques :
// Les 32 entrées AUX de ShipBase par exemple
var entrees_aux = [];
// remplissage par défaut de toutes les entrées AUX possibles :
for (i=0; i<shipheart_entrees_aux_max_nombre; i++)
{
val = chaines_entrees.indexOf("" + (i+1) + "") + 1; // Le '+1' permet de passer de l'index (0..n) à un numéro d'entrée du capteur (1..N) mais aussi de passer de l'erreur (-1) à la valeur par défaut (0)
entrees_aux.push({'used': 0, 'no_entree': val}); // Init par défaut
}
// Mise à jour en fonction des entrées déjà utilisées par ailleurs (capteurs et réservoirs) :
req = '(SELECT ' + shipheart_source_mesure_reservoir + ' AS Type, Entrees ';
req += 'FROM TB_Reservoirs WHERE ';
req += 'Type_entrees=' + shipheart_reservoir_type_entrees_aux + ') ';
req += ' UNION ';
req += '(SELECT ' + shipheart_source_mesure_capteur + ' AS Type, Entrees ';
req += 'FROM TB_Capteurs WHERE ';
req += 'Type_entrees=' + shipheart_reservoir_type_entrees_aux + ') ';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
chaines_entrees = res[1].split(';');
for(j = 0; j < chaines_entrees.length; j ++)
{
no = Number(chaines_entrees[j]);
if ((no >= 1) && (no <= shipheart_entrees_aux_max_nombre)) entrees_aux[no - 1]['used'] = 1; // le n° d'entrée doit être dans [1; 32]
}
}
}
modele_entrees_aux.clear();
i = 17;
modele_entrees_aux.append({valeurs: [{no: i, used: entrees_aux[i-1]['used'], no_entree: entrees_aux[i-1]['no_entree'] },
{no: (i+1), used: entrees_aux[i+0]['used'], no_entree: entrees_aux[i+0]['no_entree'] },
{no: (i+2), used: entrees_aux[i+1]['used'], no_entree: entrees_aux[i+1]['no_entree'] },
{no: (i+3), used: entrees_aux[i+2]['used'], no_entree: entrees_aux[i+2]['no_entree'] }] } );
i = 21;
modele_entrees_aux.append({valeurs: [{no: i, used: entrees_aux[i-1]['used'], no_entree: entrees_aux[i-1]['no_entree'] },
{no: (i+1), used: entrees_aux[i+0]['used'], no_entree: entrees_aux[i+0]['no_entree'] },
{no: (i+2), used: entrees_aux[i+1]['used'], no_entree: entrees_aux[i+1]['no_entree'] },
{no: (i+3), used: entrees_aux[i+2]['used'], no_entree: entrees_aux[i+2]['no_entree'] }] } );
i = 25;
modele_entrees_aux.append({valeurs: [{no: i, used: entrees_aux[i-1]['used'], no_entree: entrees_aux[i-1]['no_entree'] },
{no: (i+1), used: entrees_aux[i+0]['used'], no_entree: entrees_aux[i+0]['no_entree'] },
{no: (i+2), used: entrees_aux[i+1]['used'], no_entree: entrees_aux[i+1]['no_entree'] },
{no: (i+3), used: entrees_aux[i+2]['used'], no_entree: entrees_aux[i+2]['no_entree'] }] } );
i = 29;
modele_entrees_aux.append({valeurs: [{no: i, used: entrees_aux[i-1]['used'], no_entree: entrees_aux[i-1]['no_entree'] },
{no: (i+1), used: entrees_aux[i+0]['used'], no_entree: entrees_aux[i+0]['no_entree'] },
{no: (i+2), used: entrees_aux[i+1]['used'], no_entree: entrees_aux[i+1]['no_entree'] },
{no: (i+3), used: entrees_aux[i+2]['used'], no_entree: entrees_aux[i+2]['no_entree'] }] } );
i = 1;
modele_entrees_aux.append({valeurs: [{no: i, used: entrees_aux[i-1]['used'], no_entree: entrees_aux[i-1]['no_entree'] },
{no: (i+1), used: entrees_aux[i+0]['used'], no_entree: entrees_aux[i+0]['no_entree'] },
{no: (i+2), used: entrees_aux[i+1]['used'], no_entree: entrees_aux[i+1]['no_entree'] },
{no: (i+3), used: entrees_aux[i+2]['used'], no_entree: entrees_aux[i+2]['no_entree'] }] } );
i = 5;
modele_entrees_aux.append({valeurs: [{no: i, used: entrees_aux[i-1]['used'], no_entree: entrees_aux[i-1]['no_entree'] },
{no: (i+1), used: entrees_aux[i+0]['used'], no_entree: entrees_aux[i+0]['no_entree'] },
{no: (i+2), used: entrees_aux[i+1]['used'], no_entree: entrees_aux[i+1]['no_entree'] },
{no: (i+3), used: entrees_aux[i+2]['used'], no_entree: entrees_aux[i+2]['no_entree'] }] } );
i = 9;
modele_entrees_aux.append({valeurs: [{no: i, used: entrees_aux[i-1]['used'], no_entree: entrees_aux[i-1]['no_entree'] },
{no: (i+1), used: entrees_aux[i+0]['used'], no_entree: entrees_aux[i+0]['no_entree'] },
{no: (i+2), used: entrees_aux[i+1]['used'], no_entree: entrees_aux[i+1]['no_entree'] },
{no: (i+3), used: entrees_aux[i+2]['used'], no_entree: entrees_aux[i+2]['no_entree'] }] } );
i = 13;
modele_entrees_aux.append({valeurs: [{no: i, used: entrees_aux[i-1]['used'], no_entree: entrees_aux[i-1]['no_entree'] },
{no: (i+1), used: entrees_aux[i+0]['used'], no_entree: entrees_aux[i+0]['no_entree'] },
{no: (i+2), used: entrees_aux[i+1]['used'], no_entree: entrees_aux[i+1]['no_entree'] },
{no: (i+3), used: entrees_aux[i+2]['used'], no_entree: entrees_aux[i+2]['no_entree'] }] } );
// Mise à jour du flag d'utilisation du paramètre Mode_entrées :
flag_affichage_mode_entrees = true; // NB : pour les entrées AUX, on utilise une case à cocher
break;
//----------------------------------------
// Entrées Level Sensor :
//----------------------------------------
case shipheart_capteur_type_entrees_level_sensor:
for (i=0; i<shipheart_entrees_level_sensor_max_nombre; i++)
{
champ_formulaire_Entrees.model.append({
"entrees": ""+(i+1)+"",
"texte": "# "+ (i+1) + " - " + qsTr("<i>Entrée non utilisée</i>"),
"actif": true,
"code_variable": shipheart_capteur_sans_unite, // On ne sait pas le renseigner à ce stade. Sera renseigné lorsque le Mode_entree sera renseigné.
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 0, // Idem
"precision_affichage_mesures": 0 // Idem
});
// Mise à jour de l'index du mdoèle si l'on est sur l'entrée en cours :
if ((i+1) === Number(entrees)) champ_formulaire_Entrees.currentIndex = (i+1); // Le '+1' sur CurrenIndex car on a déjà ajouté une entrée NON DEFINIE
}
// Mise à jour en fonction des entrées déjà utilisées par ailleurs (capteurs et réservoirs) :
req = '(SELECT ' + shipheart_source_mesure_reservoir + ' AS Type, Nom, Entrees, "'+ shipheart_reservoir_niveau+'" AS Code_variable, 0 AS Precision_affichage_accueil, 0 AS Precision_affichage_mesures ';
req += 'FROM TB_Reservoirs WHERE ';
req += 'Type_entrees=' + shipheart_reservoir_type_entrees_level_sensor + ') ';
req += ' UNION ';
req += '(SELECT ' + shipheart_source_mesure_capteur + ' AS Type, Nom, Entrees, ';
req += ' (SELECT Code FROM TB_Variables WHERE Cle_primaire=ID_Variable) AS Code_variable, Precision_affichage_accueil, Precision_affichage_mesures ';
req += 'FROM TB_Capteurs WHERE ';
req += 'Type_entrees=' + shipheart_capteur_type_entrees_level_sensor + ') ';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
no = Number(res[2]);
if ((no >= 1) && (no <= shipheart_entrees_level_sensor_max_nombre))
{
if (no === Number(entrees)) // Si on est sur l'entrée en cours, on laisse 'actif' à TRUE (et on peut ajuster le texte au passage...)
{
champ_formulaire_Entrees.model.set(no, {
"texte": "# "+ no,
"code_variable": res[3],
"precision_affichage_accueil": Number(res[4]),
"precision_affichage_mesures": Number(res[5])} )
}
else // Si on n'est pas sur l'entrée en cours, on positionne 'actif' à FALSE (et on ajuste le texte pou rinformation)
{
champ_formulaire_Entrees.model.set(no, {
"texte": "#"+ no + " - " + Fonctions.nom_type_equipement(Number(res[0])) + " \"" + res[1] + "\"",
"code_variable": res[3],
"precision_affichage_accueil": Number(res[4]),
"precision_affichage_mesures": Number(res[5]),
"actif": false} )
}
}
}
}
// Mise à jour du flag d'utilisation du paramètre Mode_entrées :
flag_affichage_mode_entrees = true;
break;
//----------------------------------------
// Entrées Voltage Input :
//----------------------------------------
case shipheart_capteur_type_entrees_volt:
for (i=0; i<shipheart_entrees_volt_max_nombre; i++)
{
champ_formulaire_Entrees.model.append({
"entrees": ""+(i+1)+"",
"texte": "# "+ (i+1) + " - " + qsTr("<i>Entrée non utilisée</i>"),
"actif": true,
"code_variable": shipheart_capteur_tension_v,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
// Mise à jour de l'index du mdoèle si l'on est sur l'entrée en cours :
if ((i+1) === Number(entrees)) champ_formulaire_Entrees.currentIndex = (i+1); // Le '+1' sur CurrenIndex car on a déjà ajouté une entrée NON DEFINIE
}
// Mise à jour en fonction des entrées déjà utilisées par ailleurs (capteurs et batteries) :
req = '(SELECT ' + shipheart_source_mesure_batterie + ' AS Type, Nom, Entrees ';
req += 'FROM TB_Batteries WHERE ';
req += 'Type_entrees=' + shipheart_batteries_type_entrees_volt + ') ';
req += ' UNION ';
req += '(SELECT ' + shipheart_source_mesure_capteur + ' AS Type, Nom, Entrees ';
req += 'FROM TB_Capteurs WHERE ';
req += 'Type_entrees=' + shipheart_capteur_type_entrees_volt + ') ';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
no = Number(res[2]);
if ((no >= 1) && (no <= shipheart_entrees_volt_max_nombre))
{
if (no === Number(entrees)) // Si on est sur l'entrée en cours, on laisse 'actif' à TRUE (et on peut ajuster le texte au passage...)
{
champ_formulaire_Entrees.model.set(no, {"texte": "# "+ no} )
}
else // Si on n'est pas sur l'entrée en cours, on positionne 'actif' à FALSE (et on ajuste le texte pou rinformation)
{
champ_formulaire_Entrees.model.set(no, {"texte": "#"+ no + " - " + Fonctions.nom_type_equipement(Number(res[0])) + " \"" + res[1] + "\"", "actif": false} )
}
}
}
}
// Mise à jour du flag d'utilisation du paramètre Mode_entrées :
flag_affichage_mode_entrees = false;
break;
//----------------------------------------
// Entrées OW :
//----------------------------------------
case shipheart_capteur_type_entrees_ow:
// Recherche des capteurs de température physiquement présents :
req = 'SELECT Rom_code ';
req += ', Emplacement ';
req += ' FROM TB_One_wire ';
req += ' WHERE Presence=1 '
req += ' ORDER BY Rom_code';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
champ_formulaire_Entrees.model.append({
"entrees": res[0],
"texte": (res[1] === "") ? (res[0]) : (res[0] + "<br />[" + res[1] + "]"),
"actif": true,
"code_variable": shipheart_capteur_temperature,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
// Mise à jour de l'index du mdoèle si l'on est sur l'entrée en cours :
if (res[0] === entrees) champ_formulaire_Entrees.currentIndex = (i+1); // Le '+1' sur CurrenIndex car on a déjà ajouté une entrée NON DEFINIE
}
}
// Mise à jour en fonction des entrées déjà utilisées par ailleurs (capteurs) :
req = '(SELECT ' + shipheart_source_mesure_capteur + ' AS Type, Nom, Entrees ';
req += 'FROM TB_Capteurs WHERE ';
req += 'Type_entrees=' + shipheart_capteur_type_entrees_ow + ') ';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
for(j = 0; j < champ_formulaire_Entrees.model.count; j ++)
{
if (res[2] === champ_formulaire_Entrees.model.get(j).entrees)
{
if (res[2] === entrees) // Si on est sur l'entrée en cours, on laisse 'actif' à TRUE (et on peut ajuster le texte au passage...)
{
// champ_formulaire_Entrees.model.set(j, {"texte": "# "+ j} )
champ_formulaire_Entrees.model.set(j, {"texte": res[2] + "<br />" + Fonctions.nom_type_equipement(Number(res[0])) + " \"" + res[1] + "\""} )
}
else // Si on n'est pas sur l'entrée en cours, on positionne 'actif' à FALSE (et on ajuste le texte pou rinformation)
{
champ_formulaire_Entrees.model.set(j, {"texte": res[2] + "<br />" + Fonctions.nom_type_equipement(Number(res[0])) + " \"" + res[1] + "\"", "actif": false} )
}
}
}
}
}
// Mise à jour du flag d'utilisation du paramètre Mode_entrées :
flag_affichage_mode_entrees = false;
break;
//----------------------------------------
// Entrées NMEA :
//----------------------------------------
case shipheart_capteur_type_entrees_nmea:
// Recherche des PGN/Fields physiquement présents :
req = 'SELECT Pgn, ';
req += 'Field, ';
req += 'Nom, ';
req += '(SELECT Code FROM TB_Variables WHERE Cle_primaire=ID_Variable) as Code, ';
req += 'Precision_affichage_accueil, ';
req += 'Precision_affichage_mesures ';
req += ' FROM TB_Nmea2000 ';
req += ' ORDER BY Pgn, Field';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
champ_formulaire_Entrees.model.append({
"entrees": res[0] + ":" + res[1],
"texte": "PGN " + res[0] + " [# " + res[1] + "] :<br />" + res[2],
"actif": true,
"code_variable": res[3],
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": Number(res[4]),
"precision_affichage_mesures": Number(res[5]),
});
// Mise à jour de l'index du modèle si l'on est sur l'entrée en cours :
if ((res[0] + ":" + res[1]) === entrees) champ_formulaire_Entrees.currentIndex = (i+1); // Le '+1' sur CurrenIndex car on a déjà ajouté une entrée NON DEFINIE
}
}
// Mise à jour en fonction des entrées déjà utilisées par ailleurs (capteurs) :
req = '(SELECT ' + shipheart_source_mesure_capteur + ' AS Type, Nom, Entrees ';
req += 'FROM TB_Capteurs WHERE ';
req += 'Type_entrees=' + shipheart_capteur_type_entrees_nmea + ') ';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
for(j = 0; j < champ_formulaire_Entrees.model.count; j ++)
{
if (res[2] === champ_formulaire_Entrees.model.get(j).entrees)
{
// Mise à jour du texte en ajoutant le nom du capteur en-dessous :
champ_formulaire_Entrees.model.set(j, {"texte": champ_formulaire_Entrees.model.get(j).texte + "<br />" + Fonctions.nom_type_equipement(Number(res[0])) + " \"" + res[1] + "\""} );
// Si on n'est pas sur l'entrée en cours, on pass l'entrée 'actif' à FALSE :
if (res[2] !== entrees) champ_formulaire_Entrees.model.set(j, {"actif": false} );
}
}
}
}
// Mise à jour du flag d'utilisation du paramètre Mode_entrées :
flag_affichage_mode_entrees = false;
break;
//----------------------------------------
// Entrées Prédéfinies :
//----------------------------------------
case shipheart_capteur_type_entrees_predefinie:
req = 'SELECT Type FROM TB_Modules_config WHERE Adresse_k_bus=' + adresse_module+ ' ';
res = bdd.requete_unique(req);
//console.log("Requête = [ " + req + "; ]");
switch(Number(res[0])) // Type de module
{
//--------------------------------------
case shipheart_type_module_shipbase:
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_pat + "",
"texte": qsTr("Pression Atmosphérique"),
"actif": true,
"code_variable": shipheart_capteur_pression_atm,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_hum + "",
"texte": qsTr("Humidité"),
"actif": true,
"code_variable": shipheart_capteur_humidite,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 1
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_temp + "",
"texte": qsTr("Température module"),
"actif": true,
"code_variable": shipheart_capteur_temperature,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_in_v + "",
"texte": qsTr("Tension d'entrée module"),
"actif": true,
"code_variable": shipheart_capteur_tension_v,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_in_i + "",
"texte": qsTr("Consommation module"),
"actif": true,
"code_variable": shipheart_capteur_courant_a,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_usb_i + "",
"texte": qsTr("Consommation ports USB"),
"actif": true,
"code_variable": shipheart_capteur_courant_a,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
/* champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_edm + "",
"texte": qsTr("Etat de la mer"),
"actif": true,
"code_variable": shipheart_capteur_sans_unite,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_changement_etat,
"precision_affichage_accueil": 0,
"precision_affichage_mesures": 0
});
*/
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_acc_xyz + "",
"texte": qsTr("Chocs"),
"actif": true,
"code_variable": shipheart_capteur_acceleration,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_acc_x + "",
"texte": qsTr("Accélération X"),
"actif": true,
"code_variable": shipheart_capteur_acceleration,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_acc_y + "",
"texte": qsTr("Accélération Y"),
"actif": true,
"code_variable": shipheart_capteur_acceleration,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_acc_z + "",
"texte": qsTr("Accélération Z"),
"actif": true,
"code_variable": shipheart_capteur_acceleration,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_lat + "",
"texte": qsTr("GNSS - Latitude"),
"actif": true,
"code_variable": shipheart_capteur_latitude,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 0,
"precision_affichage_mesures": 0
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_lon + "",
"texte": qsTr("GNSS - Longitude"),
"actif": true,
"code_variable": shipheart_capteur_longitude,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 0,
"precision_affichage_mesures": 0
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_alt + "",
"texte": qsTr("GNSS - Altitude"),
"actif": true,
"code_variable": shipheart_capteur_distance_m,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 1
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_sog + "",
"texte": qsTr("GNSS - SOG<br />Speed Over Ground"),
"actif": true,
"code_variable": shipheart_capteur_vitesse_kts,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_cog + "",
"texte": qsTr("GNSS - COG<br />Course Over Ground"),
"actif": true,
"code_variable": shipheart_capteur_angle_degres,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 0,
"precision_affichage_mesures": 0
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_siv + "",
"texte": qsTr("GNSS - SIV<br />Satellites In View"),
"actif": true,
"code_variable": shipheart_capteur_sans_unite,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique, // Choix fait après mure réflexion : inutile d'aller chercher de la précision sur ce paramètre alors que ce qui interresse est une tendance...
"precision_affichage_accueil": 0,
"precision_affichage_mesures": 0
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_hpa + "",
"texte": qsTr("GNSS - HPA<br />Horizontal Precision Accuracy"),
"actif": true,
"code_variable": shipheart_capteur_distance_m,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 1
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_vpa + "",
"texte": qsTr("GNSS - VPA<br />Vertical Precision Accuracy"),
"actif": true,
"code_variable": shipheart_capteur_distance_m,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 1
});
if (shipheart_generation_shipbase === shipheart_generation_shipbase_v1)
{
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_rssi + "",
"texte": qsTr("Modem 4G/LTE - RSSI<br />Received Signal Strength Indicator"),
"actif": true,
"code_variable": shipheart_capteur_puissance_db,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 0,
"precision_affichage_mesures": 0
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_sinr + "",
"texte": qsTr("Modem 4G/LTE - SINR<br />Signal to Interference & Noise Ratio"),
"actif": true,
"code_variable": shipheart_capteur_pourcentage,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 0,
"precision_affichage_mesures": 0
});
}
break;
//--------------------------------------
case shipheart_type_module_shippower812:
case shipheart_type_module_shippower8DC:
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_temp + "",
"texte": qsTr("Température module"),
"actif": true,
"code_variable": shipheart_capteur_temperature,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_in_v + "",
"texte": qsTr("Tension d'entrée module"),
"actif": true,
"code_variable": shipheart_capteur_tension_v,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
break;
//--------------------------------------
case shipheart_type_module_shipBS:
case shipheart_type_module_shippower4AC:
champ_formulaire_Entrees.model.append({
"entrees": shipheart_capteur_predefini_temp + "",
"texte": qsTr("Température module"),
"actif": true,
"code_variable": shipheart_capteur_temperature,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_periodique,
"precision_affichage_accueil": 1,
"precision_affichage_mesures": 2
});
break;
//--------------------------------------
default:
break;
}
// Mise à jour de l'index du mdoèle si l'on est sur l'entrée en cours :
for(i = 0; i < champ_formulaire_Entrees.model.count; i ++)
{
if (entrees === champ_formulaire_Entrees.model.get(i).entrees)
{
champ_formulaire_Entrees.currentIndex = i;
break; // Inutile de poursuivre une fois qu'on a trouvé l'entrée en cours
}
}
// Mise à jour en fonction des entrées déjà utilisées par ailleurs (capteurs) :
req = '(SELECT ' + shipheart_source_mesure_capteur + ' AS Type, Nom, Entrees ';
req += ' FROM TB_Capteurs WHERE ';
req += ' Adresse_module=' + adresse_module + ' ';
req += ' AND Type_entrees=' + shipheart_capteur_type_entrees_predefinie + ') ';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
for(j = 0; j < champ_formulaire_Entrees.model.count; j ++)
{
if (res[2] === champ_formulaire_Entrees.model.get(j).entrees)
{
if (res[2] === entrees) // Si on est sur l'entrée en cours, on laisse 'actif' à TRUE (et on peut ajuster le texte au passage...)
{
// champ_formulaire_Entrees.model.set(j, {"texte": "# "+ j} )
}
else // Si on n'est pas sur l'entrée en cours, on positionne 'actif' à FALSE (et on ajuste le texte pou rinformation)
{
champ_formulaire_Entrees.model.set(j, {"texte": champ_formulaire_Entrees.model.get(j).texte + "<br />" + Fonctions.nom_type_equipement(Number(res[0])) + " \"" + res[1] + "\"", "actif": false} )
}
}
}
}
}
// Mise à jour du flag d'utilisation du paramètre Mode_entrées :
flag_affichage_mode_entrees = false;
break;
//----------------------------------------
// Entrée Booléenne calculée :
//----------------------------------------
case shipheart_capteur_type_entrees_calculee_booleen:
// Même si l'entrée du modèle n'est jamais affichée pour ce type de capteur, l'ajout
// de cette entrée et sa sélection permet de "porter" les renseignements tels que 'code_variable'
// ou les 'pecision_affichage_xxx'.
if (id_capteur === 0) entrees = "1/1/0:0/0/0/0;1/-1/0:0/0/0/0"; // Valeur par défaut d'ouverture et fermeture de niveau 0. NB : une chaine nulle fonctionne également mais comme cell-ci sera inévitablement créée, autant le faire directement
champ_formulaire_Entrees.model.append({
"entrees": entrees,
"texte": "Entrée calculée", // Texte jamais affiché...
"actif": true,
"code_variable": shipheart_capteur_sans_unite,
"mode_enregistrement_mesures": shipheart_mode_enregistrement_mesures_changement_etat,
"precision_affichage_accueil": 0,
"precision_affichage_mesures": 0
});
// Mise à jour de l'index du modèle si l'on est sur l'entrée en cours :
champ_formulaire_Entrees.currentIndex = 1; // Le '1' sur CurrenIndex car on a déjà ajouté une entrée NON DEFINIE
// Mise à jour du flag d'utilisation du paramètre Mode_entrées :
flag_affichage_mode_entrees = false;
break;
//----------------------------------------
// Entrée numérique calculée :
//----------------------------------------
case shipheart_capteur_type_entrees_calculee_numerique:
break;
}
//---------------------------------------------------------------------------------------
// Appel du remplissage des modèles de niveau inférieur si cela est possible :
if ( (entrees !== "")
|| (type_entrees >= shipheart_capteur_type_entrees_calculee_booleen)) // Si on est sur un capteur calculé, on avance quand même car le champ Entrees ne sera de toutes façons pas utile.
{
if (flag_affichage_mode_entrees) mise_a_jour_mode_entrees(); // Cas "normal" où le Mode_entree doit être traité
else mise_a_jour_famille(); // Si pas de Mode_entree, on passe directement à la Famille.
}
}
//=============================================================================================================
// MAJ du Mode des entrées
//=============================================================================================================
function mise_a_jour_mode_entrees()
{
var req, res;
var nb;
var i, j;
//---------------------------------------------------------------------------------------
// Mode :
//---------------------------------------------------------------------------------------
champ_formulaire_Mode_entrees.model.clear();
if (type_entrees !== shipheart_capteur_type_entrees_aux) // Pour les entrées AUX, on n'a pas accès à la valeur NON DEFINIE car NORMAL=0 (et pas utile !!)
{
champ_formulaire_Mode_entrees.model.append({"valeur": 0, "texte": qsTr("Non défini") });
}
switch(type_entrees)
{
//----------------------------------------
// Entrées AUX :
//----------------------------------------
case shipheart_capteur_type_entrees_aux:
champ_formulaire_Mode_entrees.model.append({"valeur": shipheart_capteur_mode_entrees_aux_normal, "texte": qsTr("Normal") });
champ_formulaire_Mode_entrees.model.append({"valeur": shipheart_capteur_mode_entrees_aux_inverse, "texte": qsTr("Inversé") });
break;
//----------------------------------------
// Entrées Level Sensor :
//----------------------------------------
case shipheart_capteur_type_entrees_level_sensor:
champ_formulaire_Mode_entrees.model.append({"valeur": shipheart_capteur_mode_entrees_level_sensor_0_10v, "texte": qsTr("Tension 0 - 10 V") });
champ_formulaire_Mode_entrees.model.append({"valeur": shipheart_capteur_mode_entrees_level_sensor_500r, "texte": qsTr("Résistance 0 - 500 Ohms") });
champ_formulaire_Mode_entrees.model.append({"valeur": shipheart_capteur_mode_entrees_level_sensor_4_20ma, "texte": qsTr("Courant 4 - 20 mA") });
// champ_formulaire_Mode_entrees.model.append({"valeur": shipheart_capteur_mode_entrees_level_sensor_defaut_isolement_masse, "texte": qsTr("Défaut d'isolement 0V") });
// champ_formulaire_Mode_entrees.model.append({"valeur": shipheart_capteur_mode_entrees_level_sensor_defaut_isolement_v_plus, "texte": qsTr("Défaut d'isolement V+") });
champ_formulaire_Mode_entrees.model.append({"valeur": shipheart_capteur_mode_entrees_level_sensor_defaut_isolement_complet, "texte": qsTr("Défaut d'isolement") });
break;
//----------------------------------------
// Entrées Voltage Input :
//----------------------------------------
case shipheart_capteur_type_entrees_volt:
break;
//----------------------------------------
// Entrées OW :
//----------------------------------------
case shipheart_capteur_type_entrees_ow:
break;
//----------------------------------------
// Entrées NMEA2000 :
//----------------------------------------
case shipheart_capteur_type_entrees_nmea:
break;
//----------------------------------------
// Entrées Prédéfinies :
//----------------------------------------
case shipheart_capteur_type_entrees_predefinie:
break;
//----------------------------------------
// Entrée Booléenne calculée :
//----------------------------------------
case shipheart_capteur_type_entrees_calculee_booleen:
break;
//----------------------------------------
// Entrée numérique calculée :
//----------------------------------------
case shipheart_capteur_type_entrees_calculee_numerique:
break;
}
//---------------------------------------------------------------------------------------
// Recherche de l'index du capteur en cours :
champ_formulaire_Mode_entrees.currentIndex = 0; // Si aucune entrée n'est trouvée (cas d'une création par exemple), l'index est égal à 0
for (i=0; i<champ_formulaire_Mode_entrees.model.count; i ++)
{
if (champ_formulaire_Mode_entrees.model.get(i).valeur === Number(mode_entrees))
{
champ_formulaire_Mode_entrees.model.set(i, {"actif": true} )
champ_formulaire_Mode_entrees.currentIndex = i;
break; // Une fois trouvé lindex en cours, inutile de poursuivre
}
}
// Appel du remplissage des modèles de niveau inférieur si cela est possible :
mise_a_jour_famille();
}
//=============================================================================================================
// MAJ de la Famille
//=============================================================================================================
function mise_a_jour_famille()
{
var req, res;
var nb;
var i;
//---------------------------------------------------------------------------------------
// Famille :
//---------------------------------------------------------------------------------------
champ_formulaire_Famille.model.clear();
champ_formulaire_Famille.model.append({"valeur": 0, "texte": "Non défini" });
req = 'SELECT Cle_primaire, Nom FROM TB_Familles WHERE Type_source=' + shipheart_type_source_capteurs + ' ORDER BY Priorite_affichage ';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
champ_formulaire_Famille.model.append({"valeur": Number(res[0]), "texte": res[1] });
}
}
// Positionnement de l'index sur la valeur en cours :
i = recherche_index_valeur_modele(id_famille, champ_formulaire_Famille.model, "Famille");
if (i === -1) champ_formulaire_Famille.currentIndex = 0;
else champ_formulaire_Famille.currentIndex = i;
if ( (champ_formulaire_Famille.currentIndex !== 0) &&
((type_entrees === shipheart_capteur_type_entrees_aux) || (type_entrees === shipheart_capteur_type_entrees_calculee_booleen)) )
{
mise_a_jour_libelles();
}
}
//=============================================================================================================
// MAJ des unités du capteur
//=============================================================================================================
function mise_a_jour_unite()
{
var code_variable = "";
var precision_affichage_accueil;
var precision_affichage_mesures;
switch(type_entrees)
{
//----------------------------------------
// Entrées AUX :
//----------------------------------------
case shipheart_capteur_type_entrees_aux:
break;
//----------------------------------------
// Entrées Level Sensor :
//----------------------------------------
case shipheart_capteur_type_entrees_level_sensor:
switch (mode_entrees)
{
//------------------------------------------------------
case shipheart_capteur_mode_entrees_level_sensor_0_10v:
code_variable = shipheart_capteur_tension_v;
precision_affichage_accueil = 1;
precision_affichage_mesures = 2;
break;
//------------------------------------------------------
case shipheart_capteur_mode_entrees_level_sensor_500r:
code_variable = shipheart_capteur_resistance;
precision_affichage_accueil = 0;
precision_affichage_mesures = 0;
break;
//------------------------------------------------------
case shipheart_capteur_mode_entrees_level_sensor_4_20ma:
code_variable = shipheart_capteur_courant_ma;
precision_affichage_accueil = 1;
precision_affichage_mesures = 1;
break;
//------------------------------------------------------
case shipheart_capteur_mode_entrees_level_sensor_defaut_isolement_masse:
case shipheart_capteur_mode_entrees_level_sensor_defaut_isolement_v_plus:
case shipheart_capteur_mode_entrees_level_sensor_defaut_isolement_complet:
code_variable = shipheart_capteur_courant_ma;
precision_affichage_accueil = 1;
precision_affichage_mesures = 1;
break;
//------------------------------------------------------
default: // Ne devrait pas arriver...
code_variable = shipheart_capteur_tension_v;
precision_affichage_accueil = 1;
precision_affichage_mesures = 2;
break;
}
break;
//----------------------------------------
// Entrées Voltage Input :
//----------------------------------------
case shipheart_capteur_type_entrees_volt:
break;
//----------------------------------------
// Entrées OW :
//----------------------------------------
case shipheart_capteur_type_entrees_ow:
break;
//----------------------------------------
// Entrées NMEA2000 :
//----------------------------------------
case shipheart_capteur_type_entrees_nmea:
break;
//----------------------------------------
// Entrées Prédéfinies :
//----------------------------------------
case shipheart_capteur_type_entrees_predefinie:
break;
//----------------------------------------
// Entrée Booléenne calculée :
//----------------------------------------
case shipheart_capteur_type_entrees_calculee_booleen:
break;
//----------------------------------------
// Entrée numérique calculée :
//----------------------------------------
case shipheart_capteur_type_entrees_calculee_numerique:
break;
}
if (code_variable !== "") // Pour les type de capteurs qui ont déjà leurs unités de renseignées, on ne touche à rien...
{
champ_formulaire_Entrees.model.set(champ_formulaire_Entrees.currentIndex, {
"code_variable": code_variable,
"precision_affichage_accueil": precision_affichage_accueil,
"precision_affichage_mesures": precision_affichage_mesures
});
}
}
//=============================================================================================================
// MAJ des libelles
//=============================================================================================================
function mise_a_jour_libelles()
{
var i;
switch(type_entrees)
{
case shipheart_capteur_type_entrees_aux:
nb_libelles = Math.pow(2, nb_entrees);
break;
case shipheart_capteur_type_entrees_calculee_booleen:
nb_libelles = 2;
break;
default:
return;
}
liste_libelles.model.clear();
for (i=0; i<nb_libelles; i++)
{
liste_libelles.model.append({ "valeur": i,
"libelle": "" }); // Par défaut, le placeholder indique que ce sera la valeur qui sera affiché.
}
// Recherche des Valeurs/textes existants :
var chaines_valeurs_textes = liste_valeurs_textes.split(';');
for (let chaine_valeur_texte of chaines_valeurs_textes)
{
var chaine = chaine_valeur_texte.split('/');
if (chaine.length === 2) // Evite de traiter les cas invalides (notamment, une chaine totalement vide qui arrive ici avec un length de 1...)
{
liste_libelles.model.set(Number(chaine [0]), {"libelle": chaine[1]});
}
}
}
//=============================================================================================================
// Mise à jour des valeurs saisies du capteur
//=============================================================================================================
function mise_a_jour_capteur()
{
var req, res;
var i, j;
var nb;
var nom;
var code_variable, id_variable;
var id_famille;
var mode_enregistrement_mesures;
var precision_affichage_accueil;
var precision_affichage_mesures;
nom = champ_formulaire_Nom.text;
if (flag_affichage_mode_entrees) mode_entrees = champ_formulaire_Mode_entrees.model.get(champ_formulaire_Mode_entrees.currentIndex).valeur;
else mode_entrees = 0;
id_famille = champ_formulaire_Famille.model.get(champ_formulaire_Famille.currentIndex).valeur;
if (type_entrees === shipheart_capteur_type_entrees_aux)
{
code_variable = shipheart_capteur_sans_unite;
mode_enregistrement_mesures = shipheart_mode_enregistrement_mesures_changement_etat;
precision_affichage_accueil = 0;
precision_affichage_mesures = 0;
}
else
{
code_variable = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).code_variable;
mode_enregistrement_mesures = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).mode_enregistrement_mesures;
precision_affichage_accueil = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).precision_affichage_accueil;
precision_affichage_mesures = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).precision_affichage_mesures;
}
// Traitement de la chaine 'Entrées' :
if (type_entrees === shipheart_capteur_type_entrees_aux)
{
// Création de la chaine représentant les n° d'entrées utilisées par le réservoir :
entrees = "";
for (i = 0; i < shipheart_capteur_max_nombre_entrees_aux; i ++)
{
j = entrees_aux_grid.model.get(i).no_entree_aux
if (j !== 0)
{
if (entrees !== "") entrees += ";";
entrees += j;
}
}
}
else entrees = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).entrees;
// Recherche de l'ID_Variable correspondant au code_variable :
req = ' SELECT Cle_primaire FROM TB_Variables WHERE Code="' + code_variable + '" ';
//console.log("Requête = [ " + req + "; ]");
res = bdd.requete_unique(req);
id_variable = Number(res[0]);
// Traitement des Liste_valeurs_textes pour le type ENTREES AUX et CALCULE_BOOLEEN :
liste_valeurs_textes = "";
if ((type_entrees === shipheart_capteur_type_entrees_aux) || (type_entrees === shipheart_capteur_type_entrees_calculee_booleen))
{
for (i=0; i<liste_libelles.model.count; i ++)
{
if (liste_libelles.model.get(i).libelle !== "")
{
if (liste_valeurs_textes !== "") liste_valeurs_textes += ";";
liste_valeurs_textes += liste_libelles.model.get(i).valeur + "/" + liste_libelles.model.get(i).libelle;
}
}
}
// Traitement de la case à cocher 'masquage' :
var paa;
if (champ_formulaire_Masquage.checked) // Demande de masquage :
{
if (priorite_affichage_accueil <= 0) paa = priorite_affichage_accueil; // S'il était masqué, on garde la même valeur.
else paa = - priorite_affichage_accueil; // S'il était démasque (donc > 0), on prend son opposé (comme ça, on est bien <0 mais on garde en plus la position initiale en mémoire)
}
else // Demande de ne pas le masquer :
{
if (priorite_affichage_accueil > 0) paa = priorite_affichage_accueil; // S'il était démasqué, on garde la même valeur
else if (priorite_affichage_accueil < 0) paa = - priorite_affichage_accueil; // S'il était masqué, avec une valeur mémorisée non nulle, on récupère la valur mémorisée (l'opposé donc)
else paa = 999; // S'il était masqué mais sans valeur mémorisée (donc nulle), on attribue arbitrairement une valeur très élevée pour mettre le circuit affiché mais en dernière position.
}
// Requete de mise à jour :
req = 'UPDATE TB_Capteurs SET Nom="' + nom + '" ';
req += ', Adresse_module=' + adresse_module + ' ';
req += ', Type_entrees=' + type_entrees + ' ';
req += ', Entrees="' + entrees + '"';
req += ', Mode_entrees=' + mode_entrees + ' ';
req += ', ID_Variable=' + id_variable + ' ';
req += ', Liste_valeurs_textes="' + liste_valeurs_textes + '" ';
req += ', ID_Famille=' + id_famille + ' ';
req += ', Mode_enregistrement_mesures=' + mode_enregistrement_mesures + ' ';
req += ', Priorite_affichage_accueil=' + paa + ' ';
req += ', Precision_affichage_accueil=' + precision_affichage_accueil + ' ';
req += ', Precision_affichage_mesures=' + precision_affichage_mesures + ' ';
req += ' WHERE Cle_primaire=' + id_capteur + ' '
//console.log("Requête = [ " + req + "; ]");
bdd.requete_unique(req);
// Cas particulier d'un capteur sur entrée NMEA :
if (type_entrees === shipheart_capteur_type_entrees_nmea) flag_nmea = true;
if (flag_nmea) mise_a_jour_nmea2000();
// Demande de reconfiguration système via la BDD car on a modifié des valeurs de configuration :
synchro_bdd(shipheart_type_synchro_config);
}
//=============================================================================================================
// Création du capteur
//=============================================================================================================
function creation_capteur()
{
var req, res;
var nom;
var i, j;
var nb;
var code_variable, id_variable;
var id_famille;
var precision_affichage_accueil;
var precision_affichage_mesures;
var mode_enregistrement_mesures;
nom = champ_formulaire_Nom.text;
if (flag_affichage_mode_entrees) mode_entrees = champ_formulaire_Mode_entrees.model.get(champ_formulaire_Mode_entrees.currentIndex).valeur;
else mode_entrees = 0;
id_famille = champ_formulaire_Famille.model.get(champ_formulaire_Famille.currentIndex).valeur;
if (type_entrees === shipheart_capteur_type_entrees_aux)
{
code_variable = shipheart_capteur_sans_unite;
mode_enregistrement_mesures = shipheart_mode_enregistrement_mesures_changement_etat;
precision_affichage_accueil = 0;
precision_affichage_mesures = 0;
}
else
{
code_variable = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).code_variable;
mode_enregistrement_mesures = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).mode_enregistrement_mesures;
precision_affichage_accueil = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).precision_affichage_accueil;
precision_affichage_mesures = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).precision_affichage_mesures;
}
// Traitement de la chaine 'Entrées' :
if (type_entrees === shipheart_capteur_type_entrees_aux)
{
// Création de la chaine représentant les n° d'entrées utilisées par le réservoir :
entrees = "";
for (i = 0; i < shipheart_capteur_max_nombre_entrees_aux; i ++)
{
j = entrees_aux_grid.model.get(i).no_entree_aux
if (j !== 0)
{
if (entrees !== "") entrees += ";";
entrees += j;
}
}
}
else entrees = champ_formulaire_Entrees.model.get(champ_formulaire_Entrees.currentIndex).entrees;
// Recherche de l'ID_Variable correspondant au code_variable :
req = ' SELECT Cle_primaire FROM TB_Variables WHERE Code="' + code_variable + '" ';
//console.log("Requête = [ " + req + "; ]");
res = bdd.requete_unique(req);
id_variable = Number(res[0]);
// Traitement des Liste_valeurs_textes pour le type ENTREES AUX et CALCULE_BOOLEEN :
liste_valeurs_textes = "";
if ((type_entrees === shipheart_capteur_type_entrees_aux) || (type_entrees === shipheart_capteur_type_entrees_calculee_booleen))
{
for (i=0; i<liste_libelles.model.count; i ++)
{
if (liste_libelles.model.get(i).libelle !== "")
{
if (liste_valeurs_textes !== "") liste_valeurs_textes += ";";
liste_valeurs_textes += liste_libelles.model.get(i).valeur + "/" + liste_libelles.model.get(i).libelle;
}
}
}
// Traitement du champ Priorite_affichage_accueil :
if (champ_formulaire_Masquage.checked) priorite_affichage_accueil = 0;
else priorite_affichage_accueil = 999;
// Requete de création :
req = 'INSERT INTO TB_Capteurs (Nom, ';
req += ' Adresse_module, ';
req += ' Type_entrees, ';
req += ' Entrees, ';
req += ' Mode_entrees, ';
req += ' ID_Variable, ';
req += ' Liste_valeurs_textes, ';
req += ' ID_Famille, ';
req += ' Mode_enregistrement_mesures, ';
req += ' Precision_affichage_accueil, ';
req += ' Precision_affichage_mesures, ';
req += ' Priorite_affichage_accueil) '
req += ' VALUES ("' + nom + '"';
req += ', ' + adresse_module;
req += ', ' + type_entrees;
req += ', "' + entrees + '"';
req += ', ' + mode_entrees + ' ';
req += ', ' + id_variable + ' ';
req += ', "' + liste_valeurs_textes + '"';
req += ', ' + id_famille
req += ', ' + mode_enregistrement_mesures;
req += ', ' + precision_affichage_accueil;
req += ', ' + precision_affichage_mesures;
req += ', ' + priorite_affichage_accueil;
req += ') ';
//console.log("Requête = [ " + req + "; ]");
bdd.requete_unique(req);
// Recherche de l'ID_Capteur correspondant au capteur créé :
req = ' SELECT Cle_primaire FROM TB_Capteurs ORDER BY Cle_primaire DESC LIMIT 1 ';
//console.log("Requête = [ " + req + "; ]");
res = bdd.requete_unique(req);
id_capteur = Number(res[0]);
// Cas particulier d'un capteur sur entrée NMEA :
if (type_entrees === shipheart_capteur_type_entrees_nmea) flag_nmea = true;
if (flag_nmea) mise_a_jour_nmea2000();
// Demande de reconfiguration système via la BDD car on a modifié des valeurs de configuration :
synchro_bdd(shipheart_type_synchro_config);
}
//=============================================================================================================
// Check suppression du capteur
//=============================================================================================================
function check_avant_suppression()
{
var req, res;
var nb;
var i;
var message = "";
//=========================================================================
// Recherche de l'impact de cette suppression sur les spécifiques clients :
switch(Number(shipheart_specifique_client[0]))
{
//------------------------------------------------------
default:
case shipheart_specifique_client_tous:
//console.log("Tous les clients")
break;
//------------------------------------------------------
case shipheart_specifique_client_suncy:
//console.log("Client Suncy")
break;
}
//=========================================================================
// Recherche de l'impact de cette suppression sur les évènements :
req = 'SELECT Cle_primaire, Nom FROM TB_Events WHERE Type_source=' + shipheart_source_mesure_capteur + ' AND ID_Source=' + id_capteur + ' ';
req += ' ORDER BY Nom';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
if (nb > 0)
{
if (nb === 1) message += "<br /><br />" + qsTr("Ce capteur est utilisé par l'évènement ci-dessous.<br />Vous devez modifier ou supprimer cet évènement pour qu'il ne dépende plus de ce capteur avant de pouvoir le supprimer.") + "<br /><br />";
else message += "<br /><br />" + qsTr("Ce capteur est utilisé par les %1 évènements ci-dessous.<br />Vous devez modifier ou supprimer ces évènements pour qu'ils ne dépendent plus de ce capteur avant de pouvoir le supprimer.").arg(nb) + "<br /><br />";
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
message += "&#8227; " + (i+1) + " : " + res[1] + "<br />";
}
}
}
//=========================================================================
// Recherche de l'impact de cette suppression sur les capteurs calculés :
/* Retour de la forme :
+-------------+
| Nom_capteur |
+-------------+
| Calculation |
| Calcul 2 |
+-------------+ */
req = 'SELECT Nom FROM TB_Capteurs ';
req += ' WHERE Type_entrees=' + shipheart_capteur_type_entrees_calculee_booleen + ' ';
req += ' AND Entrees LIKE "%/' + shipheart_source_mesure_capteur + ':' + id_capteur + '/%" ';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
if (nb > 0)
{
if (nb === 1) message += "<br /><br />" + qsTr("Ce capteur est utilisé par le capteur calculé ci-dessous.<br />Vous devez modifier ou supprimer ce capteur calculé pour qu'il ne dépende plus de ce capteur avant de pouvoir le supprimer.") + "<br /><br />";
else message += "<br /><br />" + qsTr("Ce capteur est utilisé par les %1 capteurs calculés ci-dessous.<br />Vous devez modifier ou supprimer ces capteurs calculés pour qu'ils ne dépendent plus de ce capteur avant de pouvoir le supprimer.").arg(nb) + "<br /><br />";
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
message += "&#8227; " + (i+1) + " : " + res[0] + "<br />";
}
}
}
//=========================================================================
// Conclusion :
if (message === "") return(0); // Aucune réserve à supprimer le message....
else // Affichage de la boite de dialogue. La suppression n'est pas autorisée...
{
boite_information.niveau = 2;
boite_information.imageTitreSource = "/images/attention.png"
boite_information.message = message;
boite_information.alignementMessage = Text.AlignLeft
boite_information.open();
return(-1);
}
}
//=============================================================================================================
// Suppression du capteur
//=============================================================================================================
function suppression_capteur()
{
var req, res;
var nb;
var i;
var liste_cdes_auto, chaines_cdes_auto;
var type_entrees;
var entrees;
// Recherche des informations actuelles du capteur :
req = 'SELECT Type_entrees, Entrees FROM TB_Capteurs WHERE Cle_primaire=' + id_capteur + ' ';
res = bdd.requete_unique(req);
type_entrees = Number(res[0]);
entrees = res[1]; // A ce stade, c'est une chaine. On ne fera la conversion en Number que lorsqu'on aura vérifié que 'Type_entrées' est de type OW.
// Pour les capteurs utilisant les sondes OW, RAZ du nom de la sonde :
if (type_entrees === shipheart_capteur_type_entrees_ow)
{
req = 'UPDATE TB_One_wire SET Nom="---" WHERE Cle_primaire=' + Number(entrees) + ' ';
bdd.requete_unique(req);
}
// Pour les capteurs utilisant les Entrees_aux :
// Il n'est pas utile de mettre à jour TB_Entrees_aux en fonction des changements effectués. En effet, on va juste après demander une "synchro" à l'appli et celle-ci
// va réinitialiser puis va le re-remplir en fonction de l'état des Capteurs et des Réservoirs. Donc si des Entrées AUX ne sont plus plus utilisées ou ont changé, elles
// seront mises à jour à ce moment-là.
// Suppression du capteur :
req = 'DELETE FROM TB_Capteurs WHERE Cle_primaire=' + id_capteur + ' ';
bdd.requete_unique(req);
// Cas particulier d'un capteur sur entrée NMEA :
if (type_entrees === shipheart_capteur_type_entrees_nmea) flag_nmea = true;
if (flag_nmea) mise_a_jour_nmea2000();
// Demande de reconfiguration système via la BDD car on a modifié des valeurs de configuration :
synchro_bdd(shipheart_type_synchro_config);
}
//=============================================================================================================
// Mise à jour de la table NMEA2000 après modifications de capteur
//=============================================================================================================
function mise_a_jour_nmea2000()
{
var req, res;
var i;
var nb;
// RAZ de tous les flags Actifs (valeur par défaut plus rapide ; sans danger puisqu'on n'a pas demandé la mise à jour NMEA) :
req = 'UPDATE TB_Nmea2000 SET Actif=0 ';
bdd.requete_unique(req);
// Mise à 1 des PGN/Fields qui sont effectivement utilisés sur des capteurs :
req = 'SELECT Entrees FROM TB_Capteurs WHERE Type_entrees=' + shipheart_capteur_type_entrees_nmea + ' ';
//console.log("Requête = [ " + req + "; ]");
nb = bdd.requete(req);
for (i = 0; i < nb; i ++)
{
res = bdd.lecture_ligne();
if (!res.isEmpty)
{
var x = res[0].split(':');
req = 'UPDATE TB_Nmea2000 SET Actif=1 WHERE Pgn=' + x[0] + ' AND Field=' + x[1] + ' ';
//console.log("Requête = [ " + req + "; ]");
bdd.requete_unique(req);
}
}
// Demande de MAJ des paramètres NMEa par l'Appli :
req = 'UPDATE TB_Systeme SET Valeur=1 WHERE Nom="Demande_maj_nmea" ';
bdd.requete_unique(req);
}
//=============================================================================================================
// Recherche groupe d'une entrée AUX à partir de son numéro et renvoit le n° de grpupe (entre 0 et 7)
//=============================================================================================================
function recherche_groupe_entree_aux(entree)
{
switch(Math.trunc(entree/4))
{
case 0: return(4);
case 1: return(5);
case 2: return(6);
case 3: return(7);
case 4: return(0);
case 5: return(1);
case 6: return(2);
case 7: return(3);
default:
console.log("Erreur de groupe d'entrée AUX")
return(-1);
}
}
//=============================================================================================================
// Recherche de l'index d'une certaine valeur dans un modele
//=============================================================================================================
function recherche_index_valeur_modele(cible, modele, nom_modele)
{
var i;
for (i=0; i<modele.count; i ++)
{
if (modele.get(i).valeur === cible) break; // Cas où la valeur cible a été trouvée parmi les valeurs du modèle
}
if (i === modele.count)
{
console.log("Aucune valeur trouvée pour cible = [" + cible + "] du modèle = " + nom_modele);
i = -1; // Cas où la valeur n'a pas été trouvée parmi les valeurs du modèle
}
//else console.log("Valeur trouvée : [" + i + "] pour cible = [" + cible + "] soit texte = [" + modele.get(i).texte + "]");
return(i);
}
}
Reference in New Issue View Git Blame Copy Permalink