#!/usr/bin/env python
# coding: utf-8

# ## Logique de la chaine d'information :

# ### Mise en situation :
# 
# Nous allons découvrir la logique fondamentale qui permet de **traiter** l'information d'un système dont nous décrirons le comportement en utilisant différents moyens. 
# 
# <img src="https://ericecmorlaix.github.io/img/AnalyseSystemique-GlobaleInformation.svg" alt="Focus sur la fonction traiter de la chaine d'information">
# 
# > *Pour illustrer notre propos, nous étudierons, dans un premier temps, le cas d'un simple **système par [Va et Vient](https://fr.wikipedia.org/wiki/Montage_va-et-vient)** qui permet de commander l’éclairage d’une pièce depuis deux endroits différents ?*
# >
# > *cf document pdf associé* : [Description de la Logique d'un Va Et Vient](https://ericecmorlaix.github.io/1SI_2024-2025/CI/Logique_va_et_vient.pdf)

# ### Définition :
# 
# Une fonction logique est une relation établie entre une variable logique de sortie et une ou plusieurs variables logiques d’entrée.
# 
# <img src="https://ericecmorlaix.github.io/img/ChaineInformation-FonctionLogique.png" alt="Fonction logique traiter">
# 
# Ces variables d’entrée et de sortie sont dites logiques car elles ne peuvent prendre que deux valeurs (niveaux ou états) distinctes et non simultanées : 
# - soit **Vraies = $1$** ;
# - soit **Fausses = $0$**.
# 
# Ce sont des variables binaires, de type **booléennes**.
# 
# Car pour étudier ces fonctions de variables binaires, on utilise l’algèbre de [George BOOLE](https://fr.wikipedia.org/wiki/George_Boole) (mathématicien britannique du XIX siècle), qui a permis le développement des automatismes et de l’informatique...
#  
# 
# > *Dans notre exemple de **système d’éclairage par va et vient** :*
# >
# > *L’état allumé ou éteint d’une lampe (L) d’éclairage d’une pièce dépend de l’état d’un interrupteur (a) situé à un des accès de la pièce et de celui d’un interrupteur (b) situé à l’autre accès de la pièce.*
# >
# ><h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Compléter</strong> les entrées et sortie de la fonction traiter du va et vient :</h4>
# > 
# ><img src="https://ericecmorlaix.github.io/img/ChaineInformation-VaEtVient-Vide.svg" alt="Fonction logique traiter d'un Va et Vient">
# 

# ### Description d'une fonction logique
# 
# #### Proposition logique littérale :
# 
# Une fonction logique peut se décrire par une phrase établissant une relation de cause à effet (si...alors) entre les entrées et la sortie.
#  
# > *Pour notre exemple de **système d’éclairage par va et vient** :*
# >
# > *SI l’interrupteur a est NON actionné ET l’interrupteur b est actionné OU SI l’interrupteur a est actionné ET l’interrupteur b est NON actionné ALORS la lampe L est allumée.*

# #### Equation logique (Equation booléenne) :
# 
# Pour alléger l’écriture et rendre possible l’application de l’algèbre de Boole, on code la proposition logique sous la forme d’une équation.
# 
# Le ET se traduit par $\bullet$, le OU se traduit par $+$, le ALORS se traduit par $=$, le NON se traduit par une barre sur la $\overline{variable}$.
#  
# > *Pour notre exemple de **système d’éclairage par va et vient** :*
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Ecrire</strong> l'équation booléenne du va et vient :</h4>
# >
# > $L =$
# >
# 
# 
# 
# ##### Complément : [les propriétés de l’algèbre de Boole](https://fr.wikiversity.org/wiki/Logique_de_base/Alg%C3%A8bre_de_Boole)

# #### Table de vérité :
# 
# Pour décrire le résultat d’une fonction logique en fonction de l’état de ses entrées on dresse un tableau ordonné appelé table de vérité.
# 
# Elle permet de faire l’inventaire de toutes les combinaisons possibles. Le nombre de combinaisons est $2^n$ avec $n$ le nombre d’entrées
#  
# > *Pour notre exemple de **système d’éclairage par va et vient** :*
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Compléter</strong> la table de vérité du va et vient :</h4>
# >
# > <img src="https://ericecmorlaix.github.io/img/ChaineInformation-TableVeriteVide.svg" alt="Table de vérité">
# 

# ### Tableau d'inventaire des principales fonctions logiques :
# 
# <img src="https://ericecmorlaix.github.io/img/TableauFonctionLogique.png" alt="TableauFonctionLogique" width= 90%>
# 
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même :</h4>
# >
# >**Compléter** le tableau ci-dessus à partir d'une recherche web et en expérimentant par simulation le fonctionnement de chaque porte logique de base sur [Capytale n° 513c-4629553 ](https://capytale2.ac-paris.fr/web/c/513c-4629553) (ou sur [https://logic.ly/demo](https://logic.ly/demo))
# >
# > *cf document associé* : Tableau des Fonctions Logiques en [`.pdf`](https://ericecmorlaix.github.io/1SI_2024-2025/CI/Tableau_fonctions_logiques.pdf) ou en [`.drawio`](https://ericecmorlaix.github.io/1SI_2024-2025/CI/Tableau_fonctions_logiques.drawio)
# >
# <hr>
# 
# > <h4 class='fa fa-rocket' style="color: MediumSeaGreen"> Prolongement :</h4>
# >
# >**Programmer** puis **Expérimenter** le fonctionnement de chaque porte logique de base avec une carte [BBC micro:bit](https://ericecmorlaix.github.io/adn-Tutoriel_lab_si/IOT/BBC_microbit/)
# >
# >- **utiliser** les boutons-poussoir A et B pour faire les entrées et **afficher** en sortie sur la matrice à LEDs un <span class='fa fa-check'></span> pour vrai et un <span class='fa fa-close'></span> pour faux ;
# >- **conserver** une copie de vos programme MicroPython dans un notebook sur [Capytale n° 96d9-4637151 ](https://capytale2.ac-paris.fr/web/c/96d9-4637151).
# 
# 

# <hr>
# 
# > <h4 class='fa fa-graduation-cap' style="color: purple"> Exercice d'application - Google doodle</h4>
# >
# ><br>
# ><img  src="https://ericecmorlaix.github.io/img/doodle_George.gif" alt="doodle_George">
# ><br>
# >
# > - **Répondre** aux questions du [notebook Capytale n° 0e33-4601596](https://capytale2.ac-paris.fr/web/c/0e33-4601596) 
# 
# <hr>

# ### Description d'une fonction logique (Suite) :
# 
# #### Schéma à contacts :
# 
# Il s’agit de représenter la fonction logique sous la forme d’un schéma à contact de technologie électrique.
# 
# Un contact ouvert au repos (NO) représente une variable d’entrée dont l’état vrai (=1) est requis, un contact fermé au repos (NF) représente une variable d’entrée dont l’état faux (=0) est requis, et une charge (bobine ou lampe) représente la variable de sortie, la fonction ET est traduite en disposant les contacts en série, la fonction OU est traduite en disposant les contacts en parallèle.
#  
# > *Pour notre exemple de **système d’éclairage par va et vient** :*
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Tracer</strong> un schéma à contacts pour le  va et vient :</h4>
# >
# > <img  src="https://ericecmorlaix.github.io/img/ChaineInformation-ShemaContactVide.svg" alt="Schéma à Contacts">
# 

# #### Logigramme :
# 
# Une fonction logique peut également être représentée sous la forme d’un logigramme de technologie électronique (ou pneumatique).
# Une fonction logique peut se décomposer en fonctions de base (opérateurs logiques). Il existe deux représentations graphiques normalisées pour ces dernières, l'une est Européenne, l'autre est Américaine.
# Le logigramme est la représentation graphique d’une fonction logique en combinant les symboles des opérateurs logiques qui la composent.
#  
# > *Pour notre exemple de **système d’éclairage par va et vient** :*
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Compléter</strong> le logigramme du va et vient :</h4>
# > 
# > <img  src="https://ericecmorlaix.github.io/img/ChaineInformation-LogigrammeVide.svg" alt="Logigramme">
# >
# 

# #### Chronogramme :
# 
# Un chronogramme permet de décrire le fonctionnement d’un système au cours du temps. Une fonction logique peut donc être représentée par un chronogramme.
# 
# Il s’agit d’un graphe permettant de visualiser, en fonction du temps, l’état logique des sorties en fonction des états logiques pris par les entrées au cours du temps.
#  
# > *Pour notre exemple de **système d’éclairage par va et vient** :*
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Compléter</strong> le chronogramme du va et vient :</h4>
# >
# > <img  src="https://ericecmorlaix.github.io/img/ChaineInformation-ChronogrammeVide.svg" alt="Chronogramme">
# 

# #### Algorithme :
# 
# Un algorithme est un ensemble de règles opératoires rigoureuses ordonnant, à un processeur particulier,
# d'exécuter dans un ordre déterminé, un nombre fini d'opérations élémentaires pour remplir une fonction donnée.
# 
# Un algorithme s'implémente dans un programme informatique.
# 
# L'algorithme est un outil méthodologique général qui ne doit pas être confondu avec le programme proprement dit. 
# 
# Un algorithme peut être représenté :
# 
# - soit graphiquement à l'aide de l'algorigramme (organigramme ou ordinogramme) en respectant un formalisme de symboles et de structure ;
# - soit littéralement grâce au langage algorithmique en respectant un formalisme d'écriture (pseudo-code). 
# 
# 
# ##### Algorigramme :
# 
# C'est une représentation graphique de l'algorithme utilisant des symboles définis par des normes (NF Z 67-010 et ISO 5807)
# 
# <img  src="https://ericecmorlaix.github.io/img/AlgorigrammeNormes.png" alt="AlgorigrammeNormes" width=70%>
# 
# 
# > *Pour notre exemple de **système d’éclairage par va et vient** :*
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Compléter</strong> l'algorigramme de la fonction va et vient :</h4>
# > 
# > <img  src="https://ericecmorlaix.github.io/img/ChaineInformation-AlgorigrammeVide.svg" alt="AlgorigrammeVaEtVient">
# 
# 
# ##### Pseudo-Code :
# 
# Le pseudo-code est une façon de décrire un algorithme en langage presque naturel, sans référence à un langage de programmation en particulier.
# 
# > *Pour notre exemple de **système d’éclairage par va et vient** :*
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Compléter</strong> le pseudo-code de la fonction va et vient :</h4>
# > 
# > ````pseudo-code
# > TANT QUE Vrai
# >     FAIRE   
# >     LIRE a
# >     LIRE b
# >     SI ....................... = Vrai
# >     ALORS
# >        FAIRE
# >        L <- ....
# >     SINON
# >        FAIRE
# >        L <- ....
# >     FIN SI
# >     ECRIRE L
# >  FIN TANT QUE
# > ````
# 
# 
# #### Implémentation en Python :
# 
# 
# 
# En Python, une variable booléeene est soit `True` soit `False` et les opérateurs booléens sont les mots clés :
# -  `and` pour le ET
# -  `or` pour le OU
# -  `not` pour le NON
# 
# > *Pour notre exemple de **système d’éclairage par va et vient** :*
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Compléter</strong> l'implémentation en Python de la fonction va et vient :</h4>
# 

# In[ ]:


while True:
    a = bool(int(input("Saisir 0 ou 1 pour a : ")))
    b = bool(int(input("Saisir 0 ou 1 pour b : ")))
    if ............................. == True:
        L = 1
    else:
        L = 0
    print("La lampe est à l'état : ", L)


# > Le module ``IPython.display`` permet d'afficher un code MarkDown dans un notebook jupyter :
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Compléter</strong> l'expression booléenne de la fonction va_et_vient(a,b) dans ce nouveau script Python :</h4>
# >

# In[ ]:


# Script générant la table de vérité d'un va et vient affichée par Python en Markdown dans un notebook jupyter :
from IPython.display import Markdown

table ='''|  a  |  b  |  L |
|:---:|:---:|:---:|\n'''

for a in [False,True]:
    for b in [False,True]:
        # Expression booléenne de la fonction en python à compléter
        L = ...
        table += f"|  {a}  |  {b}  |  {L}  |\n"
        
Markdown(table)


# > Le module ``ipywidgets`` permet d'afficher une interface graphique interactive dans un carnet jupyter (mais pas dans Basthon) :
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Compléter</strong> l'expression booléenne de la fonction va_et_vient(a,b) dans ce nouveau script Python :</h4>
# >

# In[ ]:


# Il faut importer la fonction interact() du module ipywidgets
from ipywidgets import interact

# Définition de la fonction logique à simuler
def va_et_vient(a,b):
    # Expression booléenne de la fonction en python
    L = ...........................
    # Résultat interactif à afficher
    return (print(f"Si a = {a} et b = {b} alors la lampe L = {L}"))

# Appel de la fonction interact() qui appelle la fonction logique à simuler
interact(va_et_vient, a = False, b = False)


# > Ce script peut être adapté pour toute autre fonction logique. Essayez...

# #### SYSML, Diagramme d'Etats-Transitions (stm, State Machine Diagramme) :
# 
# Le diagramme d’états est un outil de la modélisation graphique SYSML qui permet de décrire le comportement dynamique séquentiel d’un système ou d'un sous-système. On parle alors d’une machine à états.
# 
# Le diagramme d'état décrit les transitions entre les états et les actions que le système ou ses parties réalisent en réponse à un événement.
# 
# Un état représente une période du fonctionnement du système pendant laquelle le système satisfait une certaine condition, accomplit une ou plusieurs actions, ou attend un évènement.
# 
# A un moment donné, un état est actif ou inactif. Plusieurs états peuvent être actifs simultanément.
# 
# Les états sont représentés par des rectangles aux coins arrondis.
# 
# On nomme transition le lien qui relie deux états successifs.
# 
# Depuis un état actif, pour activer un état lié, il faut que la condition de transition soit vérifée.
# 
# <img  src="https://ericecmorlaix.github.io/img/ChaineInformation-EtatsTransitions.svg" alt="DiagrammeEtatsTransitions">
# 
# 
# **Actions dans un état** : Pour définir les actions à exécuter il existe trois modes :
# - Actions à l’activation de l’état : la syntaxe est ``entry: action1, action2 ;``
# - Action durant l’état : la syntaxe est ``during: action1, action2 ;``
# - Action à la désactivation de l’état : la syntaxe est ``exit: action1, action2 ;``
# 
# > *Pour notre exemple de **système d’éclairage par va et vient** :*
# >
# > <h4 class='fa fa-cogs' style="color: darkorange"> A faire vous-même - <strong>Compléter</strong> le diagramme d'états-transitions de la fonction va et vient :</h4>
# > 
# > <img  src="https://ericecmorlaix.github.io/img/ChaineInformation-EtatsTransitions-VaEtVient-Vide.svg" alt="DiagrammeEtatsTransitionsVaEtVient">
# 

# ## Références au programme :
# 
# <style type="text/css">
# .tg  {border-collapse:collapse;border-spacing:0;}
# .tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:black;}
# .tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:black;}
# .tg .tg-cv16{font-weight:bold;background-color:#dae8fc;border-color:inherit;text-align:center}
# .tg .tg-xldj{border-color:inherit;text-align:left}
# </style>
# <table class="tg">
#   <tr>
#     <th class="tg-cv16">Compétences développées</th>
#     <th class="tg-cv16">Connaissances associées</th>    
#   </tr>
#   <tr>
#     <td class="tg-xldj">Traduire le comportement attendu ou observé d’un objet</td>
#     <td class="tg-xldj">Comportement séquentiel<br>Structures algorithmiques (variables, fonctions, structures séquentielles, itératives, répétitives, conditionnelles)<br>Diagramme d’états-transitions</td>    
#   </tr>  
# 
#   <tr>
#     <td class="tg-xldj">Modéliser sous une forme graphique un circuit</td>
#     <td class="tg-xldj">Circuit électrique</td>    
#   </tr>  
#   
# </table>

# <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a><br />Ce document est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">Licence Creative Commons Attribution -  Partage dans les Mêmes Conditions 4.0 International</a>.
# 
# Pour toute question, suggestion ou commentaire : <a href="mailto:eric.madec@ecmorlaix.fr">eric.madec@ecmorlaix.fr</a>