Table des matières

I. PARTIE 1 : Objectifs et description du travail ................................................... 2

1. Objectif ................................................................................................................ 2
2. Descriptions matérielles et logiciels ................................................................... 3
2.1. Matériels........................................................................................................... 3
2.2. Logiciels ............................................................................................................ 3
II. PARTIE 2 : Réalisation de l'application web Dajngo RestApi ..................... 10
1. Développement d’application .......................................................................... 10
2. Integration des notifications d'alarme via Gmail et Twilio dans Django .... 26
2.1. Les alertes via Gmail ..................................................................................... 26
2.2. Les alertes via WhatsApp ............................................................................. 29
III. PARTIE 3 : Réalisation de PCB ...................................................................... 33
1. Circuit imprimé PCB........................................................................................ 33
IV. PARTIE 4 : Lecture de la donnée et l'envoie vers l'application (Local) les
installations arduino, et l'envoie vers l'application.................................................. 37
1 . Les installations Arduino ............................................................................... 37
2 L’envoie vers l'application ............................................................................... 38
V. PARTIE 5: déploiement de l'application sur Django Anywhere ..................... 41
VI. PARTIE 6 : Réalisation du boitier .................................................................. 48
1. Présentation de l'environnement de travail ................................................... 48
2. Création du boitier : ......................................................................................... 49
 I. PARTIE 1 : Objectifs et description du travail
1. Objectif
Ce tutoriel a pour but de vous guider dans les différentes étapes de la conception d'une
application web basée sur le Framework Django. Nous allons explorer les étapes essentielles
pour la création d'une application, de la partie hardware & circuit imprimé en passant par la
partie software jusqu'à la CAO.
Dans la première partie, nous allons aborder les éléments matériels nécessaires pour la
conception de notre application, tels que les outils de développement, les ressources
matériellesest de décrire en détail les objectifs du travail, les besoins matériels et logiciels
nécessaires, ainsi que la méthode de réalisation.
Dans la troisième partie nous nous concentrerons sur la réalisation du PCB (circuit imprimé).
Nous expliquerons les étapes clés, de la conception du schéma électrique à la fabrication du
PCB. Nous aborderons les outils nécessaires et les bonnes pratiques pour garantir un PCB
fonctionnel et de qualité.
Dans la deuxième partie,nous aborderons toutes les étapes nécessaires pour créer l'application
web en utilisant le Framework Django RestApi. Nous détaillerons également la mise en place
des alarmes par mail et Whatsapp pour notifier les utilisateurs. Nous explorerons les
différentes fonctionnalités et les étapes de développement requises.
Dans la quatrième partie,traitera de l'installation et de la configuration des dispositifs Arduino
pour la lecture des données. Nous expliquerons comment les données sont collectées à partir
des capteurs et comment elles sont envoyées vers l'application web. Nous aborderons
également les bonnes pratiques en matière de gestion des données et de communication avec
l'application.
Dans la cinquième partie nous détaillerons le processus de déploiement de l'application web
sur Django Anywhere. Nous expliquerons les étapes nécessaires pour configurer
l'environnement d'hébergement, transférer les fichiers et assurer le bon fonctionnement de
l'application en ligne.
Enfin, dans cette dernière partie, nous aborderons la réalisation du boîtier pour le projet. Nous
présenterons différents outils de CAO (Conception Assistée par Ordinateur) qui peuvent être
utilisés pour concevoir et modéliser le boîtier. Nous expliquerons les étapes nécessaires pour
la fabrication du boîtier physique, en tenant compte des aspects pratiques et esthétiques.
 2. Descriptions matérielles et logiciels
Dans cette partie, nous allons détailler les besoins matériels et logiciels nécessaires pour
mener à bien la réalisation de notre projet
projet.

2.1. Matériels
Dans ce tutoriel, nous allons utiliser une carte de développement ESP8266 pour lire les
valeurs de température et d'humidité à l'aide d'un capteur DHT11.

2.2. Logiciels
L'installation Python
Étape 1 -Accédez à la page de téléchargement officielle de Python pour Windows .

Si vous travaillez avec Windows 10, vous devez aller sur la page de téléchargement dédiée à
cette version pour télécharger. Sinon, choisissez la version de Windows adaptée à votre
système d'exploitation.
 1. Trouvez une version stable de Python 3. Ce tutoriel a été testé avec Python version
3.10.11.

2. Cliquez sur le lien correspondant à votre système pour télécharger le fichier

exécutable : programme d'installation Windows (64 bits) ou programme d'installation
Windows (32 bits).

Étape 2 - Exécution du programme d'installation exécutable

1. Après avoir téléchargé le programme d'installation, vous devez double

double-cliquer sur le
fichier exécutable, tel que python
[Link],
[Link], pour lancer le processus
d'installation de Python.
on.

2. Veuillez cocher la case "Installer le lanceur pour tous les utilisateurs" afin de
permettre à tous les utilisateurs de l'ordinateur d'accéder à l'application de lancement
Python.

3. Veuillez cocher la case "Ajouter [Link] au PATH" afin de permettre au

aux
utilisateurs de lancer Python à partir de la ligne de commande.
Étape 3 - Vérifier l'installation de Python

Pour vérifier si l'installation de Python a réussi, vous pouvez utiliser la ligne de commande ou
l'application Integrated Développement Environnent (IDLE), si elle a été installée. Pour
accéder à la ligne de commande, allez dans le menu Démarrer et entrez "cmd" dans la barre de
recherche, puis cliquez sur "Invite de commandes". Ensuite, saisissez la commande suivante
dans l'invite de commande :

Étape 4 -l’installation
l’installation Pycharm

1. Tout d'abord, téléchargez le programme d'installation de PyCharm pour Windows depuis

le site officiel de JetBrains:

[Link]

Cliquez sur le lien "télécharger" sous la section Communauté.

2. Une fois le téléchargement terminé, double

double-cliquez
cliquez sur le fichier d'installation pour
lancer l'assistant d’installation, L'assistan
L'assistantt de configuration devrait avoir démarré.
Cliquez sur ‘Suivant’.

3- Une fois arrivé à l'écran suivant, si nécessaire, veuillez modifier le chemin

d'installation, puis cliquez sur le bouton 'Suivant'.

4- Cocher les options suivantes pour configurer votre Environnement.

 5- Après avoir terminé l'installation, vous devriez voir un message confirmant l'installation
de PyCharm. Si vous souhaitez exécuter le logiciel immédiatement, cochez la case
"Exécuter PyCharm Community Edition" avant de cliquer sur "Terminer".

Installation de Arduino IDE

Voici les étapes pour installer Arduino
Téléchargez et installez l'IDE Arduino à partir du site officiel d'Arduino :
[Link]

 Cliquez sur le bouton ""Download the Arduino IDE"" pour télécharger le programme
d'installation de l'IDE Arduino.

 Une fois le programme d'installation téléchargé, ouvrez

ouvrez-le.

 Si vous utilisez Windows, le programme d'installation vous demandera si vous

souhaitez autoriser l'application à apporter des modifications à votre ordinateur.
Cliquez sur "Oui"" pour continuer.

 Dans la fenêtre d'installation, cliquez sur ""Next" pour continuer.

 Lisez les termes de la licence et cliquez sur ""I Agree"" pour accepter
acce les conditions
d'utilisation.

 Sélectionnez l'emplacement d'installation de l'IDE Arduino en cliquant sur "Browse".

Vous pouvez également laisser le répertoire d'installation par défaut.

 Cliquez sur "Next"" pour continuer.

  Choisissez les composants que vous souhaitez installer. En général, vous pouvez
laisser les paramètres par défaut et cliquer sur ""Next"
t" pour continuer.

 Attendez que l'installation soit terminée. Cela peut prendre plusieurs minutes.

 Cliquez sur "Close"" pour fermer la fenêtre d'in

d'installation.
Guide du téléchargement et l’installation de Fusion 360
Si vous voulez obtenir le logiciel Fusion 360 gratuitement à des fins éducatives, suivez les
étapes suivantes :

 Sur le site de AUTODESK aller vers Télécharger une version d’évaluation gratuite.
[Link]
[Link]

 Choisissez l’option Fusion 360 for educational use > Educational communit
 Cherchez Fusion 360 et cliquezsur
cliquezsurGet started.
 Choisissez votre rôle d’enseignement ensuite vous pouvez créer votre compte.
 Après la vérification de votre compte vous devez choisir encore le produit de Fusion
360.

 Maintenant vous aurez la main pour remplir vos informations personnelles et les
informations de votre institution.

 Ici vous devez charger une copie d’une documentation délivrée par votre établissement
d'enseignement prouvant que vous étudiez, enseignez ou travaillez dans
un établissement d'enseignement agréé (sous format JPEG, PDF, PNG ou GIF).
GIF) A droit
vous trouverez des exemples de documents à fournir.
 Après cette étape vous trouverez un mail sur votre boite, qui vous donne l’accès à tous
les produits de AUTODESK
AUTODESK.
Maintenant vous pouvez installer le logiciel Fusion 360
 Après avoir lancé le fichier
chier que vous avez téléchargé plus tôt, l’installation
commencera automatiquement.

 Vous attendez jusque l’installation se termine ensuite vous aurez la main pour se
connecter à votre compte.

Ensuite :
 Cliquez sur Creat a team
team.
 Entrez un nom pour votre équipe.
 Cochez l’option que vous préférez.
II. PARTIE 2 :Réalisation
Réalisation de l'application web Dajngo RestApi
Dans cette partie, nous allons apprendre comment créer une application web Django RestApi
avec des fonctionnalités d'alarme par mail et Whatsapp. Cette application web sera capable de
recevoir des requêtes HTTP, de traiter les données, d'envoyer des alertes et de fournir une API
Rest pour les clients.
Apres l’installation des toute les logiciels nécessaires pour notre projet en n’est prprêt pour
passer à la création l’application web pour cela il faut ouvrir Pycharm.

1. Développement d’application
Étape 1- Environnement virtuel

Il est recommandé de créer un environnement virtuel dédié pour chaque projet Django en
utilisant venv, qui est inclus dans Python. Pour ce tutoriel, nous allons nommer notre
environnement virtuel "projet". Pour créer cet environnement virtuel, ouvrez l'invl'invite de
commande dans le terminal Pycharm en mode commande Promptet et naviguez jusqu'à
l'emplacement où vous souhaitez créer votre projet, puis tapez la commande suivante :

Créer un dossier "projet_iot" sur le bureau pour le développement de l'application avec

les alarmes par e-mail
mail et WhatsApp.

Puis il faut accès vers le chemin de dossier à partir le terminal Pycharm

Puis tapez la commande suivante :

python -m
m venv projet

Cela permet de créer un environnement virtuel nommé "projet" dans le répertoire "projet_iot"
situé sur le bureau. Ensuite, pour activer cet environnement, veuillez exécuter la commande
suivante
projet\Scripts\[Link]
[Link]

NB :il faut activer l’environnement virtuel chaque fois que vous allez ouvrir la ligne de
commandende pour travailler sur votre projet.

Étape 2 – Installation Django

Après la création de notre environnement virtuel, nous sommes prêts à procéder à

l'installation de Django.

Py -m
m pip install Django

Pour installer Django restframework :

pip install djangorestframework

pip install markdown
pip install django
django-filter

Étape 3 – Création d’un projet dans Django

Créer un nouveau projet Django : Une fois que Django et les dépendances sont installés, nous
pouvons créer un nouveau projet Django avec la commande suivante :

Django-admin
admin startproject projet

Une fois que vous disposez d'un projet Django, vous pouvez l’exécuter pour vérifier que tout
fonctionne correctement.
Il faut visiter le [Link]
[Link]
dans votre navigateur Web et de vous assurer que
l'image suivante est visible :

Après l'installation et la configuration des différents outils utilisés dans ce tutoriel, nous allons
commencer maintenant à développer notre projet. Il suffit de suivre les étapes précédentes.
Tout d'abord, il faut ouvrir le dossier que vous avez créé au début, qui contient le projet (dans
nos cas, on a nommé le projet ""projet_iot").

Voici la structure du projet :

 Étape 4 – Création d’une Application dans Django

Après avoir créé le projet Django, nous devons créer une application Django
DjangoDHTà l'intérieur
du projet avec la commande suivante :

django-admin
admin startapp DHT

Afin de vérifier si cette application a bien été créée, il est nécessaire de vérifier en haut
de votre environnement de travai
travail.

Comme montre cette image application DHTétait était bien crée. On va aller vers le fichier
[Link], Le fichier "[Link]
[Link]"" dans Django est un fichier de configuration important qui
contient des paramètres pour votre application Django. Il contient des informations telles que
les paramètres de la base de données, les paramètres de messagerie électronique, les
informations de sécurité, les paramètres de fichiers statiques et médias.

Pour ce faire, vous devez accéder au fichier [Link] et ajouter notre application 'DHT'
dans le champ INSTALLED_APPS. De plus, n'oubliez pas d'inclure également 'rest-
framework' dans la liste des applications.
Chaque application créée dans Django contient les fichiers suivants :

[Link]:: Ce fichier contient les définitions des modèles de données de l'application.

Les modèles sont des classes Python qui définissent les tables de la base de données et
les champs qu'elles contiennent.

[Link] : Ce fichier contient la logique métier de l'application. Il définit les vues, qui sont
des fonctions Python qui gèrent les requêtes HTTP entrantes et renvoient des réponses
appropriées.

[Link] : Ce fichier définit les modèles de données qui peuvent être modifiés via l'interface
d'administration de Django.

Il y a un autre fichier qui n’existe pas dans cette nouvelle application crée par utilisateur qui
s’appelle ‘‘[Link]’’,ce
,ce dernier est un élé
élément
ment clé de chaque application Django car il permet
de définir les URL pour les vues spécifiques à l'application, ce qui facilite la gestion des URL
dans un projet Django.
 Étape 5 – Création d’une vue Django

Pour créer la première vue, vous devez commencer par mettre à jour le fichier [Link] de
notre application "projet". De plus, il est nécessaire de lier l'URL de l'application avec l'URL
de votre projet de la manière suivante.

a. En commençant par mettre à jour le fichier DHT/[Link]

Nous avons importé la méthode intégrée HttpResponse pour pouvoir renvoyer un objet de
réponse à l'utilisateur. Une fonction nommée 'test' a été créée, prenant en paramètre l'objet
'request' et renvoyant une réponse contenant la chaîne 'Iot Project'.

Pour poursuivre, nous devons configurer les URL dans notre application. Il est nécessaire de
mettre à jour le fichier DHT/[Link] que nous avons créé lors des étapes précédentes.

from [Link] import path

from . import views

urlpatterns=[
path('',[Link]),
ath('',[Link]),
]

La dernière étape consiste à mettre à jour le fichier projet/[Link]

from [Link] import admin

from [Link] import path,include
*
urlpatterns = {
path('admin/', [Link]),
path('', include('[Link]')),

Afin de vérifier que tout fonctionne comme prévu, veuillez redémarrer votre serveur
Django

python [Link] runserver

Lorsque vous rafraîchissez votre navigateur à l'adresse
l'adresse[Link]
[Link] , vous verrez
maintenant le texte affiché : "Iot Project"

Vous pouvez également accéder à cette page en utilisant l'adresse IP de votre machine. Pour
cela, ouvrez l'invite de commandes et saisissez la commande ""ipconfig"" pour obtenir votre
adresse IP.

Ensuite, vous devrez ajouter cette adresse IP dans le fichier [Link].

Rafraîchissez votre navigateur :

python [Link] runserver

runserver192.168.1.7:8000

Actualisez le navigateur, [Link] il affiche maintenant le texte

Partie 6 : Gestion de base de données :

python
ython [Link] runserver [Link] :8000

Dans le fichier DHT/[Link]

DHT/[Link], vous allez commencer par créer un modèle, ce qui implique
la création d'une table dans la base de données.

from [Link] import models

class Dht11([Link]):
temp = [Link](null=True)
hum = [Link](null=True)
dt = [Link](auto_now_add=True,null=True)
imeField(auto_now_add=True,null=True)
Apres en modifie DHT/[Link] pour en enregistrer le tableau :

from [Link] import admin

from . import models
[Link](models.Dht11)

Maintenant que nous avons défini un modèle dans le fichier [Link], vous devez exécuter
une commande pour créer effectivement la table correspondante dans la base de données

python [Link] makemigrations

python [Link] migrate

Afin de vérifier si le modèle existe, il est nécessaire de créer un super-utilisateur

utilisateur pour accéder
à l'interface d'administration de Django. Vous pouvez utiliser la commande suivante pour ce
faire

Python [Link] createsuperuser

Username : admin

Mail : projet@[Link]

Après cette action il faut allez vers l’interface d’administration [Link]

[Link]

Etape 6 : Utilisation de Django Rest Framework pour créer une API

Vous allez créer un fichier d’un fichier dht/[Link]

Son rôle est de faciliter la
conversion d'objets Python en données JSON, permettant ainsi la communication entre
le client et le serveur danss une application Django.
 from rest_framework import serializers
from .modelsimport Dht11
class
DHT11serialize([Link])
:
class Meta :
model = Dht11
fields ='__all__'

Créer un fichier DHT/[Link]

from .models import Dht11
from .serializers import DHT11serialize
from rest_framework.decorators import api_view
from rest_framework import status
from rest_framework.response import Response
import rest_framework
@api_view(["GET","POST"])
def dhtser(request):
if [Link]=="GET":
all=[Link]()
dataSer=DHT11serialize(all,many=True) # les donnée se form fichier JSON
return Response([Link])
elif [Link]=="POST":
serial=DHT11serialize(data=reques
serial=DHT11serialize(data=[Link])
if serial.is_valid():
[Link]()
return Response([Link], status=status.HTTP_201_CREATED)
else:
return Response([Link], status=status.HTTP_400_CREATED)

Veuillez ajouter cette ligne dans le fichier DHT/[Link] :

path("api",[Link]
[Link],name='json'),

Voilà résultat obtenue :

Postman est un outil populaire utilisé pour testeet déboguer les API RESTful développées
avec Django.

On va envoyer les données de température et humidité vers le module DHT11 pour stocker
ces valeurs, les données sont envoyées sous forme JSON, la valeur de température
tempé stock dans
le champ temp et la valeur d’humidité stock dans le champ hum.

Après l’envoi ces données on remarque que le serveur répondre par envoie des données
associer à cette requête.

Après l’envoi ces données on remarque que le serveur répondre par envoie des données
associer à cette requête.

Pour vérifier si la valeur et bien reçu on va allez accéder à l’administrationDjango puis

on va chercher si la valeur et objet et crée ou bien non, dans notre l’objet et crée avec
succès.
 Etape 9 : Création des fichiers HTML et CSS dans django

Création d’un nouveau dossier qui contient Templates.

Ensuite, nous allons nous rendre dans le fichier [Link] pour ajouter les lignes
suivantes :
import os
STATICFILES_DIRS = [
[Link](BASE_DIR, "template")]
STATIC_ROOT=[Link](BASE_DIR,'static')

Lorsque vous exécutez la commande python [Link] collectstatic,

collectstatic Django collecte
automatiquement tous les fichiers statiques de votre projet et les place dans le répertoire
spécifié par la variable STATIC_ROOT
STATIC_ROOT.

Le dossier projet_iot devient comme suit.

Pour afficher cette page, vous devez suivre les étapes suivantes :

 La première étape consiste à modifier le fichier

[Link]

def table(request):
derniere_ligne = [Link]()
derniere_date = [Link]().dt
delta_temps = [Link]() - derniere_date
difference_minutes = delta_temps.seconds // 60
temps_ecoule = ' il y a ' + str(difference_minutes) + ' min'
if difference_minutes>
fference_minutes> 60:
temps_ecoule = 'il y ' + str(difference_minutes // 60) + 'h' +
str(difference_minutes % 60) + 'min'
valeurs = {'date': temps_ecoule, 'id': derniere_ligne.id, 'temp':
derniere_ligne.temp, 'hum': derniere_ligne.hum}
return render(request,
r(request, '[Link]', {'valeurs': valeurs})
  Au début du fichier [Link], vous devez importer les bibliothèques suivantes.

import datetime
from [Link] import timezone

 Pour télécharger les données au format CSV, cliquez sur le bouton de

téléchargement. Cela déclenchera le processus qui génère un fichier CSV
contenant les informations demandées, puis le fichier sera proposé en
téléchargement à l’utilisateur.

Vous devez ajouter dans le fichier [Link] :

def download_csv(request):
model_values = [Link]()
response
nse = HttpResponse(content_type='text/csv')
response['Content-Disposition']
Disposition'] = 'attachment; filename="[Link]"'
writer = [Link](response)
[Link](['id', 'temp', 'hum', 'dt'])
liste = model_values.values_list('id', 'temp', 'hum', 'dt')
for row in liste:
[Link](row)
return response

Par la s

Aussi ajouter dans le fichier [Link] :

uite il faut mettre à jours leviews.download_csv,

path('download_csv/', fichier [Link] : name='download_csv'),
path('index/',[Link],name='table'),
path('myChart/',[Link],name='myChart'),

Vous devez créer les fichiers suivants dans le dossier "template".

Dans le dossier de notre projet qui s’appelé projeton va créer un nouveau dossier qui
s’appelle staticdans ce dernier on crée d’autre dossier qui s’appelé cssetimages.
Vous devez créer les fichiers suivants dans le dossier "static/css"

Pour accéder au code de ces fichiers, veuillez

veuillez-vous
vous rendre sur le lien GitHub suivant :

 Lorsque l'utilisateur clique sur le bouton de téléchargement, les données du

modèle sont automatiquement stockées dans un fichier CSV

 Afin d'afficher les valeurs de température et d'humidité sous forme de

graphiques.
Notre application offre une gamme d'options avancées pour la surveillance de la température
et de l'humidité. Elle permet non seulement l'affichage en temps réel des graphiques de
température et d'humidité, mais intègre également une fonctionnalité puissante qui permet aux
utilisateurs d'accéder à l'historique des valeurs sur une période allant d'un jour à un mois.
Cette fonctionnalité permet une analyse approfondie des tendances pa passées
ssées et une meilleure
compréhension des variations sur une période donnée, offrant ainsi aux utilisateurs une
perspective complète de l'évolution des conditions environnementales.

Vous devez mettre à jour le fichier DHT/[Link]

#pour afficher navbar de template

defindex_view(request):
return render(request, '[Link]')

#pour afficher les graphes

def graphique(request):
return render(request, '[Link]')

# récupérer toutes les valeur de température et humidity sous forme un

#fichier json

def chart_data(request):
dht = [Link]()

data = {
'temps': [[Link] for Dt in dht],
'temperature': [[Link] for Temp in dht],
'humidity': [[Link] for Hum in dht]
}
return JsonResponse(data)

#pour récupérer les valeurs de température et humidité de dernier 24h

# et envoie sous forme JSON

defchart_data_jour(request):
dht = [Link]()
now = [Link]()

# Récupérer l'heure il y a 24 heures

last_24_hours = now - [Link](hours=24)

# Récupérer tous les objets de Module créés au cours des 24 dernières

heures
dht = [Link](dt__range=(last_24_hours, now))
data = {
'temps': [[Link] for Dt in dht],
'temperature': [[Link] for Temp in dht],
'humidity': [[Link] for Hum in dht]
}
return JsonResponse(data)

#pour récupérer les valeurs de température et humidité de dernier semaine

# et envoie sous forme JSON

defchart_data_semaine(request):
dht = [Link]()
# calcul de la date de début de la semaine dernière
date_debut_semaine = [Link]().date() - [Link](days=7)
print([Link](days=7))
print(date_debut_semaine)

# filtrer les enregistrements créés depuis le début de la semaine

dernière
dht = [Link](dt__gte=date_debut_semaine)

data = {
'temps': [[Link] for Dt in dht],
'temperature': [[Link] for Temp in dht],
'humidity': [[Link] for Hum in dht]
}

return JsonResponse(data)

#pour récupérer les valeurs de température et humidité de dernier moins

# et envoie sous forme JSON

defchart_data_mois(request):
dht = [Link]()

date_debut_semaine = [Link]().date() - [Link](days=30)

print([Link](days=30))
print(date_debut_semaine)

# filtrer les enregistrements créés depuis le début de la semaine

dernière
dht = [Link](dt__gte=date_debut_semaine)

data = {
'temps': [[Link] for Dt in dht],
'temperature': [[Link] for Temp in dht],
'humidity': [[Link] for Hum in dht]
}
return JsonResponse(data)
Vous devez également mettre à jour le fichier DHT/[Link].
path ('chart-data/',views.chart_data, name='chart-data'),
path('chart-data-jour/',views.chart_data_jour,name='chart-data-jour'),
path('chart-data-semaine/',views.chart_data_semaine,name='chart-data-
semaine'),
path('chart-data-mois/',views.chart_data_mois,name='chart-data-mois'),

2. Integration des notifications d'alarme via Gmail et Twilio dans

Django
Nous avons utilisé deux types d'alerte : par WhatsApp et par Gmail.

2.1. Les alertes via Gmail

a. Pour commencer, vous devez accéder à votre boîte de réception, puis vous rendre dans la
section 'Gérer votre compte Google'
b. Ensuite, vous devrez accéder à la section 'Validation en deux étapes

c. Veuillez entrer votre numéro de téléphone, puis saisir le code de confirmation

[Link]édez à la section 'Mots de passe des applications'

c. Vous devez sélectionner les deux options suivantes : Messagerie et Ordinateur Windows.

d. Pendant cette étape, vous devrez récupérer le mot de passe afin de l'utiliser dans l'étape
suivante
e. Pour cela, vous devez ajouter ces lignes dans le fichier [Link].
EMAIL_BACKEND = '[Link]'
EMAIL_HOST = '[Link]' # remplacer avec l'adresse SMTP de votre
fournisseur de messagerie
EMAIL_PORT = 587 # remplacer avec le port SMTP de votre fournisseur de
messagerie
EMAIL_USE_TLS = True # ou False, selon la configuration de votre
fournisseur de messagerie
EMAIL_HOST_USER = 'pfaensao@[Link]' # remplacer avec votre adresse email
EMAIL_HOST_PASSWORD = '**************' # remplacer avec votre mot de passe
email

Veuillez remplacer EMAIL_HOST_PASSWORD par le mot de passe de l'application. Assurez-vous

également de substituer EMAIL_HOST_USER par l'adresse e-mail de l'utilisateur destinataire de
l’alerte.
Et aussi Il faut mettre à jour le fichier DHT/[Link]
from .models import Dht11
from .serializers import DHT11serialize
from rest_framework.decorators import api_view
from rest_framework import status
from rest_framework.response import Response
from [Link] import send_mail
from [Link] import settings
import rest_framework
@api_view(["GET","POST"])
def dhtser(request):
if [Link]=="GET":
all=[Link]()
dataSer=DHT11serialize(all,many=True) # les donnée se form fichier
JSON
return Response([Link])
elif [Link]=="POST":
serial=DHT11serialize(data=[Link])
if serial.is_valid():
[Link]()
derniere_temperature = [Link]().temp
print(derniere_temperature)
if (derniere_temperature > 10):
# Alert Email
subject = 'Alerte'
message = 'Il y a une alerte importante sur votre Capteur
la température dépasse le seuil'
email_from = settings.EMAIL_HOST_USER
recipient_list = ['simouyacoubi3@[Link]']
send_mail(subject, message, email_from, recipient_list)
return Response([Link], status=status.HTTP_201_CREATED)
else:
return Response([Link], status=status.HTTP_400_CREATED)
Dès que le capteur détecte une valeur dépassant le seuil, Django envoie instantanément une
alerte par e-mail.

2.2. Les alertes via WhatsApp

En utilisant Django, vous pouvez facilement intégrer Twilio pour envoyer des SMS et des
messages WhatsApp. Pour ce faire, vous devez configurer votre compte Twilio, installer le
package Twilio pour Python dans votre environnement Django, puis configurer le code
permettant l'envoi de messages WhatsApp.
Pour intégrer Twilio dans un projet Django, vous pouvez suivre ces éétapes :

 Ouvrez une console de commande ou un terminal et accédez au répertoire racine de votre

projet Django.
 Exécutez la commande suivante :
pip install twilio
 Ajoutez "twilio" à la liste des applications installées dans le fichier [Link] de votre projet
Django.

1. Créer un compte Twilio sur [Link]

2. Une fois que vous avez créé un compte sur Twilio, vous serez redirigé(e) vers cette
page.
3. Par la suite vous devez accéder à Develop>Try
>Try it out >send a WhatsApp message

4. Vous devez connecté à WhatsApp Sandbox

5. Une fois la dernière étape terminée, vous devrez envoyer un message contenant le
texte 'joint-plane-consider'.
consider'.

6. Afin de vérifier que tout fonctionne correctement, nous allons envoyer un message
simple contenant le texte 'test project'.

7. Voilà le résultat de ce test

Maintenant, pour recevoir une alerte lorsque la valeur de température dépasse le seuil, vous
devez ajouter les lignes suivantes dans le fichier DHT/[Link], après la fonction send_mail.
Tout d'abord, veuillez importer la bibliothèque suivante en haut du fichier :
from [Link] import Client

# Alertwhatsapp
account_sid = 'AC96f6d9f021767c357c40bf66cc4f6934'
auth_token = 'd2783068de43b66f778115c7bae9fa8d'
client = Client(account_sid, auth_token)

message = [Link](
from_='whatsapp:+14155238886',
body='Il y a une alerte importante sur votre Capteur la température
dépasse le seuil',
to='whatsapp:+212701085841'
)

[Link] vérifier que tout fonctionne correctement, nous allons envoyer une valeur qui dépasse
le seuil (dans notre cas, le seuil est fixé à 10°C) depuis POSTMAN.
III. PARTIE 3 :Réalisation
Réalisation de PCB
1. Circuit imprimé PCB
Le but de ce tutoriel est de vous apprendre à créer un PCB fonctionnel en utilisant EasyEDA,
un logiciel en ligne gratuit de conception de circuits imprimés. Ce tutoriel vous guidera à
travers les étapes nécessaires ppour
our créer un PCB pour la carte de développement ESP8266 et
un capteur DHT11.
Étape 1 : Créer un compte EasyEDA
La première étape consiste à créer un compte sur EasyEDA. Vous pouvez vous rendre sur le
site Web d'EasyEDA et créer un compte gratuitement.
[Link]://[Link]

Étape 2 : Créer un nouveau projet

Une fois que vous avez créé un compte EasyEDA, vous pouvez commencer à créer un
nouveau projet. Pour créer un nouveau projet, cliquez sur l'onglet "New Project" dans la
barre de navigation supérieure, puis suivez les instructions pour nommer votre projet.
Étape 3 : Ajouter les composants
La prochaine étape consiste à ajouter les composants nécessaires à votre PCB. Dans ce cas,
nous avons besoin d'un module ESP8266 et d'un capteur DHT11. Pour ajouter ces
composants, recherchez-les
les dans la bibliothèque de composants EasyEDA et faites
faites-les glisser
sur votre schéma.
Étape 4 : Connecter les composants
Une fois que vous avez ajouté les composants, vous devez les connecter. Pour ce faire, utilisez
l'outil "Wire" pour connecter les broches des composants ensemble. Assurez
Assurez-vous de suivre
correctement les broches de chaque composant en fonction de son schéma.
 Connectez le pin VCC de l'ESP8266 au pin VCC du D
DHT11.
 Connectez le pin GND de l'ESP8266 au pin GND du DHT11.
 Connectez le pin D3 de l'ESP8266 au pin DATA du DHT11.

Étape 5 : Créer un PCB

Une fois que vous avez créé votre schéma et que vous avez connecté tous les composants,
vous pouvez passer à la création de votre PCB. Cliquez sur l'onglet "Convert to PCB" dans
le coin supérieur droit pour passer en mode PCB.
Étape 6 : Positionner les composants
Dans le mode PCB, vous pouvez positionner les composants sur le PCB en faisant glisser les
composants vers leur emplacement souhaité. Assurez
Assurez-vous
vous que les broches de chaque
composant sont correctement alignées avec les pistes que vous avez dessinées.
Étape 7 : Dessiner les pistes
Une fois que vous avez positionné les composants, vous pouvez dessiner les pistes nécessaires
pour connecter les broches. Utilisez l'outil "Route" pour dessiner les pistes en reliant les
broches ensemble. Essayez de dessiner les pistes les plus courtes possible pour éviter les
pertes de signal.
Étape 8 : Générer les fichiers Gerber
Une fois que vous avez terminé la conception de votre PCB, vous devez générer les fichiers
Gerber pour envoyer votre PCB en production. Pour générer les fichiers Gerber, cliquez sur

l'onglet "Gerber" dans le coin supérieur droit et suivez les instruction

instructions pour générer les
fichiers nécessaires.
Et voilà ! Vous avez créé votre PCB avec EasyEDA pour votre carte de développement
ESP8266 et votre capteur DHT11. Vous pouvez maintenant envoyer les fichiers Gerber à
votre fabricant de PCB préféré pour produire vo
votre PCB.
IV. PARTIE 4 : Lecture de la donnée et l'envoie vers
l'application (Local) les installations arduino, et l'envoie vers
l'application

Dans cette partie qui explique le fonctionnement du code de surveillance de température et

d'humidité à l'aide de l'ESP8266. Nous allons utiliser une carte de développement ESP8266
pour lire les valeurs de température et d'humidité à l'aide d'un capteur DHT11 et les envoye
envoyer à
un serveur Web via une requête HTTP POST.

1 . Les installations Arduino

1. Ouvrez l'IDE Arduino et allez dans le menu "Fichier" -> "Préférences". Dans la
fenêtre de préférences, collez le lien suivant dans le champ "URL de gestionnaire de
cartes supplémentaires" :
[Link]
[Link]
/package_esp8266com_index.json

2. Cliquez sur "OK" pour fermer la fenêtre de préférences.

3. Allez dans le menu "Outils" -> "Type Type de carte" et sélectionnez "Gestionnaire de
cartes". Dans la fenêtre de gestionnaire de cartes, recherchez "esp8266" et installez
installez-le
package correspondant.
 4. Une fois l'installation terminée, sélectionnez "NodeMCU 1.0 (ESP-12E Module)"
comme type de carte dans le menu "Outils" -> "Type de carte".
5. Connectez votre ESP8266 à votre ordinateur à l'aide d'un câble USB.
6. Allez dans le menu "Outils" -> "Port série" et sélectionnez le port COM
correspondant à votre ESP8266.
7. Vous êtes maintenant prêt à téléverser un programme sur votre ESP8266 à partir de
l'IDE Arduino.

2 L’envoie vers l'application

Nous allons apprendre à :
 Préparation de l'environnement de développement
 Configurer l'adresse IP et le port du serveur Web.
 Initialiser le capteur de température et d'humidité.
 Configurer les informations de connexion Wi-Fi.
 Lire les valeurs de température et d'humidité.
 Envoyer les données au serveur Web.
Commençons !
1- Préparation de l'environnement de développement
Avant de commencer, vous devez installer les bibliothèques ESP8266WiFi,
ESP8266HTTPClient, ArduinoJson et DHT. Pour cela, vous pouvez suivre les étapes
suivantes
 Lancez l'IDE Arduino.
 Sélectionnez le menu "Croquis" (Sketch), puis "Inclure une bibliothèque" (Include
Library), puis "Gérer les bibliothèques" (Manage Libraries).
 Recherchez et installez les bibliothèques ESP8266WiFi, ESP8266HTTPClient,
ArduinoJson et DHT.
2-Configuration de l'adresse IP et du port du serveur Web
Dans la partie suivante du code, nous devons configurer l'adresse IP et le port du serveur Web
où nous allons envoyer les données de température et d'humidité.

// Remplacez l'adresse IP et le port par ceux de votre serveur Web

const char* serverName = "[Link]
Dans cet exemple, le port est "8000". Vous devrez remplacer ces informations avec celles de
votre propre serveur Web.
3-Initialisation du capteur DHT11
Nous initialisons le capteur DHT11 dans la fonction setup() en définissant la broche à laquelle
il est connecté (DHTPIN) et en spécifiant son type (DHTTYPE).
#define DHTPIN 2 // broche du capteur connecté à la carte Arduino
#define DHTTYPE DHT11 // Type de capteur DHT (DHT11 ou DHT22)
DHT dht(DHTPIN, DHTTYPE);
4- Configuration des informations de connexion Wi-Fi
Dans la première partie du code, nous devons configurer les informations de connexion Wi-Fi
pour se connecter à notre réseau sans fil.
const char* ssid = "VotreSSID";
const char* password = "VotreMotDePasse";
Ensuite, dans la fonction setup(), nous initialisons la communication série avec une vitesse de
9600 bauds et nous nous connectons à notre réseau WiFi. Nous utilisons une boucle while
pour attendre que la connexion soit établie avant de continuer.
void setup() {
[Link](9600);
[Link](ssid, password);
while ([Link]() != WL_CONNECTED) {
delay(1000);
[Link]("Connexion en cours au réseau WiFi...");
}
[Link]("Connecté au réseau WiFi");
}

4-Lecture des valeurs de température et d'humidité

Dans cette partie du code, nous lisons les valeurs de température et d'humidité à partir du
capteur.
// Lecture des valeurs de température et d'humidité
floattemperature = [Link]();
floathumidity = [Link]();
Nous stockons ensuite ces valeurs dans les variables "temperature" et "humidity".
Les valeurs sont ensuite affichées sur le moniteur série :
[Link]("Temperature: ");
 [Link](temperatur
[Link](temperature);
[Link](" °C - Humidity: ");
[Link](humidity);
[Link](" %");

6-Envoyer
Envoyer les données au serveur Web.
Les valeurs sont ensuite envoyées à un serveur web via une requête HTTP POST. Tout
d'abord, nous créons un objet JSON qui contient les valeurs de température et d'humidité :

StaticJsonDocument<200>doc;
doc["temperature"] = temperature;
doc["humidity"] = humidity;
Nous convertissons ensuite l'objet JSON en une chaîne JSON :
String jsonStr;
serializeJson(doc, jsonStr);
Nous envoyons ensuite la requête HTTP POST au serveur web :
WiFiClientclient;
HTTPClienthttp;
[Link](client, serverName);
[Link]("Content
[Link]("Content-Type", "application/json");
inthttpResponseCode = [Link](jsonStr);

Si la requête est réussie, le code de réponse HTTP est affiché sur le moniteur série :
[Link]("HTTP Responsecode: ");
[Link](httpResponseCode);
Sinon,
non, le code d'erreur est affiché sur le moniteur série :
[Link]("Errorcode: ");
[Link](httpResponseCode);
Nous terminons enfin la requête HTTP :
[Link]();
V. PARTIE5 : déploiement de l'application sur Django
Anywhere
PythonAnywhere est une plateforme d'hébergement et de développement en ligne qui offre un
environnement complet pour exécuter, développer et déployer des applications Python sans
tracas d'installation ou de configuration complexe. Avec PythonAnywhere, vous pouvez
facilement lancer des scripts Python, créer des applications web, accéder à une console
interactive, programmer des tâches automatisées et gérer des bases de données. Nous avons
choisi d'utiliser cette plateforme pour lancer notre application gratu
gratuitement,
itement, profitant ainsi de
ses fonctionnalités pratiques et de son infrastructure fiable.
Après accédé à cette plateforme il faut allez à signup.

Ensuite, vous devez créer un compte sur la plateforme.

À ce niveau, veuillez remplir les champs requis en entrant vos informations correctement,
notamment votre adresse électronique, car vous recevrez ultérieurement un message de
confirmationpermettant
permettant d'activer votre compte
compte.

Une fois connecté, vous serez redirigé vers le tableau de bord. Da

Dans
ns le menu supérieur,
cliquez sur l'onglet "Web".

Dans la section "Web Apps", cliquez sur le bouton "Add a new web app" (Ajouter une
nouvelle application web)
Choisissez-vous
vous l’option "Manual Configuration" (Configuration manuelle) pour
personnaliser davantage votre environnement.

Suivez les instructions pour configurer votre application. Cela peut inclure la spécification du
chemin d'accès de votre application, la sélection de la version de Python (dans notre cas on a
travaillé par la version 3.9).
Après cela, vous devrez ouvrir l'invite de commande Windows et activer l'environnement
virtuel de votre projet en utilisant le nom "projet". Ensuite, exécutez la commande suivante
dans le répertoire de votre projet, qui est appelé "pro
"projet_iot"
jet_iot" dans notre cas.
NB : Si vous avez modifié le nom de l'environnement de votre projet, assurez
assurez-vous
d'inclure ce changement dans la commande correspondante.

Dans les étapes suivantes, vous devrez compresser le dossier de travail afin de l'ajouter aux
fichiers de la plateforme PythonAnywhere. Cliquez sur le bouton ""Upload file" et
sélectionnez le chemin du dossier compressé. Voilà le résultat que vous devez obtenir.
Dans l'étape suivante de la procédure, vous devez accéder à la console et sélectionner "Start
New Console".

Ensuit vous devez créer un nouvel environnement virtuel dans votre pythonAnywhere serveur
pour cela vous devez exécuter cette commande :
mkvirtualenv django --python=/usr/bin/python3.9
Cette figure montre deux commande doivent exécuter dans votre bash.
La première commande à exécuter est "dir" pour vérifier si votre dossier compressé est
présent dans votre environnement de travail. Ensuite, utilisez la deuxième commande "unzip
projet_iot.zip" pour décompresser le dossier "projet_iot.zip".

Ensuite, dans l'onglet "Web" de votre tableau de bord PythonAnywhere, vous devrez
remplacer "Virtualenv" par le nom de votre environnement virtuel (dans notre exemple, nous
l'avons appelé "django").
Après le lancement de l'application, vous serez redirigé vers la page d'accueil par défaut d'une
application Web hébergée sur PythonAnywhere.

Afin de lancer votre application à la place de la page d'accueil par défaut, veuillez suivre les
étapes suivantes :
1. Accédez à la console Bash et naviguez vers votre répertoire de travail, comme illustré
dans l'image ci-dessous
dessous :

2. Exécutez la commande suivantes :

pip install -rr [Link]

3. Ensuite, dans l'onglet "Web" de votre tableau de bord PythonAnywhere, accédez à la

configuration WSGI en cliquant sur le fichier de configuration dans la section "Code".
Supprimez la partie de code relative à la page d'accueil et effacez toutes les lignes, à
l'exception de la partie concernant Django. À ce stade, il est nécessaire de supprimer
les commentaires des lignes de code pertinentes, puis enregistrez les modifications ,
comme illustré dans l'image ci
ci-dessous.
4. Dans le même fichier où nous avons effectué les modifications, deux autres
modifications doivent être apportées.
a) La première modification concerne la ligne path = '/home/pfaprojet/mysite'.
Vous devez remplacer "mysite" par le nom du dossier de votre environnement
de travail. Dans notre exemple, le dossier est appelé "projet_iot". L'image ci-
dessous explique comment trouver votre dossier de travail.

La deuxième modification concerne la ligne

[Link]['DJANGO_SETTINGS_MODULE'] =[Link]'

b) Vous devez remplacer "mysite" par le nom du dossier de votre environnement

virtuel. Dans notre exemple, le dossier est appelé "projet ". L'image ci-dessous
explique comment trouver votre dossier qui contient le fichier [Link].
5. Allez vers bash et exécuter la commande suivante :
python [Link] collectstatic
VI. PARTIE 6 : Réalisation du boitier
1. Présentation de l'environnement de travail

1. Application Bar
Barre d’applications
Accédez au panneau de données (permettant un accès rapide à vos fichiers de conception),
aux opérations de fichiers, à l'enregistrement, à l’annulation et à la restauration.
2. Profile, Préférences, Notifications, and Help
Profil, préférences, notifications et aide
Le profil utilisateur vous permet de gérer vos paramètres de compte et de profil, tandis que le
menu d'aide peut être utilisé pour obtenir une assistance en cas de problèmes ou pour
continuer à apprendre. Les extensions de Fusion 360 peuvent être gérées pour contrôler
l'accès à celles-ci. Vous pouvez également vérifier l'état de votre travail, de la mise à jour de
Fusion 360 et de votre connectivité en ligne ou hors ligne.
3. Toolbar
 Barre d’outils
A l’aide de la barre d’outils vous pouvez sélectionner l’espace de travail dans lequel vous
souhaitez travailler et l’outil que vous souhaitez utiliser dans l’espace de travail sélectionné
4. Browser
Navigateur
Le navigateur répertorie les objets de votre conception (planes, sketches, parts, assemblies,
etc.) et vous permet de contrôler la visibilité des objets
6. ViewCube

Cube de visualisation
Le ViewCube vous permet d’orbiter votre conception ou d’afficher la conception à partir de
positions d’affichage standard
6. Navigation Bar and display settings
Barre de navigation et paramètres d'affichage
La barre de navigation contient des commandes utilisées pour zoomer, faire pivoter et
déplacer votre conception. Les paramètres d’affichage contrôlent l’apparence de l’interface et
la façon dont les conceptions sont affichées
7. Timeline
Chronologie
La chronologie répertorie toutes les opérations effectuées sur votre conception. Vous pouvez
cliquer avec le bouton droit sur les opérations dans la chronologie pour apporter des
modifications. Faites glisser les opérations pour modifier l'ordre dans lequel elles sont
calculées.

2. Création du boitier :

Tous les mesures qui sont prises dans ce tuto dépendent des dimensions du PCB

Tout d’abord, vous devez importer le fichier .dxf de la PCB que vous avez realisée avec
EasyEDA. Pour ce faire, vous allez dans Application bar File >upload et vous sélectionnez le
fichier. Ensuite, allez dans File >open et ouvrez-le.
Dans Toolbar>CREATEsélectionnez
sélectionnez Box et puis commencez à créer une boite autour de la PCB (en
laissant une marge de quelques millimètres de chaque ccôté)
ôté) avec une hauteur de 48mm.

Dans Toolbar selectionnez MODIFY

MODIFY>Shell puis sélectionnez la face du Box qui correspond à
la face TOP du Viewcube.. Assurez
Assurez-vous de sélectionner le choix OUTSIDE de la direction.
Glissez la flèche et faites une distance de 4mm et cliquez sur OK.
Sélectionnez la face du Box correspondante a TRIGHT dans Viewcube puis dans Toolbar
cliquer sur Create sketch
Dans Toolbar cliquez sur Create
Create>Project/Include>Project (ou vous pouvez simplement
appuyer sur le bouton P du clavier). Sélectionnez ces deux lignes de bord et cliquez sur OK.

Cliquez sur la face RIGHT.

Dans Toolbar choisissez la commande Line,, sélectionnez l’un des points projetés des lignes de
bord et créez une ligne de 4mm avec un angle de 55 degrés.
Maintenant sélectionnez le point dans le coin faites glisser à
l’extérieur Ensuite sélectionnez les deux points et dans Toolbar cliquez sur
CONSTRAINTS>Coincident.
Le résultat devrait ressembler à ceci :

Créez une autre ligne en veillant à ce qu'elle démarre à partir du point situé au milieu du côté du

rectangle.

Créez la ligne avec un angle de 90 degrés.

Sélectionnez les points A et B et dans Toolbar cliquer sur
CONSTRAINTS>Horizontal/Vertical. Cela forcera les deux lignes à avoir la même hauteur.
Sélectionnez la ligne au milieu et rendez la une ligne de construction.

Maintenant tracez une autre ligne qui connecte les deux points A et B.
Dans Toolbar cliquez sur Create>Mirror, sélectionnez les lignes 1 et 2 pour Objectset pour
Mirror line sélectionnez la ligne de construction au milieu, puis cliquez sur OK.
Vous obtiendrez un résultat qui ressemble à ceci :

Dans Toolbar cliquez sur Extrude (ou vous pouvez simplement appuyer sur le bouton E du
clavier). Pour le profil, sélectionnez la figure que vous avez venez de dessiner (le trapèze),
dans Extent Type choisissez l’option To Object et pour l’Object sélectionnez le côté parallèle.
Ensuite cliquez sur OK.
Dans Toolbarcliquez sur ASSEMBLE
ASSEMBLE>New Component. Pour Parent sélectionnez le
Component de racine dans le Browser, et assurez-vous que l’option Activate est cochée.

Ensuite

cliquez sur OK.

Cliquez clic droit sur la face RIGHT du box puis sélectionnez Create Sketch.

Utilisez la commande Project pour projeter les 4 côtés du trapèze

Dans Toolbar sélectionnez MODIFY>Offset (ou vous pouvez simplement appuyer sur le
bouton O du clavier).
Sélectionnez les lignes suivantes et faites un Offset de 0.25mm

Avec l’outil Line tracez une ligne entre les deux points x et y où les lignes projetées et les
lignes de l’ Offsetse croisent.
Cliquez sur FINISH SKETCH .
Dans Toolbar cliquez sur la commande Extrude. Sélectionnez le trapèze que vous avez créé
comme Pofile, changez l’ Extent Type en sélectionnant l’option To Object,puis choisissez la
face de la boite qui est parallèle au trapèze comme Object. Modifiez l’Offset à 0.25 et assurez-
vous que le type de l’Operation est New Body .ensuite, cliquez sur OK.
Et voilà vous obtiendrez un boitier similaire à ceci :

Maintenant nous allons ajouter un support permettant de soulever et fixer la PCB.

Sélectionnez la base de la boite puis avec la commande Project faites projeter ces 4 cercles
Puis, avec la commande Create > Circle > Center Diameter Circle, créez 4 nouveaux cercles
avec les mêmes centres des derniers 4 cercles, mais avec des diamètres plus grands, comme le
montre l’image suivant :

Ensuite, Avec l’outil Extrude créez 4 cylindres avec une hauteur de 8mm.
Avec l’outil Extrude vous pouvez aussi ajouter un trou pour le câble du chargeur, des petites
fentes pour faire circuler l’air à l’intérieur du boitier (pour une meilleure précision du
capteur), un trou pour fixer la couverture du boitier lorsque celui
celui-ci
ci est fermé à l’aide d’une
d
vis…

Voici le résultat final.

Si vous souhaitez examiner ce design en 3D ou bien le télécharger, veuillez accéder au lien

suivant :
[Link]
Mot de passe : pfa2023
 Conclusion

En conclusion, ce tutoriel vise à accompagner les lecteurs à travers toutes les étapes de la
conception d'une application web basée sur le Framework Django. Il couvre à la fois les
aspects matériels et logiciels, en commençant par la description des outils de développement
et des ressources matérielles nécessaires. Ensuite, il explique comment créer l'application web
en utilisant le Framework Django RestApi, en détaillant les fonctionnalités et les étapes de
développement requises, y compris la mise en place d'alarmes par mail et Whatsapp pour
notifier les utilisateurs.

Le tutoriel poursuit en abordant la réalisation du PCB (circuit imprimé), en expliquant les

étapes clés allant de la conception du schéma électrique à la fabrication du PCB, en mettant
l'accent sur les outils et les bonnes pratiques pour obtenir un PCB fonctionnel et de qualité.

Il traite également de l'installation et de la configuration des dispositifs Arduino pour la

lecture des données, en décrivant comment collecter les données à partir des capteurs et les
envoyer vers l'application web, tout en mettant en avant les bonnes pratiques en matière de
gestion des données et de communication avec l'application.

Le processus de déploiement de l'application web sur Django Anywhere est ensuite détaillé,
en expliquant les étapes nécessaires pour configurer l'environnement d'hébergement,
transférer les fichiers et assurer le bon fonctionnement de l'application en ligne.

Enfin, le tutoriel aborde la réalisation du boîtier physique pour le projet, en présentant

différents outils de CAO pouvant être utilisés pour concevoir et modéliser le boîtier. Il
explique également les étapes nécessaires pour la fabrication du boîtier, en tenant compte des
aspects pratiques et esthétiques.

Dans l'ensemble, ce tutoriel offre un guide complet pour la conception d'une application web
basée sur Django, en couvrant les différents aspects nécessaires pour mener à bien le projet,
allant de la conception matérielle à la réalisation logicielle et à la mise en place de
l'application en ligne.