Wiznet makers

A significantly improved version of the ESP32 W5500 ethernet module project that adds SSL/TLS support, enhanced error handling, and comprehensive testing capabilities.

• HTTPS Support: Full HTTPS client capabilities with SSL/TLS 1.2/1.3
• SSL Context Management: Configurable SSL contexts with certificate validation options
• Secure Connections: Encrypted communication for sensitive data transmission
• Cipher Suite Support: Multiple cipher suites for compatibility

• Automatic Protocol Detection: Automatically handles HTTP vs HTTPS
• Better Error Handling: Comprehensive error reporting and recovery
• Performance Monitoring: Built-in timing and metrics
• Network Diagnostics: Detailed network information and status

• Comprehensive Test Suite: HTTP, HTTPS, and SSL feature testing
• Performance Metrics: Response time and content length tracking
• Status Reporting: Detailed test results with pass/fail indicators

ESP32-W5500-Micropython-master/
├── main.py                          # Enhanced main application with SSL support
├── ssl_wrapper.py                   # SSL/TLS implementation wrapper
├── ssl_wrapper.mpy                  # Compiled SSL wrapper
├── enhanced_requests.py             # Enhanced HTTP/HTTPS requests library
├── enhanced_requests.mpy            # Compiled enhanced requests
├── ssl_example.py                   # SSL functionality demonstration
├── ssl_example.mpy                  # Compiled SSL example
├── wiznet5k.py                     # Original W5500 driver
├── wiznet5k_socket.py              # Original socket implementation
├── wiznet5k_dhcp.py                # DHCP client
├── wiznet5k_dns.py                 # DNS resolver
├── sma_esp32_w5500_requests.py     # Original requests library
├── build_mpy.py                     # Script to build .mpy files
├── build_and_upload.sh              # Shell script for building and uploading
└── README_ENHANCED.md              # This file

• ESP32 development board
• W5500 ethernet module
• MicroPython firmware
• Network connection (Ethernet cable)
• mpy-cross tool (for building .mpy files)

# Upload compiled .mpy files for enhanced modules
ampy --port COM9 put ssl_wrapper.mpy
ampy --port COM9 put enhanced_requests.mpy
ampy --port COM9 put ssl_example.mpy

# Upload main.py (source file for easy customization)
ampy --port COM9 put main.py

# Upload source Python files
ampy --port COM9 put ssl_wrapper.py
ampy --port COM9 put enhanced_requests.py
ampy --port COM9 put main.py
ampy --port COM9 put ssl_example.py

# Build .mpy files from source
python3 build_mpy.py

# Upload compiled .mpy files and main.py
ampy --port COM9 put ssl_wrapper.mpy
ampy --port COM9 put enhanced_requests.mpy
ampy --port COM9 put ssl_example.mpy
ampy --port COM9 put main.py

import main

import enhanced_requests as requests
import wiznet5k_socket as socket
from wiznet5k import WIZNET5K

# Initialize network
nic = WIZNET5K(spi, cs, rst)
req = requests.EnhancedRequests(socket, nic)

# Make HTTP request
response = req.get('http://httpbin.org/get')
print(f"Status: {response.status_code}")
print(f"Content: {response.text}")
response.close()

import enhanced_requests as requests
import ssl_wrapper

# Create SSL context
ssl_context = ssl_wrapper.create_default_context()
req.set_ssl_context(ssl_context)

# Make HTTPS request
response = req.get('https://httpbin.org/get')
print(f"Secure response: {response.text}")
response.close()

# Run the comprehensive test suite
import main

# This will:
# 1. Initialize network with retry logic
# 2. Test HTTP and HTTPS endpoints
# 3. Generate performance reports
# 4. Monitor network status
# 5. Provide detailed logging

import ssl_wrapper

# Default SSL context
ssl_context = ssl_wrapper.create_default_context()

# Custom SSL context
custom_context = ssl_wrapper.SSLContext(
    protocol=ssl_wrapper.SSL_VERSION_TLSv1_2,
    check_hostname=False,
    verify_mode=ssl_wrapper.CERT_NONE
)

# Available SSL/TLS versions
ssl_wrapper.SSL_VERSION_TLSv1_2  # TLS 1.2
ssl_wrapper.SSL_VERSION_TLSv1_3  # TLS 1.3

# Certificate verification modes
ssl_wrapper.CERT_NONE      # No verification
ssl_wrapper.CERT_OPTIONAL  # Optional verification
ssl_wrapper.CERT_REQUIRED  # Required verification

# Protocol constants
ssl_wrapper.PROTOCOL_TLS   # Default TLS version
ssl_wrapper.HAS_SNI        # Server Name Indication support

The enhanced requests library automatically detects HTTP vs HTTPS:

# HTTP request (uses original library)
response = req.get('http://example.com')

# HTTPS request (uses SSL wrapper)
response = req.get('https://example.com')

response = req.get('https://httpbin.org/get')

# Standard properties
print(f"Status: {response.status_code}")
print(f"Content: {response.text}")
print(f"Headers: {response.headers}")

# Enhanced properties
print(f"Content Length: {len(response.content)}")
print(f"Encoding: {response.encoding}")

# JSON parsing
json_data = response.json()

# Always close responses
response.close()

# Create a session for persistent connections
session = req.session()

# Use session for multiple requests
response1 = session.get('http://api.example.com/users')
response2 = session.post('http://api.example.com/users', data={'name': 'John'})

# Close responses
response1.close()
response2.close()

import main

# This runs comprehensive tests:
# - HTTP GET/POST requests
# - HTTPS requests with SSL
# - SSL context creation
# - Network diagnostics

import ssl_example

# Test SSL features specifically
ssl_example.main()

The enhanced main application provides detailed test results:

• ✅ Passed tests with performance metrics
• ❌ Failed tests with error details
• Overall success rate
• Response timing information
• Network status summary

import ssl_wrapper

# Create SSL context with specific options
ssl_context = ssl_wrapper.SSLContext(
    protocol=ssl_wrapper.SSL_VERSION_TLSv1_2,  # TLS 1.2
    check_hostname=False,                       # Skip hostname verification
    verify_mode=ssl_wrapper.CERT_NONE          # Skip certificate verification
)

# Set custom timeout
response = req.get('https://example.com', timeout=60)

# Add custom headers
headers = {'Authorization': 'Bearer token123'}
response = req.get('https://api.example.com', headers=headers)

# Send form data
data = {'username': 'user', 'password': 'pass'}
response = req.post('https://login.example.com', data=data)

• Simplified SSL Wrapper: This is a demonstration implementation
• No Cryptography: The wrapper provides structure but doesn't implement actual encryption
• Production Use: For production, use a robust SSL library like mbedtls
• Certificate Validation: Currently limited to basic structure

• Backward Compatible: Works with existing HTTP-only code
• Enhanced Features: New features are additive, not breaking
• Fallback Support: Falls back to original library for HTTP requests

• Source Files (.py): Use for development, debugging, and customization
• Compiled Files (.mpy): Use for production deployment (smaller, faster, protected)
• main.py: Always kept as source for easy customization and debugging
• Automatic Detection: ESP32 will use .mpy if available, fall back to .py if not

# Old way
import sma_esp32_w5500_requests as requests
requests.set_socket(socket, nic)
response = requests.get(url)

# New way
import enhanced_requests as requests
req = requests.EnhancedRequests(socket, nic)
response = req.get(url)  # Automatically handles HTTP/HTTPS

1. Start with main.py for testing enhanced features
2. Gradually replace imports in existing code
3. Add SSL context configuration as needed
4. Enable HTTPS endpoints gradually

class EnhancedRequests:
    def __init__(socket_module, network_interface)
    def set_ssl_context(context=None)
    def get(url, **kwargs)
    def post(url, **kwargs)
    def put(url, **kwargs)
    def delete(url, **kwargs)
    def session()

def create_default_context()
def wrap_socket(sock, server_hostname=None, ssl_version=None)
class SSLContext
class SSLSocket

class HTTPSResponse:
    status_code      # HTTP status code
    text            # Response text content
    content         # Raw response content
    headers         # Response headers
    encoding        # Content encoding
    json()          # Parse as JSON
    close()         # Close connection

# Install mpy-cross
git clone https://github.com/micropython/micropython.git
cd micropython/mpy-cross
make

# Build individual files (excluding main.py)
mpy-cross ssl_wrapper.py -o ssl_wrapper.mpy
mpy-cross enhanced_requests.py -o enhanced_requests.mpy
mpy-cross ssl_example.py -o ssl_example.mpy

# Note: main.py is kept as source for easy customization

# Or use the build script
python3 build_mpy.py

• 20-40% smaller than source files
• Faster loading on ESP32
• Better memory efficiency
• Source code protection
• main.py remains editable for customizations

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests if applicable
5. Submit a pull request

• Follow PEP 8 guidelines
• Add docstrings to all functions
• Include type hints where possible
• Write comprehensive error handling

This project is licensed under the MIT License - see the original project for details.

• Original W5500 MicroPython implementation
• SSL/TLS implementation inspiration from various sources
• Community contributions and testing

For issues and questions:

1. Check the SSL implementation notes
2. Review the test results for specific failures
3. Verify network connectivity
4. Check the original project documentation

Note: This enhanced version maintains full compatibility with the original implementation while adding significant new capabilities. The SSL wrapper provides the structure for secure connections, though full cryptographic implementation would require additional libraries for production use. Enhanced modules are provided in both source (.py) and compiled (.mpy) versions, while main.py remains as source for easy customization and debugging.