This commit is contained in:
2026-04-26 17:47:14 +02:00
13 changed files with 572 additions and 121 deletions
@@ -0,0 +1,74 @@
/*
ESP32 + HX711 (Arduino framework)
- DOUT (DT) -> GPIO 4
- SCK -> GPIO 5
- VCC HX711 -> 3V3 (recommandé) ou 5V si module compatible
- GND -> GND
*/
/*
Calibration (méthode simple) : poser une masse connue (ex. 1 kg), lire la valeur affichée, puis ajuster CALIBRATION_FACTOR jusqu’à obtenir la bonne valeur.
Si laffichage part en négatif quand tu ajoutes du poids, inverse le signe du facteur (ou inverse A+/A-).
*/
#include <Arduino.h>
#include "HX711.h"
static const int PIN_DOUT = 4;
static const int PIN_SCK = 5;
HX711 scale;
// Ajuster après calibration
static float CALIBRATION_FACTOR = -7050.0f; // exemple (le signe dépend du câblage)
void waitReadyOrFail(uint32_t timeoutMs = 2000) {
uint32_t start = millis();
while (!scale.is_ready()) {
if (millis() - start > timeoutMs) {
Serial.println("HX711 non prêt (timeout). Vérifier câblage/alimentation.");
delay(1000);
start = millis();
}
delay(5);
}
}
void setup() {
Serial.begin(115200);
delay(200);
// (Optionnel) Fixer explicitement les modes
pinMode(PIN_DOUT, INPUT);
pinMode(PIN_SCK, OUTPUT);
scale.begin(PIN_DOUT, PIN_SCK);
// Si la lib le permet (selon version), choisir gain/canal :
// scale.set_gain(128);
Serial.println("Initialisation HX711...");
waitReadyOrFail();
Serial.println("Tare (ne rien mettre sur la balance)...");
scale.set_scale(); // échelle à 1
scale.tare(20); // moyenne sur 20 mesures
Serial.println("Tare OK.");
scale.set_scale(CALIBRATION_FACTOR);
Serial.println("Lecture en cours. Utiliser une masse étalon pour calibrer.");
}
void loop() {
waitReadyOrFail();
// Moyenne sur N lectures (réduit le bruit)
const int N = 10;
float units = scale.get_units(N);
Serial.print("Poids (unités calibrées) : ");
Serial.println(units, 3);
delay(250);
}
@@ -0,0 +1,107 @@
## HX711 — Amplificateur 24-bits pour cellule de charge
**Type :** Convertisseur analogique-numérique (ADC) différentiel avec amplificateur programmable intégré
**Applications typiques :** balances électroniques, systèmes de pesée, capteurs de force, instrumentation basse fréquence
---
## Caractéristiques principales
* ADC 24 bits à faible bruit, optimisé pour capteurs de pont de Wheatstone
* Amplificateur à gain programmable : **32, 64 ou 128**
* Deux canaux d'entrée différentiels :
* **Canal A :** gain 128 ou 64
* **Canal B :** gain 32
* Fréquences d'échantillonnage : **10 Hz ou 80 Hz**
* Alimentation : **2,6 V à 5,5 V**
* Interface série propriétaire à deux fils (DATA, CLOCK)
* Consommation typique : ~1,5 mA en fonctionnement
* Oscillateur interne (pas de quartz requis)
* Filtre numérique intégré (réjection 50/60 Hz)
---
## Architecture interne
* Amplificateur différentiel faible bruit
* Multiplexeur de canal
* ADC sigma-delta 24 bits
* Régulateur analogique interne
* Oscillateur interne
* Interface série synchrone
---
## Brochage (package SOP-16)
* **VSUP** : alimentation analogique
* **AVDD** : sortie régulateur analogique
* **AGND** : masse analogique
* **VBG** : référence interne
* **INA+, INA-** : entrée différentielle canal A
* **INB+, INB-** : entrée différentielle canal B
* **PD_SCK** : horloge et mise en veille
* **DOUT** : sortie données
* **DVDD** : alimentation logique
* **DGND** : masse logique
* Autres broches : non connectées (selon package)
---
## Fonctionnement
1. Le HX711 amplifie la tension différentielle issue du pont de jauge.
2. Le signal est converti par un ADC sigma-delta 24 bits.
3. Les données sont lues via une interface série synchrone :
* DOUT passe à 0 lorsque la conversion est prête
* 24 impulsions d'horloge lisent la valeur
* 2527 impulsions définissent le gain et le canal suivant
---
## Performances électriques (typique)
* Résolution effective : ~18 à 20 bits (selon bruit)
* Bruit d'entrée (gain 128, 10 Hz) : ~50 nV RMS
* Tension pleine échelle : ±20 mV (gain 128)
* Dérive thermique : faible (adapté métrologie)
---
## Modes de fonctionnement
* **Mode normal :** conversions continues
* **Mode veille :** maintenir PD_SCK à 1 > 60 µs
* **Sélection gain/canal :** nombre d'impulsions après lecture
---
## Avantages
* Très faible coût et intégration minimale
* Pas de composants externes critiques
* Excellente réjection du bruit secteur
* Directement compatible microcontrôleurs (Arduino, ESP, etc.)
---
## Limitations
* Bande passante faible (pesée statique)
* Interface non standard (pas SPI/I²C natif)
* Sensible au routage PCB et au bruit d'alimentation
---
## Cas d'usage courant
* Modules de pesée avec cellules 1 kg à plusieurs tonnes
* Balances connectées
* Mesure de force lente
* Projets embarqués IoT de mesure de poids
---
Si nécessaire, fournir un schéma de câblage type avec cellule de charge ou un résumé timing interface.
@@ -0,0 +1,54 @@
# Câblage type HX711 avec cellule de charge (pont de Wheatstone)
[Voir un HX711 — câblage avec cellule de charge 4 fils et un Arduino](https://git.abonnel.fr/cedricAbonnel/notes-techniques/raw/branch/main/notes/technologie/HX711-%20Amplificateur%2024-bits%20pour%20cellule%20de%20charge%20-%20schema%20de%20cablage/charge-arduino-hx711.png)
[Voir Pinout d'un HX711](https://git.abonnel.fr/cedricAbonnel/notes-techniques/raw/branch/main/notes/technologie/HX711-%20Amplificateur%2024-bits%20pour%20cellule%20de%20charge%20-%20schema%20de%20cablage/hx711-pinout.png)
### Principe
Une cellule de charge 4 fils est un pont de Wheatstone complet.
Le HX711 alimente le pont et mesure la très faible tension différentielle produite lors de la déformation.
---
## Correspondance des fils (standard le plus courant)
| Cellule de charge | Fonction | HX711 |
| ----------------- | ----------------- | ----- |
| Rouge | Excitation + (E+) | E+ |
| Noir | Excitation - (E-) | E- |
| Blanc | Signal - (S-) | A- |
| Vert | Signal + (S+) | A+ |
⚠️ Les couleurs peuvent varier selon le fabricant → toujours vérifier la fiche technique.
---
## Connexion HX711 → microcontrôleur
| HX711 | Rôle | MCU (exemple) |
| ------------ | -------------------- | ------------- |
| VCC | Alimentation 3,3-5 V | 3V3 ou 5V |
| GND | Masse | GND |
| DT (DOUT) | Données | GPIO entrée |
| SCK (PD_SCK) | Horloge | GPIO sortie |
---
## Schéma fonctionnel simplifié
Cellule de charge
→ pont de Wheatstone alimenté par E+ / E-
→ sortie différentielle S+ / S-
→ amplification + conversion HX711
→ données numériques vers microcontrôleur
---
## Bonnes pratiques de câblage
* Utiliser des fils courts et torsadés pour S+ / S-
* Éloigner du bruit (alims à découpage, relais)
* Plan de masse propre si PCB
* Stabilisation mécanique de la cellule avant calibration
* Effectuer une calibration logicielle (tare + facteur d'échelle)
Binary file not shown.

After

Width:  |  Height:  |  Size: 402 KiB

@@ -0,0 +1,38 @@
## Pinout VL53L1X (module breakout standard)
[Voir un cablage d'un VL53L1X](https://git.abonnel.fr/cedricAbonnel/notes-techniques/raw/branch/main/notes/technologie/VL53L1X%20-%20catpeur%20de%20distance/vl53l1x-arduino-calbage.png)
### Brochage principal (modules 6 pins les plus courants)
| Pin | Type | Fonction |
| --------------- | ------------ | ------------------------------------------------ |
| **VIN / VCC** | Alimentation | Entrée alimentation (≈ 2.6 V à 5 V selon module) |
| **GND** | Alimentation | Masse |
| **SDA** | I²C | Données bus I²C |
| **SCL** | I²C | Horloge bus I²C |
| **XSHUT** | Contrôle | Mise en veille (actif à l'état bas) |
| **GPIO1 / INT** | Sortie | Interruption (data ready) |
Ces six signaux constituent le brochage typique des cartes VL53L1X, qui communiquent exclusivement via I²C avec une adresse par défaut **0x29**. ([docs.cirkitdesigner.com][1])
---
### Rôle des pins optionnels
* **XSHUT**
Permet d'éteindre le capteur ou de gérer plusieurs capteurs sur le même bus (reset individuel). ([Wolles Elektronikkiste][2])
* **GPIO1**
Sortie interruption indiquant qu'une mesure est prête (non obligatoire si lecture en polling). ([Wolles Elektronikkiste][2])
---
### Rappel sur le composant nu (IC)
Le circuit intégré interne possède davantage de broches (alimentation analogique, VCSEL, I²C, etc.), mais sur les modules breakout elles sont déjà câblées et non accessibles. ([STMicroelectronics][3])
---
[1]: https://docs.cirkitdesigner.com/component/9511d34f-a84c-471f-9b93-2be16516a555/vl53l1x?utm_source=chatgpt.com "How to Use VL53L1X: Examples, Pinouts, and Specs"
[2]: https://wolles-elektronikkiste.de/en/vl53l0x-and-vl53l1x-tof-distance-sensors?utm_source=chatgpt.com "VL53L0X and VL53L1X - ToF distance sensors"
[3]: https://www.st.com/resource/en/datasheet/vl53l1x.pdf?utm_source=chatgpt.com "Datasheet - VL53L1X"
@@ -0,0 +1,86 @@
## VL53L1X — Datasheet
### Présentation générale
Le **VL53L1X** est un capteur de distance **Time-of-Flight (ToF)** miniature développé par STMicroelectronics. Il mesure la distance en calculant le temps de trajet d'impulsions laser infrarouges réfléchies par la cible. Cette technologie permet une mesure absolue indépendante de la couleur ou de la texture de l'objet. ([STMicroelectronics][1])
---
## Caractéristiques principales
* Technologie : Time-of-Flight (FlightSense)
* Source lumineuse : laser infrarouge 940 nm classe 1 (œil-safe)
* Portée maximale : jusqu'à 4 m
* Distance minimale : ≈ 4 cm
* Fréquence de mesure : jusqu'à 50 Hz
* Résolution : ~1 mm
* Champ de vision typique : ~27° (réductible via ROI)
* Interface : I²C (jusqu'à 400 kHz) ([All Datasheet][2])
---
## Modes de distance
Le capteur propose plusieurs modes pour adapter portée et robustesse :
* **Short** : portée plus courte, meilleure immunité à la lumière ambiante
* **Medium** : compromis portée / vitesse
* **Long** : portée maximale jusqu'à ~4 m ([STMicroelectronics][3])
---
## Spécifications électriques
* Tension d'alimentation typique : ~2.6 V à 3.5 V (IC)
* Modules avec régulateur : 2.6 V à 5.5 V
* Courant actif typique : ~1525 mA
* Consommation faible possible en mode ULP (< 100 µA) ([Pololu][4])
---
## Architecture interne
Le module intègre :
* Émetteur laser VCSEL 940 nm
* Récepteur SPAD (Single Photon Avalanche Diode)
* Microcontrôleur interne avec firmware de traitement
* Filtre IR et optique intégrée ([STMicroelectronics][1])
---
## Fonctions avancées
* ROI programmable (réduction ou déplacement du champ de vision)
* Multizone logicielle
* Détection de présence / gestes 1D
* Compatibilité pin-to-pin avec VL53L0X ([All Datasheet][2])
---
## Dimensions du composant
* Boîtier IC : environ **4.9 x 2.5 x 1.56 mm** ([All Datasheet][2])
---
## Applications typiques
* Robotique (évitement d'obstacles)
* Domotique et détection de présence
* Autofocus caméra
* Mesure de niveau ou de distance industrielle ([waveshare.com][5])
---
## Lien vers la fiche officielle
* [Télécharger le datasheet ST officiel](https://www.st.com/resource/en/datasheet/vl53l1x.pdf?utm_source=chatgpt.com)
[1]: https://www.st.com/en/imaging-and-photonics-solutions/vl53l1x.html?utm_source=chatgpt.com "VL53L1X | Product"
[2]: https://www.alldatasheet.fr/datasheet-pdf/pdf/1419071/STMICROELECTRONICS/VL53L1X.html?utm_source=chatgpt.com "VL53L1X Fiches technique(PDF) - STMicroelectronics"
[3]: https://www.st.com/resource/en/datasheet/vl53l1x.pdf?utm_source=chatgpt.com "Datasheet - VL53L1X"
[4]: https://www.pololu.com/product/3415?utm_source=chatgpt.com "VL53L1X Time-of-Flight Distance Sensor Carrier with ..."
[5]: https://www.waveshare.com/vl53l1x-distance-sensor.htm?utm_source=chatgpt.com "VL53L1X ToF Distance Ranging Sensor, Ranging up to 4m"
Binary file not shown.

After

Width:  |  Height:  |  Size: 389 KiB

@@ -0,0 +1,53 @@
#include <Wire.h>
#include <Adafruit_VL6180X.h>
Adafruit_VL6180X vl = Adafruit_VL6180X();
// I2C ESP32 (valeurs par défaut fréquentes)
static const int I2C_SDA = 21;
static const int I2C_SCL = 22;
void setup() {
Serial.begin(115200);
delay(200);
// Init I2C (ESP32 permet de choisir les pins)
Wire.begin(I2C_SDA, I2C_SCL);
Wire.setClock(400000); // 400 kHz
Serial.println("Init VL6180X...");
if (!vl.begin()) {
Serial.println("Erreur: VL6180X non detecte sur le bus I2C.");
Serial.println("Verifier: cablage, adresse I2C, alimentation, pull-ups.");
while (true) delay(1000);
}
Serial.println("VL6180X OK.");
}
void loop() {
// Distance en mm
uint8_t range = vl.readRange();
// Code de statut (0 = OK)
uint8_t status = vl.readRangeStatus();
// ALS (luminosite). Paramètre = gain (ex: VL6180X_ALS_GAIN_5)
// Tu peux ajuster le gain suivant ton environnement.
float lux = vl.readLux(VL6180X_ALS_GAIN_5);
if (status == VL6180X_ERROR_NONE) {
Serial.print("Distance: ");
Serial.print(range);
Serial.print(" mm");
} else {
Serial.print("Distance: ERR status=");
Serial.print(status);
}
Serial.print(" | Lux: ");
Serial.println(lux, 2);
delay(200);
}
@@ -0,0 +1,13 @@
Voici un exemple complet avec un **ESP32** et un **VL6180X** en **I²C**, en environnement **Arduino** (PlatformIO ou Arduino IDE). Le code lit la distance (mm) et la luminosité ambiante (ALS).
Câblage typique : VL6180X VDD→3V3, GND→GND, SDA→GPIO21, SCL→GPIO22. Si ton module VL6180X a une entrée “VIN”, tu peux parfois lalimenter en 5 V (régulateur intégré), mais les lignes I²C doivent rester compatibles 3,3 V (la plupart des breakouts gèrent ça, sinon il faut un level shifter).
### Code Arduino (ESP32 + Adafruit_VL6180X)
Voir le fichier [Code Arduino (ESP32 + Adafruit_VL6180X)](https://git.abonnel.fr/cedricAbonnel/notes-techniques/raw/branch/main/notes/technologie/VL6180X%20-%20catpeur%20de%20distance%20-%20code.c)
Remarques pratiques :
* Si tu as plusieurs capteurs VL6180X sur le même bus, il faut gérer la broche **CE/XSHUT** (selon module) pour démarrer un capteur à la fois et changer son adresse I²C (ce capteur le permet).
* Si tu vois “non détecté”, la cause la plus fréquente est labsence de pull-ups I²C (certains modules en ont déjà), un câblage SDA/SCL inversé, ou un module alimenté en 5 V avec I²C non compatible 3,3 V.
@@ -0,0 +1,80 @@
## VL6180X — Fiche technique
### Description générale
Le **VL6180X** est un capteur de distance à **temps de vol (ToF)** développé par STMicroelectronics. Il intègre un émetteur laser infrarouge, un récepteur et un traitement interne permettant de mesurer la distance absolue indépendamment de la réflectivité de la cible.
Il inclut également un capteur de luminosité ambiante.
---
## Caractéristiques principales
* Technologie : Time-of-Flight (laser IR 850 nm)
* Portée typique : 0 à 100 mm (jusqu'à ~200 mm selon conditions)
* Résolution distance : 1 mm
* Fréquence de mesure : jusqu'à ~10-50 Hz (configurable)
* Capteur ALS (Ambient Light Sensor) intégré
* Interface : I²C (jusqu'à 400 kHz)
* Tension d'alimentation :
* VDD : 2.6 à 3.5 V
* I/O : 1.8 à 3.3 V
* Consommation typique :
* Actif : ~20 mA (laser actif)
* Veille : < 5 µA
---
## Fonctions intégrées
* Mesure de distance absolue indépendante de la couleur
* Compensation de la lumière ambiante
* Filtrage et traitement du signal embarqué
* Interruptions configurables (seuil distance / lumière)
* Calibration interne
---
## Brochage principal (boîtier LGA)
* VIN / VDD : alimentation
* GND : masse
* SDA : données I²C
* SCL : horloge I²C
* GPIO0 / CE : enable / interruption
* GPIO1 : interruption programmable
---
## Performances typiques
| Paramètre | Valeur |
| ---------------------------- | ----------------------- |
| Précision | ±3 mm (typique < 50 mm) |
| Champ de vision | ~25° |
| Temps de mesure | ~10 ms |
| Sensibilité lumière ambiante | jusqu'à ~100 klux |
---
## Applications typiques
* Détection de proximité
* Interfaces gestuelles
* Robotique courte portée
* Détection d'obstacle
* IoT / domotique
* Réglage automatique d'écran (ALS)
---
## Avantages
* Mesure indépendante de la couleur ou texture
* Très faible consommation
* Intégration simple (pas de traitement externe complexe)
* Format compact
+56 -118
View File
@@ -1,165 +1,103 @@
#!/bin/bash #!/bin/bash
# Basé sur un travail de Cédric Abonnel / Cédrix sous licence CC BY-NC 4.0 # Basé sur un travail de Cédric Abonnel / Cédrix sous licence CC BY-NC 4.0
# Importer les fonctions communes
source "$(dirname "$0")/../common/common_utils.sh" source "$(dirname "$0")/../common/common_utils.sh"
# Vérifier si le script est exécuté en root
check_root check_root
# Définition des couleurs pour un affichage clair
GREEN="\e[32m" GREEN="\e[32m"
YELLOW="\e[33m" YELLOW="\e[33m"
RED="\e[31m" RED="\e[31m"
RESET="\e[0m" RESET="\e[0m"
echo -e "${YELLOW}Mise à jour des paquets...${RESET}" echo -e "${YELLOW}Mise à jour du système...${RESET}"
apt update && apt upgrade -y || { echo -e "${RED}Échec de la mise à jour des paquets${RESET}"; exit 1; } apt update && apt upgrade -y
# Détection de la version de Debian
VERSION=$(lsb_release -sc) VERSION=$(lsb_release -sc)
SUPPORTED_VERSIONS=("buster" "bullseye" "bookworm") SUPPORTED_VERSIONS=("trixie")
TIMEZONE=$(timedatectl show --value --property=Timezone) TIMEZONE=$(timedatectl show --value --property=Timezone)
TIMEZONE=${TIMEZONE:-UTC}
if [[ ! " ${SUPPORTED_VERSIONS[@]} " =~ " ${VERSION} " ]]; then if [[ ! " ${SUPPORTED_VERSIONS[@]} " =~ " ${VERSION} " ]]; then
echo -e "${RED}Version de Debian non supportée : $VERSION${RESET}" echo -e "${RED}Version non supportée : $VERSION${RESET}"
exit 1 exit 1
fi fi
echo -e "${GREEN}Version de Debian détectée : $VERSION${RESET}" # Dépôt Sury (Format moderne avec signed-by pour Trixie)
# Vérification de l'existence du dépôt Sury
if ! grep -q "packages.sury.org" /etc/apt/sources.list.d/php.list 2>/dev/null; then if ! grep -q "packages.sury.org" /etc/apt/sources.list.d/php.list 2>/dev/null; then
echo -e "${YELLOW}Ajout du dépôt Sury pour PHP...${RESET}" apt install -y ca-certificates apt-transport-https curl
apt install -y ca-certificates apt-transport-https software-properties-common || { echo -e "${RED}Échec de l'installation des paquets nécessaires${RESET}"; exit 1; } curl -sSLo /usr/share/keyrings/deb.sury.org-php.gpg https://packages.sury.org/php/apt.gpg
wget -qO /etc/apt/trusted.gpg.d/php.gpg https://packages.sury.org/php/apt.gpg || { echo -e "${RED}Échec du téléchargement de la clé GPG de Sury${RESET}"; exit 1; } echo "deb [signed-by=/usr/share/keyrings/deb.sury.org-php.gpg] https://packages.sury.org/php/ $VERSION main" > /etc/apt/sources.list.d/php.list
echo "deb https://packages.sury.org/php/ $VERSION main" | tee /etc/apt/sources.list.d/php.list
apt update apt update
else
echo -e "${GREEN}Le dépôt Sury est déjà installé.${RESET}"
fi fi
# Définition de la version PHP souhaitée
PHP_VERSION="8.3" PHP_VERSION="8.3"
echo -e "${YELLOW}Installation de PHP $PHP_VERSION...${RESET}"
PHP_INI_CLI="/etc/php/${PHP_VERSION}/cli/php.ini"
PHP_INI_APACHE="/etc/php/${PHP_VERSION}/apache2/php.ini"
# Vérification de l'installation de PHP
echo -e "${YELLOW}Installation de PHP $PHP_VERSION et des modules courants...${RESET}"
# Base des modules PHP à installer
PHP_MODULES=( PHP_MODULES=(
php${PHP_VERSION} php${PHP_VERSION} php${PHP_VERSION}-cli php${PHP_VERSION}-fpm php${PHP_VERSION}-common
php${PHP_VERSION}-cli php${PHP_VERSION}-curl php${PHP_VERSION}-gd php${PHP_VERSION}-mbstring php${PHP_VERSION}-xml
php${PHP_VERSION}-fpm php${PHP_VERSION}-zip php${PHP_VERSION}-bcmath php${PHP_VERSION}-soap php${PHP_VERSION}-intl
php${PHP_VERSION}-curl php${PHP_VERSION}-readline php${PHP_VERSION}-ldap php${PHP_VERSION}-imagick php${PHP_VERSION}-gmp
php${PHP_VERSION}-gd php${PHP_VERSION}-apcu php${PHP_VERSION}-opcache php${PHP_VERSION}-sqlite3
php${PHP_VERSION}-mbstring
php${PHP_VERSION}-xml
php${PHP_VERSION}-zip
php${PHP_VERSION}-bcmath
php${PHP_VERSION}-soap
php${PHP_VERSION}-intl
php${PHP_VERSION}-readline
php${PHP_VERSION}-ldap
php${PHP_VERSION}-imagick
php${PHP_VERSION}-exif
php${PHP_VERSION}-gmp
php${PHP_VERSION}-apcu
php${PHP_VERSION}-opcache
php${PHP_VERSION}-sqlite3
) )
# Vérification MySQL / MariaDB dpkg -l | grep -qE 'mysql-server|mariadb-server' && PHP_MODULES+=(php${PHP_VERSION}-mysql)
if dpkg -l | grep -qE 'mysql-server|mariadb-server'; then dpkg -l | grep -q postgresql && PHP_MODULES+=(php${PHP_VERSION}-pgsql)
echo -e "${GREEN}MySQL/MariaDB détecté. Ajout du module php-mysql.${RESET}"
PHP_MODULES+=(php${PHP_VERSION}-mysql)
fi
# Vérification PostgreSQL apt install -y "${PHP_MODULES[@]}"
if dpkg -l | grep -q postgresql; then
echo -e "${GREEN}PostgreSQL détecté. Ajout du module php-pgsql.${RESET}"
PHP_MODULES+=(php${PHP_VERSION}-pgsql)
fi
# Installation des modules PHP # 1. Optimisation des fichiers php.ini (CLI, FPM, Apache)
echo -e "${GREEN}Installation des modules PHP...${RESET}" for INI in "/etc/php/${PHP_VERSION}/fpm/php.ini" "/etc/php/${PHP_VERSION}/cli/php.ini" "/etc/php/${PHP_VERSION}/apache2/php.ini"; do
apt install -y "${PHP_MODULES[@]}" || { if [ -f "$INI" ]; then
echo -e "${RED}❌ Échec de l'installation de PHP ou des modules.${RESET}" sed -i 's/memory_limit = .*/memory_limit = 512M/' "$INI"
exit 1 sed -i 's/upload_max_filesize = .*/upload_max_filesize = 100M/' "$INI"
} sed -i 's/post_max_size = .*/post_max_size = 100M/' "$INI"
sed -i 's/max_execution_time = .*/max_execution_time = 300/' "$INI"
sed -i "s|^;*date.timezone =.*|date.timezone = ${TIMEZONE}|" "$INI"
fi
done
# Vérification si Apache est installé et installation du module PHP si nécessaire # 2. Optimisation OPcache (incluant le JIT pour PHP 8.3)
if systemctl list-units --type=service --all | grep -q "apache2.service"; then OPCACHE_INI="/etc/php/${PHP_VERSION}/fpm/conf.d/10-opcache.ini"
echo -e "${YELLOW}Apache détecté. Installation de libapache2-mod-php${RESET}"
apt install -y libapache2-mod-php$PHP_VERSION || { echo -e "${RED}Échec de l'installation de libapache2-mod-php${RESET}"; exit 1; }
echo -e "${YELLOW}Redémarrage d'Apache...${RESET}"
systemctl restart apache2 || { echo -e "${RED}Échec du redémarrage d'Apache${RESET}"; exit 1; }
fi
# Configuration de PHP-FPM si ce n'est pas déjà fait
PHP_INI="/etc/php/$PHP_VERSION/fpm/php.ini"
PHP_INI_DIR="/etc/php/${PHP_VERSION}/fpm/conf.d"
if grep -q "memory_limit = 512M" "$PHP_INI"; then
echo -e "${GREEN}Configuration de PHP-FPM déjà optimisée.${RESET}"
else
echo -e "${YELLOW}Configuration de PHP-FPM...${RESET}"
sed -i 's/memory_limit = .*/memory_limit = 512M/' "$PHP_INI"
sed -i 's/upload_max_filesize = .*/upload_max_filesize = 100M/' "$PHP_INI"
sed -i 's/post_max_size = .*/post_max_size = 100M/' "$PHP_INI"
sed -i 's/max_execution_time = .*/max_execution_time = 300/' "$PHP_INI"
echo -e "${YELLOW}Redémarrage de PHP-FPM...${RESET}"
systemctl restart php$PHP_VERSION-fpm || { echo -e "${RED}Échec du redémarrage de PHP-FPM${RESET}"; exit 1; }
fi
# Configuration OPCache
OPCACHE_INI="${PHP_INI_DIR}/10-opcache.ini"
cat > "$OPCACHE_INI" <<EOF cat > "$OPCACHE_INI" <<EOF
; Configuration OPcache optimisée
opcache.enable=1 opcache.enable=1
opcache.memory_consumption=128 opcache.enable_cli=1
opcache.memory_consumption=256
opcache.interned_strings_buffer=16 opcache.interned_strings_buffer=16
opcache.max_accelerated_files=10000 opcache.max_accelerated_files=20000
opcache.revalidate_freq=60 opcache.revalidate_freq=60
opcache.fast_shutdown=1 opcache.fast_shutdown=1
opcache.enable_cli=1 ; Optimisation JIT pour PHP 8.3
opcache.jit=tracing
opcache.jit_buffer_size=100M
EOF EOF
echo "==> Fichier $OPCACHE_INI mis à jour."
# Configuration APCu # 3. Optimisation APCu
APCU_INI="${PHP_INI_DIR}/20-apcu.ini" APCU_INI="/etc/php/${PHP_VERSION}/fpm/conf.d/20-apcu.ini"
cat > "$APCU_INI" <<EOF cat > "$APCU_INI" <<EOF
; Configuration APCu optimisée
apc.enabled=1 apc.enabled=1
apc.shm_size=64M apc.shm_size=64M
apc.ttl=7200 apc.ttl=7200
apc.enable_cli=0 apc.enable_cli=0
EOF EOF
echo "==> Fichier $APCU_INI mis à jour."
# Définir la timezone PHP pour CLI et Apache # 4. Optimisation du Pool PHP-FPM (www.conf)
sed -i "s|^;*date.timezone =.*|date.timezone = ${TIMEZONE}|" "${PHP_INI_CLI}" FPM_POOL="/etc/php/${PHP_VERSION}/fpm/pool.d/www.conf"
sed -i "s|^;*date.timezone =.*|date.timezone = ${TIMEZONE}|" "${PHP_INI_APACHE}" if [ -f "$FPM_POOL" ]; then
echo -e "${YELLOW}Optimisation des processus FPM...${RESET}"
# Test de la configuration Apache sed -i 's/^pm = .*/pm = dynamic/' "$FPM_POOL"
if systemctl is-active --quiet apache2; then sed -i 's/^pm.max_children = .*/pm.max_children = 80/' "$FPM_POOL"
read -rp "Voulez-vous tester le support de PHP par Apache ? (o/n) : " test_php sed -i 's/^pm.start_servers = .*/pm.start_servers = 10/' "$FPM_POOL"
if [[ "$test_php" =~ ^[oOyY]$ ]]; then sed -i 's/^pm.min_spare_servers = .*/pm.min_spare_servers = 5/' "$FPM_POOL"
echo -e "${YELLOW}Vérification du support de PHP par Apache...${RESET}" sed -i 's/^pm.max_spare_servers = .*/pm.max_spare_servers = 20/' "$FPM_POOL"
echo "<?php phpinfo(); ?>" > /var/www/html/info.php sed -i 's/^;pm.max_requests = .*/pm.max_requests = 1000/' "$FPM_POOL"
chown www-data:www-data /var/www/html/info.php
chmod 644 /var/www/html/info.php
echo -e "${GREEN}Vous pouvez tester PHP en accédant à : http://<IP_SERVEUR>/info.php${RESET}"
else
echo -e "${YELLOW}Test PHP annulé.${RESET}"
fi
else
echo -e "${RED}Le service Apache n'est pas actif.${RESET}"
fi fi
echo -e "${GREEN}Installation terminée avec succès ! 🚀${RESET}" # Finalisation
systemctl restart php${PHP_VERSION}-fpm
if systemctl list-units --type=service --all | grep -q "apache2.service"; then
apt install -y libapache2-mod-php${PHP_VERSION}
systemctl restart apache2
fi
echo -e "${GREEN}Installation et optimisations PHP $PHP_VERSION terminées ! 🚀${RESET}"
+11 -3
View File
@@ -29,10 +29,10 @@ echo ""
echo "🔐 Génération d'un mot de passe fort pour le rôle '$ROLE_NAME'..." echo "🔐 Génération d'un mot de passe fort pour le rôle '$ROLE_NAME'..."
ROLE_PASSWORD=$(generate_token 20) ROLE_PASSWORD=$(generate_token 20)
# Exécution des commandes SQL de manière sécurisée # Générer un fichier SQL temporaire pour la vérification + création
echo "🔎 Exécution des commandes SQL avec sudo..." SQL_FILE=$(mktemp)
sudo -u postgres env PGPASSWORD="${POSTGRES_PASSWORD}" psql -v ON_ERROR_STOP=1 -U postgres -h localhost <<EOF cat <<EOF > "$SQL_FILE"
DO \$\$ DO \$\$
BEGIN BEGIN
IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = '${ROLE_NAME}') THEN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = '${ROLE_NAME}') THEN
@@ -45,6 +45,14 @@ END
\$\$; \$\$;
EOF EOF
chmod 644 "$SQL_FILE"
# Une seule exécution de psql via sudo avec mot de passe PostgreSQL exporté
echo "🔎 Exécution des commandes SQL avec sudo..."
sudo -u postgres bash -c "PGPASSWORD='${POSTGRES_PASSWORD}' psql -v ON_ERROR_STOP=1 -f '${SQL_FILE}'"
rm -f "$SQL_FILE"
# Affichage des identifiants si création # Affichage des identifiants si création
echo "" echo ""
echo "-------------------------------------------" echo "-------------------------------------------"