⚡ TempoBot

Smart electricity consumption management with EDF Tempo calendar

---

📋 Table of Contents

• About
• Features
• Architecture
• Technologies Used
• Prerequisites
• Installation
• Configuration
• Usage
• Project Structure
• Documentation
• Contributing
• License

---

🎯 About

TempoBot is a complete solution for intelligently managing your electrical device consumption by leveraging the EDF Tempo calendar. The project combines:

• 🤖 A Python bot/server : Automates control of smart plugs via Tasmota, MQTT, and Firebase
• 📱 A native iOS application : SwiftUI interface to configure and monitor your plugs in real-time

The system automatically detects the Tempo day color (blue, white, red) and adjusts electricity consumption based on pricing, while allowing fine-grained schedule customization.

---

✨ Features

🔄 Automatic EDF Tempo Calendar Tracking

• ✅ Automatic detection of the day's color (blue, white, red)
• ✅ J+1 forecast for optimal planning
• ✅ Remaining days counter per color for the year

⚙️ Smart Plug Control

• ✅ Automatic on/off based on Tempo color
• ✅ Peak/off-peak hours management per color
• ✅ Custom schedules by day of the week
• ✅ Manual override with one click from the iOS app

🔌 Tasmota Integration

• ✅ Remote control via MQTT
• ✅ Real-time synchronization with Firebase
• ✅ Simplified configuration from the iOS app

📱 Native iOS Application

• ✅ Modern and intuitive SwiftUI interface
• ✅ Secure Firebase authentication
• ✅ Simplified Wi-Fi and MQTT configuration
• ✅ Real-time plug status
• ✅ Complete schedule management

🔔 Notifications

• ✅ Discord integration for alerts and notifications
• ✅ Error and crash handling with retry system

---

🏗️ Architecture

┌─────────────────────────────────────────────────────────────┐
│                      TempoBot Ecosystem                      │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  ┌──────────────┐      ┌──────────────┐      ┌──────────┐  │
│  │   iOS App    │◄─────►│   Firebase   │◄─────►│  Python  │  │
│  │  (SwiftUI)   │      │  Realtime DB │      │   Bot    │  │
│  └──────┬───────┘      └──────┬───────┘      └─────┬────┘  │
│         │                      │                    │        │
│         │                      │                    │        │
│         └──────────────────────┼────────────────────┘        │
│                                │                              │
│                         ┌──────▼──────┐                      │
│                         │   Tasmota   │                      │
│                         │  (MQTT)     │                      │
│                         └─────────────┘                      │
│                                                               │
└─────────────────────────────────────────────────────────────┘

Data Flow

1. EDF API → Retrieves the day's Tempo color
2. Python Bot → Processes and updates Firebase
3. Firebase → Synchronizes with the iOS app
4. MQTT → Controls Tasmota plugs
5. Discord → Notifications and alerts (optional)

---

🛠️ Technologies Used

Backend (Python)

Technology	Version	Usage
Python	3.x	Main language
Firebase Admin SDK	Latest	Database management
Discord.py	Latest	Discord notifications
Requests	Latest	EDF Tempo API
MQTT	-	Communication with Tasmota
miniupnpc	Latest	UPnP port forwarding

Frontend (iOS)

Technology	Version	Usage
Swift	5.0+	Main language
SwiftUI	Latest	User interface
Firebase iOS SDK	9.6.0	Authentication & Database
CocoaAsyncSocket	7.6.5	Network communication

Services

• 🔥 Firebase : Authentication, Realtime Database, Analytics
• 📡 MQTT : Communication with Tasmota devices
• 🌐 EDF API : Tempo calendar retrieval

---

📦 Prerequisites

For Python Backend

• Python 3.x installed
• Access to an MQTT server (Mosquitto)
• Firebase account with Realtime Database enabled
• (Optional) Discord bot for notifications

For iOS Application

• Xcode 14.2+ installed
• iOS 16.0+ (simulator or physical device)
• Apple developer account (for device deployment)
• Configured GoogleService-Info.plist file

Hardware

• Tasmota-compatible plug(s)
• Local network access (Wi-Fi)
• UPnP-compatible router (optional, for port forwarding)

---

🚀 Installation

1. Clone the Repository

git clone https://github.com/votre-user/TempoBot.git
cd TempoBot

2. Python Backend Setup

cd Python

# Create a virtual environment (recommended)
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install requests firebase-admin discord.py miniupnpc

3. Firebase Configuration

1. Create a Firebase project on Firebase Console

2. Enable services :

   • ✅ Authentication (Email/Password)
   • ✅ Realtime Database
   • ✅ Analytics (optional)

3. Download configuration files :

   • Python : Service Account JSON → Place in Python/tempobot-406fc-firebase-adminsdk-....json
   • iOS : GoogleService-Info.plist → Add to Xcode project

4. MQTT Configuration

Ensure an MQTT server (Mosquitto) is accessible on your network:

# Install Mosquitto (example on Ubuntu/Debian)
sudo apt-get install mosquitto mosquitto-clients

# Verify the service is active
sudo systemctl status mosquitto

5. iOS Application Setup

1. Open the project in Xcode :

   open iOS/TempoBot.xcodeproj

2. Configure the Bundle Identifier in project settings

3. Add GoogleService-Info.plist to the app :

   • Drag and drop the file into the Xcode project
   • Check "Copy items if needed"

4. Install dependencies (automatically managed by Swift Package Manager)

---

⚙️ Configuration

Python Bot Configuration

Edit Python/tasmota.py and adjust parameters:

# MQTT server IP address (if different)
# By default, uses mosquitto_pub command line

# Discord configuration (optional)
DISCORD_TOKEN = "your_discord_token"
CHANNEL_ID = 1120669437528379464  # Your Discord channel ID

Firebase Realtime Database Configuration

Database structure:

{
  "data": {
    "date": "2024/01/15",
    "dateJ1": "2024/01/16",
    "couleurJ": "TEMPO_BLEU",
    "couleurJ1": "TEMPO_BLANC",
    "Jrest_bleu": 300,
    "Jrest_blanc": 43,
    "Jrest_rouge": 22,
    "Pleines_creuses": "pleines",
    "users": {
      "<uid>": {
        "prises": {
          "<id_prise>": {
            "nom": "Living Room Plug",
            "isOn": false,
            "isManualOn": null,
            "creuses_bleu": true,
            "creuses_blanc": false,
            "creuses_rouge": false,
            "pleines_bleu": true,
            "pleines_blanc": true,
            "pleines_rouge": false,
            "Lundi": "08:00-12:00",
            "Mardi": null,
            ...
          }
        }
      }
    }
  }
}

Firebase Security Rules

Configure security rules in Firebase Console:

{
  "rules": {
    "data": {
      ".read": "auth != null",
      ".write": "auth != null",
      "users": {
        "$uid": {
          ".read": "$uid === auth.uid",
          ".write": "$uid === auth.uid"
        }
      }
    }
  }
}

---

💻 Usage

Start the Python Bot

cd Python
python tasmota.py

The bot will:

1. Connect to Firebase
2. Retrieve the day's Tempo color from the EDF API
3. Update the Firebase database
4. Control Tasmota plugs according to configured rules
5. Send Discord notifications (if configured)

Using the iOS App

1. Launch the application from Xcode (⌘+R) or install on a device
2. Create an account or sign in with Firebase Auth
3. Add a plug :
   • Detect the tasmota-* SSID
   • Connect to the plug's Wi-Fi
   • Configure IP address and MQTT settings
4. Configure schedules :
   • Choose peak/off-peak periods per Tempo color
   • Define custom schedules by day
   • Activate manual override if needed

Example Scripts

Port Forwarding (UPnP)

cd Python
python port_forwarding.py

Firebase Connection Test

cd Python
python testdtata.py

---

📁 Project Structure

TempoBot/
│
├── 📱 iOS/
│   ├── TempoBot/
│   │   ├── 📂 Authentification/
│   │   │   ├── Login.swift
│   │   │   ├── SignUp.swift
│   │   │   └── CompteView.swift
│   │   │
│   │   ├── 📂 Connexion/
│   │   │   ├── ConnexionReseauView.swift
│   │   │   ├── ConnexionReseau2View.swift
│   │   │   └── NouvellePriseView.swift
│   │   │
│   │   ├── 📂 Prise/
│   │   │   ├── HeuresPickerView.swift
│   │   │   ├── IsManualOnView.swift
│   │   │   └── InfoPriseView.swift
│   │   │
│   │   ├── 📂 Reseau/
│   │   │   ├── NetworkDiscovery.swift
│   │   │   └── ConnectionStateChecker.swift
│   │   │
│   │   ├── ContentView.swift
│   │   ├── MainPage.swift
│   │   ├── PriseList.swift
│   │   ├── ReadDatas.swift
│   │   └── TempoBotApp.swift
│   │
│   └── TempoBot.xcodeproj/
│
├── 🐍 Python/
│   ├── tasmota.py              # Main bot script
│   ├── port_forwarding.py      # UPnP port forwarding script
│   ├── test.py                 # Automation example
│   ├── testdtata.py            # Firebase read/write example
│   └── tempobot-406fc-firebase-adminsdk-....json
│
├── 📄 README.md
└── 📄 .deepsource.toml

Key Files

File	Description
Python/tasmota.py	Main script handling Tempo & Tasmota logic
iOS/TempoBot/TempoBotApp.swift	iOS application entry point
iOS/TempoBot/ContentView.swift	Authentication and navigation management
iOS/TempoBot/MainPage.swift	Main page after authentication
Python/port_forwarding.py	UPnP port forwarding script

---

📚 Documentation

EDF Tempo API

The bot uses EDF's public API to retrieve Tempo information:

• Day color : https://particulier.edf.fr/services/rest/referentiel/searchTempoStore?dateRelevant=YYYY-MM-DD
• Remaining days : https://particulier.edf.fr/services/rest/referentiel/getNbTempoDays?TypeAlerte=TEMPO

Tasmota MQTT Topics

The bot uses standard Tasmota MQTT topics:

• Command : cmnd/<device_id>/power
• Status : stat/<device_id>/POWER

Firebase Architecture

See the Firebase Configuration section for the complete database structure.

---

🤝 Contributing

Contributions are welcome! To contribute:

1. Fork the project
2. Create a feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

Guidelines

• Follow existing code conventions
• Add comments for complex code
• Test your changes before submitting a PR
• Update documentation if necessary

---

📄 License

This project is licensed under the MIT License. See the LICENSE file for more details.

---

🙏 Acknowledgments

• Tasmota for the open-source firmware
• EDF for the Tempo API
• Firebase for backend services
• The open-source community

---

Made with ❤️ to optimize your electricity consumption

⬆ Back to top