import network,time,machine,ssd1306,random
from joke_fetcher import JokeFetcher
from facts_fetcher import FactsFetcher
from blinker import Blinker

i2c=machine.I2C(0,scl=machine.Pin(22),sda=machine.Pin(21))
oled=ssd1306.SSD1306_I2C(128,64,i2c)
fetcher1,fetcher2,blinker=FactsFetcher(),JokeFetcher(),Blinker(2)

def connect_wifi(ssid,password):
    machine.freq(160000000);time.sleep(1)
    station=network.WLAN(network.STA_IF);station.active(True)
    attempts,max_attempts,connected=0,5,False
    while attempts<max_attempts:
        try:
            station.connect(ssid,password);print("Connecting to WiFi...")
            if station.isconnected():connected=True;print("Connected to WiFi");blinker.blink(2,0.1,0.15);break
            else:attempts+=1
        except OSError as e:print(f"Error: {e}");attempts+=1
    return connected

def edit_text(text):
    replacements={"…":"...","‘":"'","’":"'","`":"'",""":'"',""":'"',"  ":" ","  ":" ","é":"e"}
    for old,new in replacements.items():text=text.replace(old,new)
    return ' '.join(text.split())

def display_on_oled(t1,t2,clear=False):
    machine.freq(80000000);line_height,lines,loop_count=8,[t2],1
    if clear:oled.fill(0)
    for _ in range(loop_count):
        oled.fill(0);oled.text(t1,0,3,1);oled.text(t2,0,15,1);oled.show();time.sleep(1.35)
        for line in lines:
            for i in range(len(line)*8):oled.fill(0);oled.text(t1,0,3,1);oled.text(line,-i,15,1);oled.show();time.sleep(0.0035)
            time.sleep(0.15)

wifi_connected=connect_wifi("Wokwi-GUEST","")
fetchers=[(fetcher2.get_text,"Here a joke:"),(fetcher1.get_text,"Here a fact:")]

while True:
    machine.freq(160000000);time.sleep(0.5)
    choice,display_text=random.choice(fetchers)
    content=edit_text(choice())
    display_on_oled(display_text,f"{content}",clear=True)
    machine.freq(160000000);time.sleep(0.5)


main.py

diagram.json

facts.json

from micropython import const
import framebuf

SCT=const(0x81);SEO=const(0xA4);SNI=const(0xA6);SDP=const(0xAE);SMA=const(0x20)
SCA=const(0x21);SPA=const(0x22);SDSL=const(0x40);SSR=const(0xA0)
SMR=const(0xA8);SCOD=const(0xC0);SDO=const(0xD3);SCPC=const(0xDA)
SDCD=const(0xD5);SPR=const(0xD9);SVD=const(0xDB);SCP=const(0x8D)

class SSD1306(framebuf.FrameBuffer):
    def __init__(s,w,h,ev):
        s.w=w; s.h=h; s.ev=ev; s.p=h//8
        s.b=bytearray(s.p*w)
        super().__init__(s.b,w,h,framebuf.MONO_VLSB)
        s.init()

    def init(s):
        for cmd in (SDP|0x00,SMA,0x00,SDSL|0x00,SSR|0x01,SMR,s.h-1,SCOD|0x08,SDO,0x00,SCPC,0x02 if s.w>2*s.h else 0x12,SDCD,0x80,SPR,0x22 if s.ev else 0xF1,SVD,0x30,SCT,0xFF,SEO,SNI,SCP,0x10 if s.ev else 0x14,SDP|0x01): s.write_cmd(cmd)
        s.fill(0); s.show()

    def pof(s): s.write_cmd(SDP|0x00)
    def pon(s): s.write_cmd(SDP|0x01)
    def con(s,c): s.write_cmd(SCT); s.write_cmd(c)
    def inv(s,i): s.write_cmd(SNI|(i&1))

    def show(s):
        x0=0; x1=s.w-1
        if s.w==64: x0+=32; x1+=32
        s.write_cmd(SCA); s.write_cmd(x0); s.write_cmd(x1); s.write_cmd(SPA); s.write_cmd(0); s.write_cmd(s.p-1)
        s.write_data(s.b)

class SSD1306_I2C(SSD1306):
    def __init__(s,w,h,i2c,a=0x3C,ev=False):
        s.i2c=i2c; s.a=a; s.t=bytearray(2); s.wl=[b"\x40",None]
        super().__init__(w,h,ev)

    def write_cmd(s,c): s.t[0]=0x80; s.t[1]=c; s.i2c.writeto(s.a,s.t)
    def write_data(s,b): s.wl[1]=b; s.i2c.writevto(s.a,s.wl)


ssd1306.py

# README for Random Fact Display using ESP32 and MicroPython

## Overview

This project utilizes an ESP32 microcontroller to display random facts on an OLED screen. It connects to a WiFi network, fetches random facts from an online API, stores them locally, and displays them on the screen. If the internet connection is unavailable, it retrieves facts from the local storage. Additionally, an LED blinks every time a new fact is retrieved and displayed.

## Features

- Connects to a WiFi network.
- Checks internet connectivity.
- Fetches random facts from an online API.
- Stores facts locally in a JSON file.
- Retrieves and displays random facts from local storage if offline.
- Displays facts on an SSD1306 OLED screen with scrolling text.
- Blinks an LED to indicate the retrieval and display of a new fact.

## Hardware Requirements

- ESP32 microcontroller
- SSD1306 OLED display
- LED (optional)
- Resistors and connecting wires

## Software Requirements

- MicroPython installed on the ESP32
- MicroPython libraries:
  - `network`
  - `urequests`
  - `ujson`
  - `uos`
  - `machine`
  - `ssd1306`

## Setup and Installation

### Hardware Connections

1. **OLED Display:**
   - Connect `SCL` to GPIO 22.
   - Connect `SDA` to GPIO 21.
   - Connect `VCC` to 3.3V.
   - Connect `GND` to GND.

2. **LED (optional):**
   - Connect the positive leg (anode) to GPIO 2 (with a current-limiting resistor if necessary).
   - Connect the negative leg (cathode) to GND.

### Software Setup

1. **Install MicroPython on ESP32:**
   - Follow the instructions [here](https://docs.micropython.org/en/latest/esp32/tutorial/intro.html) to install MicroPython on your ESP32.

2. **Upload the code to ESP32:**
   - Save the provided code into a file named `main.py`.
   - Use a tool like [ampy](https://github.com/scientifichackers/ampy) or [Thonny IDE](https://thonny.org/) to upload `main.py` to your ESP32.

3. **Install Required Libraries:**
   - Ensure the `ssd1306` library is available on your ESP32. If not, upload it manually using the same tools.

## Code Explanation

### Key Components

1. **WiFi Connection:**
   - `connect_wifi(ssid, password)`: Connects the ESP32 to the specified WiFi network.

2. **Internet Connectivity Check:**
   - `is_connected_to_internet()`: Pings a public DNS server to check internet connectivity.

3. **Fetch Random Fact:**
   - `get_random_fact(use_online=True)`: Fetches a random fact from an online API if `use_online` is `True`. Otherwise, retrieves a fact from the local JSON file.

4. **Save Fact:**
   - `save_fact(fact_details)`: Saves the fetched fact to a local JSON file, ensuring the file size does not exceed the defined limit.

5. **Display Fact on OLED:**
   - `display_fact_on_oled(fact_text, duration=30)`: Displays the given fact on the OLED screen with scrolling text.

### Main Loop

1. Connect to WiFi using `connect_wifi(ssid, password)`.
2. Continuously check for internet connectivity using `is_connected_to_internet()`.
3. Fetch a random fact using `get_random_fact()`.
4. Blink the LED to indicate fact retrieval.
5. Save the fact using `save_fact(fact_details)`.
6. Display the fact on the OLED screen using `display_fact_on_oled(fact_text, duration=5)`.

## Usage

1. Power up the ESP32.
2. The ESP32 will automatically connect to the predefined WiFi network.
3. It will fetch a random fact and display it on the OLED screen.
4. The LED will blink each time a new fact is retrieved and displayed.
5. If the internet is unavailable, it will fetch a random fact from the local storage.

## Customization

- **Change WiFi Credentials:**
  - Modify `ssid` and `password` variables with your WiFi credentials.

- **Change Display Duration:**
  - Adjust the `duration` parameter in `display_fact_on_oled(fact_text, duration=30)` to change how long each fact is displayed.

- **Modify LED Pin:**
  - Change `LED_PIN` variable to use a different GPIO pin for the LED.

## Troubleshooting

- **WiFi Connection Issues:**
  - Ensure the correct SSID and password are set.
  - Check the signal strength and stability of the WiFi network.

- **OLED Display Issues:**
  - Verify the connections between the ESP32 and the OLED display.
  - Ensure the `ssd1306` library is correctly installed.

- **Fact Retrieval Issues:**
  - Check internet connectivity.
  - Verify the API endpoint is accessible.

## License

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

---

By following this guide, you should be able to set up and run the Random Fact Display project on your ESP32 microcontroller. Enjoy your new source of random knowledge!

Readme.md

import machine,time
class Blinker:
    def __init__(s,p=2):s.l=machine.Pin(p,machine.Pin.OUT);s.l.off()
    def blink(s,n,on,off):
        for _ in range(n):s.l.on();time.sleep(on);s.l.off();time.sleep(off)


blinker.py

import urequests as r,json,os,machine,time,random
from blinker import Blinker
P,MAX,b="facts.json",20*1024,Blinker(2)
class FactsFetcher:
    def __init__(s):s.f=P
    def get_random(s):
        try:
            if random.choice([True,False]):
                d=r.get("https://uselessfacts.jsph.pl/api/v2/facts/random").json()
                return d["text"],{"id":d["id"],"fact":d["text"],"source":"on"}
            else:
                t=r.get("http://numbersapi.com/random").text
                return t,{"id":hash(t),"fact":t,"source":"on"}
        except:return None,None
    def save(s,f):
        try:k=json.load(open(s.f))
        except:k=[]
        if f["id"]not in[d["id"]for d in k]:k.append(f)
        k=[k[-n]for n in range(1,len(k)+1)if len(json.dumps(k[:n]))<=MAX]
        with open(s.f,"w")as file:json.dump(k,file)
    def get_local(s):
        try:d=random.choice(json.load(open(s.f)))
        except:return None,None
        return d["fact"],{"id":d["id"],"fact":d["fact"],"source":"off"}
    def get_text(s):
        t,d=s.get_random()
        if t and d:b.blink(1,0.15,0.15);print(f"fact ({d['source']}):\n",t);s.save(d)
        else:t,d=s.get_local();b.blink(1,0.2,0.2)if t and d else b.blink(1,0.25,0.25);t="fact unavailable"if not t else t;print(t)
        return t


facts_fetcher.py

import urequests as r,json,os,machine,time,random
from blinker import Blinker
P,MAX,b="joke.json",20*1024,Blinker(2)
class JokeFetcher:
    def __init__(s):s.f=P;s.apis=[("https://icanhazdadjoke.com/",{"Accept":"application/json"}),("https://v2.jokeapi.dev/joke/Any?type=single",None)]
    def get_random(s):
        try:
            api_url,headers=random.choice(s.apis)
            d=r.get(api_url,headers=headers).json()if headers else r.get(api_url).json()
            joke=d.get("joke")or d.get("setup")+"\n"+d.get("delivery")
            return joke,{"id":d.get("id"),"joke":joke,"source":"on"}
        except:return None,None
    def save(s,j):
        try:k=json.load(open(s.f))
        except:k=[]
        if j["id"]not in[d["id"]for d in k]:k.append(j)
        k=[k[-n]for n in range(1,len(k)+1)if len(json.dumps(k[:n]))<=MAX]
        with open(s.f,"w")as f:json.dump(k,f)
    def get_local(s):
        try:d=random.choice(json.load(open(s.f)))
        except:return None,None
        return d["joke"],{"id":d["id"],"joke":d["joke"],"source":"off"}
    def get_text(s):
        t,d=s.get_random()
        if t and d:b.blink(1,0.15,0.15);print(f"Joke ({d['source']}):\n",t);s.save(d)
        else:t,d=s.get_local();b.blink(1,0.2,0.2)if t and d else b.blink(1,0.25,0.25);t="joke unavailable"if not t else t;print(t)
        return t
