import network
import time
from dadjoke_fetcher import DadJokeFetcher
from facts_fetcher import FactsFetcher
from blinker import Blinker

fetcher1 = DadJokeFetcher()
fetcher2 = FactsFetcher()
blinker = Blinker(2)

def connect_to_wifi(ssid, password):
    station = network.WLAN(network.STA_IF)
    station.active(True)
    station.connect(ssid, password)
    
    while not station.isconnected():
        print("Connecting to WiFi...")
        blinker.blink(2, 0.3, 0.3)
    
    print("Connected to WiFi")
    blinker.blink(4, 0.4, 0.3)

SSID = "Wokwi-GUEST"
PASSWORD = ""
connect_to_wifi(SSID, PASSWORD)

while True:
    fetcher1.get_joke()
    time.sleep(5)
    fetcher2.get_fact()
    time.sleep(5)



main.py

diagram.json

import machine
import time

class Blinker:
    
    def __init__(self, pin=2):
        self.led = machine.Pin(pin, machine.Pin.OUT)
        
    def blink(self, num_blinks, on_duration, off_duration):
        for _ in range(num_blinks):
            self.led.value(not self.led.value())
            time.sleep(on_duration)
            self.led.value(not self.led.value())
            time.sleep(off_duration)


blinker.py

import urequests as requests
import json
import os
import machine
import time
import random
from blinker import Blinker

PATH = "dadjokes.json"
MAX_SIZE = 128 * 1024
blinker = Blinker(2)

class DadJokeFetcher:
    def __init__(self):
        self.filepath = PATH

    def get_random_dadjoke(self):
        url = "https://icanhazdadjoke.com/"
        headers = {"Accept": "application/json"}
        try:
            response = requests.get(url, headers=headers)
            if response.status_code == 200:
                data = response.json()
                joke_text = data["joke"]
                joke_details = {
                    "id": data["id"],
                    "joke": data["joke"]
                }
                return joke_text, joke_details
        except:
            pass
        return None, None

    def save_joke_details(self, joke_details):
        try:
            with open(self.filepath, "r") as f:
                jokes = json.load(f)
        except OSError:
            jokes = []

        joke_ids = [joke["id"] for joke in jokes]
        if joke_details["id"] not in joke_ids:
            jokes.append(joke_details)

            while len(json.dumps(jokes)) > MAX_SIZE:
                jokes.pop(0)

            with open(self.filepath, "w") as f:
                json.dump(jokes, f)

    def get_local_joke(self):
        try:
            with open(self.filepath, "r") as f:
                jokes = json.load(f)
            if jokes:
                joke_details = random.choice(jokes)
                return joke_details["joke"], joke_details
        except OSError:
            return None, None

    def get_joke(self):
        joke_text, joke_details = self.get_random_dadjoke()
        if joke_text and joke_details:
            blinker.blink(2, 0.3, 0.5)
            print("Random Dad Joke :")
            print(joke_text)
            self.save_joke_details(joke_details)
        else:
            joke_text, joke_details = self.get_local_joke()
            if joke_text and joke_details:
                blinker.blink(2, 0.5, 0.35)
                print("Random Dad Joke :")
                print(joke_text)
            else:
                blinker.blink(1, 0.25, 0.25)
                print("No jokes available offline.")


dadjoke_fetcher.py

import urequests as requests
import json
import os
import machine
import time
import random
from blinker import Blinker

PATH = "facts.json"
MAX_SIZE = 128 * 1024
blinker = Blinker(2)

class FactsFetcher:
    def __init__(self):
        self.filepath = PATH

    def get_random_fact(self):
        url = "https://uselessfacts.jsph.pl/api/v2/facts/random"
        try:
            response = requests.get(url)
            if response.status_code == 200:
                data = response.json()
                fact_text = data["text"]
                fact_details = {
                    "id": data["id"],
                    "fact": data["text"]
                }
                return fact_text, fact_details
        except:
            pass
        return None, None

    def save_fact_details(self, fact_details):
        try:
            with open(self.filepath, "r") as f:
                facts = json.load(f)
        except OSError:
            facts = []

        fact_ids = [fact["id"] for fact in facts]
        if fact_details["id"] not in fact_ids:
            facts.append(fact_details)

            while len(json.dumps(facts)) > MAX_SIZE:
                facts.pop(0)

            with open(self.filepath, "w") as f:
                json.dump(facts, f)

    def get_local_fact(self):
        try:
            with open(self.filepath, "r") as f:
                facts = json.load(f)
            if facts:
                fact_details = random.choice(facts)
                return fact_details["fact"], fact_details
        except OSError:
            return None, None

    def get_fact(self):
        fact_text, fact_details = self.get_random_fact()
        if fact_text and fact_details:
            blinker.blink(2, 0.3, 0.5)
            print("Random fact :")
            print(fact_text)
            self.save_fact_details(fact_details)
        else:
            fact_text, fact_details = self.get_local_fact()
            if fact_text and fact_details:
                blinker.blink(2, 0.5, 0.35)
                print("Random fact :")
                print(fact_text)
            else:
                blinker.blink(1, 0.25, 0.25)
                print("No facts available offline.")


facts_fetcher.py

dadjokes.json

facts.json

### Project: Multi-Library Call using ESP32 on Wokwi

#### Overview
This project demonstrates the use of an ESP32 microcontroller to fetch dad jokes and fun facts from external sources, displaying them at regular intervals. It uses multiple libraries and modules to achieve this.

#### Components
- **ESP32 Microcontroller**: Handles WiFi connection and data fetching.
- **LED Blinker**: Provides visual feedback during WiFi connection.
- **DadJokeFetcher**: Fetches random dad jokes.
- **FactsFetcher**: Fetches random facts.
- **WiFi Connection**: Connects to WiFi to access the internet for fetching data.

#### Files and Structure
- **main.py**: Main script to control the workflow.
- **blinker.py**: Module to control LED blinking.
- **dadjoke_fetcher.py**: Module to fetch dad jokes.
- **facts_fetcher.py**: Module to fetch facts.
- **dadjokes.json**: JSON file containing dad jokes.
- **facts.json**: JSON file containing facts.
- **diagram.json**: Visual representation of the setup.

#### How It Works
1. **WiFi Connection**: 
   - `connect_to_wifi(ssid, password)`: Connects to WiFi and provides LED feedback.
   - Uses the `network` library to manage connections.
   
2. **Data Fetching**:
   - `DadJokeFetcher.get_joke()`: Fetches a random dad joke.
   - `FactsFetcher.get_fact()`: Fetches a random fact.
   - Alternates between fetching jokes and facts every 5 seconds.

3. **LED Blinker**:
   - `Blinker.blink()`: Controls LED to indicate connection status and data fetching.

#### Usage
1. **Clone the project** from Wokwi and open it in the simulator.
2. **Configure WiFi credentials** in `main.py` (default: `SSID = "Wokwi-GUEST"`, `PASSWORD = ""`).
3. **Run the simulation**: The ESP32 will attempt to connect to WiFi, indicated by the blinking LED.
4. **Fetch and display data**: Once connected, it will fetch and display jokes and facts alternately.

#### Detailed Explanation
- **main.py**:
  - Initializes the `DadJokeFetcher`, `FactsFetcher`, and `Blinker`.
  - Connects to WiFi and uses LED feedback during connection attempts and success.
  - Enters an infinite loop to fetch and display data.

- **blinker.py**:
  - Contains the `Blinker` class to manage LED operations, such as blinking with specific patterns.

- **dadjoke_fetcher.py** and **facts_fetcher.py**:
  - These modules handle API calls or local data retrieval to get dad jokes and facts, respectively.

#### Conclusion
This project serves as a practical example of integrating multiple modules and libraries with an ESP32 for network operations and data fetching. It demonstrates essential IoT concepts such as WiFi connectivity, API interaction, and real-time data processing.
