easylinux/Maison
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initialisation depot

Browse Source
This commit is contained in:
Serge NOEL
2026-02-10 12:12:11 +01:00
commit c3176e8d79
818 changed files with 52573 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
ESP32/DCC-Bench/.gitignore vendored Normal file
View File

@@ -0,0 +1,5 @@
.pio
.vscode/.browse.c_cpp.db*
.vscode/c_cpp_properties.json
.vscode/launch.json
.vscode/ipch

10
ESP32/DCC-Bench/.vscode/extensions.json vendored Normal file
View File

@@ -0,0 +1,10 @@
{
// See http://go.microsoft.com/fwlink/?LinkId=827846
// for the documentation about the extensions.json format
"recommendations": [
"platformio.platformio-ide"
],
"unwantedRecommendations": [
"ms-vscode.cpptools-extension-pack"
]
}

8
ESP32/DCC-Bench/DCC-Bench.code-workspace Normal file
View File

@@ -0,0 +1,8 @@
{
"folders": [
{
"path": "."
}
],
"settings": {}
}

282
ESP32/DCC-Bench/Doxyfile Normal file
View File

@@ -0,0 +1,282 @@
# Doxyfile 1.9.1
# Configuration file for Doxygen documentation generation
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = "Locomotive Test Bench"
PROJECT_NUMBER = 1.0
PROJECT_BRIEF = "ESP32-based test bench for DC and DCC model locomotives"
PROJECT_LOGO =
OUTPUT_DIRECTORY = ./doc
CREATE_SUBDIRS = NO
ALLOW_UNICODE_NAMES = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ABBREVIATE_BRIEF =
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = YES
STRIP_FROM_PATH =
STRIP_FROM_INC_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = YES
JAVADOC_BANNER = NO
QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 4
OPTIMIZE_OUTPUT_FOR_C = NO
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
OPTIMIZE_OUTPUT_SLICE = NO
MARKDOWN_SUPPORT = YES
TOC_INCLUDE_HEADINGS = 5
AUTOLINK_SUPPORT = YES
BUILTIN_STL_SUPPORT = YES
CPP_CLI_SUPPORT = NO
DISTRIBUTE_GROUP_DOC = NO
GROUP_NESTED_COMPOUNDS = NO
SUBGROUPING = YES
INLINE_GROUPED_CLASSES = NO
INLINE_SIMPLE_STRUCTS = NO
TYPEDEF_HIDES_STRUCT = NO
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
EXTRACT_ALL = YES
EXTRACT_PRIVATE = YES
EXTRACT_PRIV_VIRTUAL = NO
EXTRACT_PACKAGE = NO
EXTRACT_STATIC = YES
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = NO
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = YES
HIDE_SCOPE_NAMES = NO
HIDE_COMPOUND_REFERENCE= NO
SHOW_INCLUDE_FILES = YES
SHOW_GROUPED_MEMB_INC = NO
FORCE_LOCAL_INCLUDES = NO
INLINE_INFO = YES
SORT_MEMBER_DOCS = YES
SORT_BRIEF_DOCS = NO
SORT_MEMBERS_CTORS_1ST = NO
SORT_GROUP_NAMES = NO
SORT_BY_SCOPE_NAME = NO
STRICT_PROTO_MATCHING = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = YES
SHOW_FILES = YES
SHOW_NAMESPACES = YES
#---------------------------------------------------------------------------
# Configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = YES
WARN_AS_ERROR = NO
WARN_FORMAT = "$file:$line: $text"
#---------------------------------------------------------------------------
# Configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = ./src \
./include \
./README.md
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.cpp \
*.h \
*.md
RECURSIVE = YES
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS = */build/* \
*/.pio/* \
*/data/*
EXCLUDE_SYMBOLS =
EXAMPLE_PATH =
EXAMPLE_PATTERNS = *
EXAMPLE_RECURSIVE = NO
IMAGE_PATH =
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
FILTER_SOURCE_PATTERNS =
#---------------------------------------------------------------------------
# Configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = YES
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = YES
REFERENCES_RELATION = YES
REFERENCES_LINK_SOURCE = YES
SOURCE_TOOLTIPS = YES
USE_HTAGS = NO
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# Configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = YES
COLS_IN_ALPHA_INDEX = 5
#---------------------------------------------------------------------------
# Configuration options related to the HTML output
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT = html
HTML_FILE_EXTENSION = .html
HTML_HEADER =
HTML_FOOTER =
HTML_STYLESHEET =
HTML_EXTRA_STYLESHEET =
HTML_EXTRA_FILES =
HTML_COLORSTYLE_HUE = 220
HTML_COLORSTYLE_SAT = 100
HTML_COLORSTYLE_GAMMA = 80
HTML_TIMESTAMP = YES
HTML_DYNAMIC_MENUS = YES
HTML_DYNAMIC_SECTIONS = NO
HTML_INDEX_NUM_ENTRIES = 100
GENERATE_DOCSET = NO
GENERATE_HTMLHELP = NO
GENERATE_QHP = NO
GENERATE_ECLIPSEHELP = NO
DISABLE_INDEX = NO
GENERATE_TREEVIEW = YES
ENUM_VALUES_PER_LINE = 4
TREEVIEW_WIDTH = 250
EXT_LINKS_IN_WINDOW = NO
HTML_FORMULA_FORMAT = png
FORMULA_FONTSIZE = 10
FORMULA_TRANSPARENT = YES
FORMULA_MACROFILE =
USE_MATHJAX = NO
SEARCHENGINE = YES
SERVER_BASED_SEARCH = NO
#---------------------------------------------------------------------------
# Configuration options related to the LaTeX output
#---------------------------------------------------------------------------
GENERATE_LATEX = NO
#---------------------------------------------------------------------------
# Configuration options related to the RTF output
#---------------------------------------------------------------------------
GENERATE_RTF = NO
#---------------------------------------------------------------------------
# Configuration options related to the man page output
#---------------------------------------------------------------------------
GENERATE_MAN = NO
#---------------------------------------------------------------------------
# Configuration options related to the XML output
#---------------------------------------------------------------------------
GENERATE_XML = NO
#---------------------------------------------------------------------------
# Configuration options related to the DOCBOOK output
#---------------------------------------------------------------------------
GENERATE_DOCBOOK = NO
#---------------------------------------------------------------------------
# Configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# Configuration options related to the Perl module output
#---------------------------------------------------------------------------
GENERATE_PERLMOD = NO
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = YES
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH = ./include
INCLUDE_FILE_PATTERNS =
PREDEFINED = ARDUINO \
ESP32
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration options related to external references
#---------------------------------------------------------------------------
TAGFILES =
GENERATE_TAGFILE =
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
EXTERNAL_PAGES = YES
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = YES
DIA_PATH =
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = NO
DOT_NUM_THREADS = 0
DOT_FONTNAME = Helvetica
DOT_FONTSIZE = 10
CLASS_GRAPH = YES
COLLABORATION_GRAPH = YES
GROUP_GRAPHS = YES
UML_LOOK = NO
UML_LIMIT_NUM_FIELDS = 10
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
CALLER_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
INTERACTIVE_SVG = NO
DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
DOT_TRANSPARENT = NO
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = YES
DOT_CLEANUP = YES

196
ESP32/DCC-Bench/ESP32-2432S028R_MIGRATION.md Normal file
View File

@@ -0,0 +1,196 @@
# ESP32-2432S028R Migration Summary
## Overview
Successfully migrated the DCC-Bench project from WiFi/WebServer control to touchscreen-based control using the ESP32-2432S028R module (ESP32 with ILI9341 TFT touchscreen).
## Hardware Configuration
### ESP32-2432S028R Module
- **Board**: ESP32-WROOM-32
- **Display**: ILI9341 TFT (320x240 pixels)
- **Touch**: XPT2046 resistive touchscreen
- **Pins Used**:
- TFT MISO: GPIO 12
- TFT MOSI: GPIO 13
- TFT SCLK: GPIO 14
- TFT CS: GPIO 15
- TFT DC: GPIO 2
- TFT BL (Backlight): GPIO 21
- Touch CS: GPIO 22
- Relay Control: GPIO 4
- PWM/DCC_A: GPIO 18 (dual purpose)
- DIR/DCC_B: GPIO 19 (dual purpose)
- Motor BRAKE: GPIO 23
### LM18200 H-Bridge Driver (Dual Purpose)
The LM18200 serves as **BOTH** the DC motor controller AND DCC signal booster:
- **DC Analog Mode**: GPIO 18 sends PWM for speed, GPIO 19 sets direction
- **DCC Digital Mode**: GPIO 18 sends DCC signal A, GPIO 19 sends DCC signal B (inverted)
- Same hardware, different signals depending on mode selected
- LM18200 amplifies the 3.3V logic signals to track voltage (12-18V)
## Key Changes
### 1. PlatformIO Configuration (`platformio.ini`)
- **Changed**: Board target from `esp32doit-devkit-v1` to `esp32dev` for ESP32-2432S028R
- **Removed**: WiFi/WebServer libraries (ESPAsyncWebServer, AsyncTCP)
- **Added**:
- `bodmer/TFT_eSPI@^2.5.43` - Display driver
- `paulstoffregen/XPT2046_Touchscreen@^1.4` - Touch controller
- **Added**: TFT_eSPI build flags for ILI9341 configuration
### 2. New Components
#### RelayController (`RelayController.h/cpp`)
- Controls relay on GPIO 27 for 2-rail/3-rail track switching
- Simple HIGH/LOW control
- State tracking and persistence through Config
#### TouchscreenUI (`TouchscreenUI.h/cpp`)
- Full graphical user interface with touch controls
- **Features**:
- Power ON/OFF button (green/red indicator)
- DCC/Analog mode toggle button (cyan/yellow)
- 2-Rail/3-Rail selector button
- Direction control (FWD/REV)
- Horizontal speed slider (0-100%)
- Status bar showing all current settings
- **Behavior**:
- Switching from DCC to Analog (or vice versa) automatically powers off the system
- All settings are saved to NVS (persistent storage)
- Touch events mapped to screen coordinates with calibration
### 3. Modified Components
#### Config (`Config.h/cpp`)
- **Removed**: All WiFi-related configuration (`WiFiConfig` struct)
- **Added to SystemConfig**:
- `bool is3Rail` - Track configuration (2-rail/3-rail)
- `bool powerOn` - Power state tracking
- **Updated**: Save/load methods to persist new settings
#### Main (`main.cpp`)
- **Removed**: WiFi, WebServer, LEDIndicator components
- **Added**: TouchscreenUI, RelayController
- **Updated**: Setup sequence and main loop
- **Simplified**: Loop now only handles UI updates and motor/DCC control based on power state
### 4. Removed Files
- `include/WiFiManager.h`
- `src/WiFiManager.cpp`
- `include/WebServer.h`
- `src/WebServer.cpp`
- `include/LEDIndicator.h` (was already commented out)
## User Interface Layout
```
┌─────────────────────────────────────────────────┐
│ [POWER] [MODE ] [RAILS] [DIR ] │
│ ON/OFF DCC/DC 2/3Rail FWD/REV │
│ │
│ Speed: 45% │
│ │
│ ╔════════════════○═════════════╗ │
│ ║ ║ Speed Slider│
│ ╚═══════════════════════════════╝ │
│ │
│ ┌─────────────────────────────────────────────┐ │
│ │ PWR:ON | Mode:DCC | 3-Rail | Addr:3 │ │
│ │ Speed:45% FWD │ │
│ └─────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────┘
```
## Features Implemented
### ✅ Power Control
- Power ON/OFF button
- **Safety**: Power automatically turns OFF when switching between DCC and Analog modes
- Power state persisted in configuration
### ✅ Mode Switching
- Toggle between DCC and DC Analog control
- Visual indication (Cyan for DCC, Yellow for Analog)
- Automatic power-off on mode change prevents unsafe transitions
### ✅ Rail Configuration
- 2-Rail / 3-Rail selector
- Physical relay control on GPIO 27
- Energized = 3-Rail, De-energized = 2-Rail
### ✅ Speed Control
- Interactive horizontal slider
- Range: 0-100%
- Real-time speed updates to motor/DCC controller
- Visual feedback with active/inactive portions
### ✅ Direction Control
- Forward/Reverse toggle
- Updates motor or DCC direction based on current mode
### ✅ Persistent Storage
- All settings saved to ESP32 NVS (Non-Volatile Storage)
- Settings persist across power cycles
- Automatic save on every change
## Building and Uploading
```bash
# Install dependencies and build
pio run
# Upload to ESP32-2432S028R
pio run --target upload
# Monitor serial output
pio device monitor
```
## Next Steps / Future Enhancements
1. **DCC Address Entry**: Add touchscreen numeric keypad for changing DCC address
2. **Function Buttons**: Add DCC function controls (F0-F12) with toggle buttons
3. **Speed Presets**: Add quick-access speed buttons (25%, 50%, 75%, 100%)
4. **Track Current Monitoring**: Display track current if current sensor is added
5. **Emergency Stop**: Large red emergency stop button
6. **Locomotive Profiles**: Save/load different locomotive configurations
## Testing Checklist
- [ ] Display initializes correctly
- [ ] Touch calibration is accurate
- [ ] Power button toggles ON/OFF
- [ ] Mode switch changes DCC/Analog
- [ ] Mode switch automatically powers off
- [ ] Rail selector controls relay
- [ ] Speed slider adjusts output
- [ ] Direction button changes FWD/REV
- [ ] Settings persist after reboot
- [ ] DCC signals generated correctly (when powered on)
- [ ] DC motor control works (when powered on)
- [ ] Relay switches correctly
## Pin Reference
| Function | GPIO | Notes |
|----------|------|-------|
| PWM/DCC_A | 18 | DC: 20kHz PWM / DCC: Signal A |
| DIR/DCC_B | 19 | DC: Direction / DCC: Signal B |
| Motor Brake | 23 | Active LOW brake |
| Relay Control | 4 | HIGH=3-Rail, LOW=2-Rail |
| TFT MISO | 12 | SPI data in |
| TFT MOSI | 13 | SPI data out |
| TFT SCLK | 14 | SPI clock |
| TFT CS | 15 | Chip select |
| TFT DC | 2 | Data/Command |
| TFT Backlight | 21 | Backlight control |
| Touch CS | 22 | Touch chip select |
## Notes
- Motor PWM frequency: 20kHz (silent operation)
- Display orientation: Landscape (320x240)
- Touch type: Resistive (XPT2046)
- All configuration stored in NVS partition
- Pin assignments avoid conflicts with ESP32-2432S028R built-in peripherals

176
ESP32/DCC-Bench/MIGRATION_COMPLETE.md Normal file
View File

@@ -0,0 +1,176 @@
# 🎉 Project Migration Complete!
## Summary
Successfully migrated the DCC-Bench project from WiFi/WebServer control to **ESP32-2432S028R touchscreen control**.
## ✅ What Was Changed
### 1. Hardware Platform
- ✅ Changed from generic ESP32 to **ESP32-2432S028R** (with built-in ILI9341 touchscreen)
- ✅ Updated `platformio.ini` with correct board and TFT configuration
- ✅ Added TFT_eSPI and XPT2046_Touchscreen libraries
### 2. New Features Added
- ✅ **TouchscreenUI**: Full graphical interface with buttons and slider
- ✅ **RelayController**: 2-rail/3-rail track switching via relay
- ✅ **Power Control**: ON/OFF button with safety features
- ✅ **Mode Switching**: DCC ↔ Analog with automatic power-off
- ✅ **Settings Persistence**: All settings saved to NVS
### 3. Components Removed
- ✅ WiFiManager (no longer needed)
- ✅ WebServer (replaced by touchscreen)
- ✅ Web interface files (data/ folder)
- ✅ Bootstrap dependencies
### 4. Safety Improvements
- ✅ **Auto power-off** when switching modes (prevents dangerous transitions)
- ✅ Visual power state indication (green/red button)
- ✅ Clear mode indication (cyan for DCC, yellow for Analog)
### 5. Updated Pin Assignments
All pins updated to avoid conflicts with ESP32-2432S028R peripherals:
| Component | Old Pins | New Pins |
|-----------|----------|----------|
| DCC Output | 32, 33 | 17, 16 |
| Motor Control | 25, 26, 27 | 18, 19, 23 |
| Relay | - | 4 |
| Touch/Display | - | 2, 12-15, 21, 22 |
### 6. Documentation Created
- ✅ `ESP32-2432S028R_MIGRATION.md` - Detailed migration guide
- ✅ `WIRING_ESP32-2432S028R.md` - Complete wiring guide
- ✅ `QUICK_REFERENCE.md` - Quick reference card
- ✅ Updated `README.md` - Main documentation
## 📋 Files Modified
### Created:
- `include/TouchscreenUI.h`
- `src/TouchscreenUI.cpp`
- `include/RelayController.h`
- `src/RelayController.cpp`
- `ESP32-2432S028R_MIGRATION.md`
- `WIRING_ESP32-2432S028R.md`
- `QUICK_REFERENCE.md`
### Modified:
- `platformio.ini` - Board config and libraries
- `include/Config.h` - Removed WiFi, added rail mode and power state
- `src/Config.cpp` - Updated save/load logic
- `include/MotorController.h` - Updated pin assignments
- `include/DCCGenerator.h` - Updated pin assignments
- `src/main.cpp` - Completely rewritten for touchscreen
- `README.md` - Updated documentation
### Removed:
- `include/WiFiManager.h`
- `src/WiFiManager.cpp`
- `include/WebServer.h`
- `src/WebServer.cpp`
### Kept (not used, but preserved):
- `include/LEDIndicator.h` - Can be used for future features
- `src/LEDIndicator.cpp` - Can be used for future features
- `data/` folder - Web files (not needed but preserved)
## 🚀 Next Steps
### To Build and Upload:
```bash
# Build the project
pio run
# Upload to ESP32-2432S028R
pio run --target upload
# Monitor serial output
pio device monitor
```
### To Test:
1. ✅ Power on via USB-C
2. ✅ Verify display shows UI
3. ✅ Test touch responsiveness
4. ✅ Toggle each button
5. ✅ Test speed slider
6. ✅ Verify relay clicking
7. ✅ Test mode switching (should power off)
8. ✅ Verify settings persist after reboot
## 📚 Documentation Reference
- **Main README**: [README.md](README.md)
- **Migration Details**: [ESP32-2432S028R_MIGRATION.md](ESP32-2432S028R_MIGRATION.md)
- **Wiring Guide**: [WIRING_ESP32-2432S028R.md](WIRING_ESP32-2432S028R.md)
- **Quick Reference**: [QUICK_REFERENCE.md](QUICK_REFERENCE.md)
## ⚠️ Important Notes
### Power Safety
- **Switching modes automatically powers OFF** - this is by design for safety
- Always verify power state before testing with a locomotive
### Pin Conflicts Resolved
- Original design had GPIO 33 conflict (DCC_B and Touch CS)
- Resolved by moving DCC to GPIO 16/17 and Touch to GPIO 22
### External Circuits Required
- **DCC Mode**: Requires DCC booster circuit (LMD18200 or similar)
- **DC Mode**: Requires motor driver (LM18200 or similar)
- **Relay**: Requires 5V relay module for 2-rail/3-rail switching
### Settings Storage
All settings stored in ESP32 NVS and persist across:
- Power cycles
- Firmware updates (unless NVS is erased)
- Reboots
## 🎯 Feature Highlights
### User Interface
```
┌─────────────────────────────────────────┐
│ [POWER] [MODE] [RAILS] [DIR] │
│ ON/OFF DCC/DC 2/3Rail FWD/REV │
│ │
│ Speed: 45% │
│ │
│ ═══════════════○════════════ │
│ │
│ PWR:ON | Mode:DCC | 3-Rail | Addr:3 │
│ Speed:45% FWD │
└─────────────────────────────────────────┘
```
### Button Colors
- **Power**: Green (ON) / Red (OFF)
- **Mode**: Cyan (DCC) / Yellow (Analog)
- **Rails**: Green (3-Rail) / Gray (2-Rail)
- **Direction**: White text
## 🔄 Version Information
- **Previous Version**: 1.0 (WiFi/WebServer based)
- **Current Version**: 2.0 (Touchscreen based)
- **Platform**: ESP32-2432S028R
- **Framework**: Arduino via PlatformIO
## ✨ Future Enhancement Ideas
1. **DCC Address Entry**: Numeric keypad on touchscreen
2. **Function Buttons**: F0-F12 control for DCC mode
3. **Speed Presets**: Quick buttons (25%, 50%, 75%, 100%)
4. **Current Monitoring**: Display track current (requires sensor)
5. **Locomotive Profiles**: Save/load multiple loco configurations
6. **Emergency Stop**: Large dedicated button
7. **Sound Feedback**: Beep on button press
8. **Brightness Control**: Adjust display backlight
---
**Migration Date**: December 1, 2025
**Git Branch**: ESP32-2432 (feature branch)
**Status**: ✅ Complete and ready for testing

48
ESP32/DCC-Bench/PIN_REFERENCE.txt Normal file
View File

@@ -0,0 +1,48 @@
/*
* Pin Configuration Reference
*
* This file documents all pin assignments for quick reference.
* To change pins, edit the corresponding header files.
*/
// ===================================
// MOTOR CONTROLLER (LM18200)
// Defined in: include/MotorController.h
// ===================================
#define MOTOR_PWM_PIN 25 // PWM signal for speed control
#define MOTOR_DIR_PIN 26 // Direction: HIGH=forward, LOW=reverse
#define MOTOR_BRAKE_PIN 27 // Brake: LOW=brake, HIGH=release
// ===================================
// DCC GENERATOR
// Defined in: include/DCCGenerator.h
// ===================================
#define DCC_PIN_A 32 // DCC signal output A
#define DCC_PIN_B 33 // DCC signal output B (inverted)
// ===================================
// LED INDICATORS (WS2812)
// Defined in: include/LEDIndicator.h
// ===================================
#define LED_DATA_PIN 4 // WS2812 data line
#define NUM_LEDS 2 // LED 0: Power, LED 1: Mode
// ===================================
// AVAILABLE GPIO PINS (ESP32 D1 Mini)
// ===================================
// Used: 4, 25, 26, 27, 32, 33
// Available for expansion:
// - GPIO 5, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23
// - GPIO 34, 35, 36, 39 (Input only)
// Reserved for internal use:
// - GPIO 0, 2 (Boot/Flash)
// - GPIO 1, 3 (Serial TX/RX)
// ===================================
// NOTES
// ===================================
// - All control pins are outputs except where noted
// - Ensure adequate current capacity for motor loads
// - DCC outputs require proper signal conditioning
// - PWM frequency: 20kHz (defined in MotorController.cpp)
// - DCC timing follows NMRA standards

162
ESP32/DCC-Bench/PROGRAMMING_IMPLEMENTATION.md Normal file
View File

@@ -0,0 +1,162 @@
# DCC Programming Track - Implementation Summary
## What Changed
You're absolutely correct! The LM18200 can handle programming track operations perfectly fine for a dedicated test bench where only one locomotive is present at a time.
## Implementation Complete ✅
### 1. DCCGenerator Header (`include/DCCGenerator.h`)
Added programming track methods:
- `bool factoryReset()` - Send CV8 = 8 reset command
- `bool setDecoderAddress(uint16_t address)` - Set short/long address
- `bool readCV(uint16_t cv, uint8_t* value)` - Read CV using bit-wise verify
- `bool writeCV(uint16_t cv, uint8_t value)` - Write and verify CV
Helper methods:
- `void sendServiceModePacket()` - Send programming packets (22-bit preamble)
- `bool verifyByte()` - Verify write operations
- `bool waitForAck()` - Detect ACK pulses from decoder
### 2. DCCGenerator Implementation (`src/DCCGenerator.cpp`)
**~200 lines** of NMRA-compliant programming track code:
- **Factory Reset**: Sends CV8 = 8 command (standard NMRA reset)
- **Set Address**:
- Short (1-127): Writes CV1
- Long (128-10239): Writes CV17+CV18
- Updates CV29 for address mode
- **Read CV**: Bit-wise verify method (tests each bit 0-7)
- **Write CV**: Write with 3 retries + verification
- **Service Mode Packets**: 22-bit preamble for programming
### 3. TouchscreenUI Updates (`src/TouchscreenUI.cpp`)
Updated all programming methods to call actual DCC functions:
- `performFactoryReset()` - Calls `dccGen->factoryReset()`
- `performSetAddress()` - Calls `dccGen->setDecoderAddress()`
- `performReadCV()` - Calls `dccGen->readCV()`
- `performWriteCV()` - Calls `dccGen->writeCV()`
All methods now show real success/failure based on ACK detection.
### 4. Documentation
Created comprehensive guide:
- **`doc/PROGRAMMING_TRACK.md`**: Full programming track documentation
- How it works with LM18200
- Hardware requirements (current sense resistor)
- ACK detection implementation
- Usage instructions
- Troubleshooting guide
Updated wiring documentation:
- **`WIRING_ESP32-2432S028R.md`**: Added current sense circuit
- 0.1Ω resistor for current measurement
- Voltage divider to GPIO 35 (ADC)
- Pin table updated with ACK detect
## Hardware Required
### Essential (Already in Design)
✅ LM18200 H-Bridge (GPIO 18, 19, 23)
✅ ESP32-2432S028R module
✅ Track power supply (12-18V)
### For ACK Detection (New)
📋 **0.1Ω, 1W current sense resistor** (in series with track)
📋 **Voltage divider** (1kΩ + 10kΩ resistors)
📋 **Wire to GPIO 35** (ADC input for ACK detection)
## How Programming Works
### Without ACK Detection (Current State)
✅ Sends correct NMRA programming packets
✅ Proper timing and packet structure
✅ Retry logic for reliability
⚠️ `waitForAck()` returns `true` (assumes success)
**Result**: Programming commands are sent correctly, but success cannot be verified.
### With ACK Detection (Hardware Addition)
1. Decoder receives programming command
2. If valid, decoder draws **60mA pulse for 6ms**
3. Current sense resistor creates voltage spike
4. ESP32 ADC (GPIO 35) detects voltage above threshold
5. Returns **true ACK** = verified success
6. Returns **false** = no response / failed
## Next Steps
### Option 1: Use As-Is (No ACK)
- Programming works but not verified
- Good for known-working decoders
- Suitable for basic address setting
### Option 2: Add ACK Detection (Recommended)
1. **Hardware**: Add current sense circuit (see PROGRAMMING_TRACK.md)
2. **Software**: Update `waitForAck()` method:
```cpp
bool DCCGenerator::waitForAck() {
#define CURRENT_SENSE_PIN 35
#define ACK_THRESHOLD 100 // Calibrate based on hardware
unsigned long startTime = millis();
while (millis() - startTime < 20) {
int adcValue = analogRead(CURRENT_SENSE_PIN);
if (adcValue > ACK_THRESHOLD) {
return true; // ACK detected
}
delayMicroseconds(100);
}
return false; // Timeout
}
```
3. **Calibration**: Test with known decoder, adjust threshold
## Testing Procedure
### Step 1: Verify Packet Generation
- Connect logic analyzer to GPIO 18/19
- Verify DCC signal during programming mode
- Check timing matches NMRA specs
### Step 2: Test Without ACK
- Place decoder on track
- Send factory reset
- Send set address command
- Test decoder responds to new address
### Step 3: Add ACK Detection
- Wire current sense circuit
- Calibrate threshold value
- Verify ACK pulses detected
- Test all programming functions
## Advantages of This Approach
✅ **Single Driver**: LM18200 handles both operation and programming
✅ **No Mode Switch**: Same hardware, just different signals
✅ **Safe for Bench**: Only one loco at a time = no current issues
✅ **Full NMRA Compliance**: Proper packet structure and timing
✅ **Cost Effective**: No separate programming track booster needed
✅ **Simplified Wiring**: Fewer components
## Current Limitations
⚠️ **ACK Detection**: Needs current sense hardware (optional but recommended)
⚠️ **Operations Mode**: Not implemented (programming on main track)
⚠️ **RailCom**: Not supported (requires special hardware)
## Files Modified
- `include/DCCGenerator.h` - Added 4 public methods + 3 private helpers
- `src/DCCGenerator.cpp` - Added ~200 lines of programming implementation
- `src/TouchscreenUI.cpp` - Updated 4 methods to call real DCC functions
- `doc/PROGRAMMING_TRACK.md` - New comprehensive documentation (600+ lines)
- `WIRING_ESP32-2432S028R.md` - Added current sense circuit diagram
## Summary
The DCC-Bench now has **full programming track capability** using the existing LM18200 driver. The implementation is NMRA-compliant and ready to use. ACK detection is the only optional addition that requires minimal hardware (one resistor + voltage divider).
This is exactly the right approach for a test bench - simple, effective, and uses the hardware you already have! 🎯

105
ESP32/DCC-Bench/QUICK_REFERENCE.md Normal file
View File

@@ -0,0 +1,105 @@
# ESP32-2432S028R Quick Reference Card
## 🎯 Quick Start
1. Connect USB-C cable
2. Display shows touchscreen UI
3. Tap [POWER] to turn ON (green)
4. Use slider to control speed
5. Tap [DIR] to change direction
## 📱 UI Button Guide
```
┌──────────────────────────────────────┐
│ [POWER] [MODE] [RAILS] [DIR] │
└──────────────────────────────────────┘
```
### [POWER] Button
- **Green** = Power ON → Motor/DCC active
- **Red** = Power OFF → No output
- Tap to toggle
### [MODE] Button
- **Cyan** = DCC Digital mode
- **Yellow** = DC Analog mode
- ⚠️ **Auto powers OFF when switching!**
### [RAILS] Button
- **2-Rail** = Standard configuration (relay OFF)
- **3-Rail** = Center rail mode (relay ON)
- Relay clicks when toggling
### [DIR] Button
- **FWD** = Forward direction
- **REV** = Reverse direction
- Changes immediately if powered
### Speed Slider
- Drag white knob OR tap anywhere on slider
- Range: 0-100%
- Real-time updates
## ⚡ Pin Quick Reference
| Function | GPIO | External Connection |
|----------|------|---------------------|
| PWM/DCC_A | 18 | LM18200 PWM (dual purpose) |
| DIR/DCC_B | 19 | LM18200 DIR (dual purpose) |
| Motor BRAKE | 23 | LM18200 BRAKE |
| Relay | 4 | Relay Module IN |
| Ground | GND | All GNDs |
## 🔒 Safety Features
✅ **Auto Power-Off**: Switching DCC↔Analog automatically turns power OFF
✅ **Emergency Stop**: Tap [POWER] button for immediate stop
✅ **Settings Saved**: All configurations persist after reboot
## 🚨 Important Notes
- **Always power OFF before switching modes** (automatic)
- **DCC requires booster circuit** (ESP32 outputs logic-level only)
- **Motor controller handles high current** (not ESP32 directly)
- **Common ground required** for all external circuits
## 🛠️ Default Settings
- **DCC Address**: 3 (change in code)
- **Power**: OFF on startup
- **Mode**: DC Analog
- **Rails**: 2-Rail
- **Speed**: 0%
- **Direction**: Forward
## 📊 Serial Monitor Commands
Baud rate: **115200**
Watch for:
- Configuration loaded
- Relay Controller initialized
- Touchscreen UI initialized
- Mode changes
- Power state changes
## 🔄 Factory Reset
To reset all settings:
1. Flash firmware with PlatformIO
2. Settings will revert to defaults
3. Or call `config.reset()` in code
## 📞 Troubleshooting Quick Fixes
| Problem | Quick Fix |
|---------|-----------|
| Touch not working | Adjust calibration in code |
| Display blank | Check USB power |
| Motor not running | Check power is ON + correct mode |
| Relay not clicking | Verify 5V power to relay |
| Settings not saving | Check NVS partition |
---
**Tip**: Keep this card handy near your test bench!

401
ESP32/DCC-Bench/README.md Normal file
View File

@@ -0,0 +1,401 @@
# 🚂 Locomotive Test Bench
A comprehensive testing platform for model/scale locomotives using **ESP32-2432S028R** (ESP32 with ILI9341 touchscreen) and motor driver circuits. This system supports both **DC Analog** and **DCC Digital** control modes with an intuitive touchscreen interface.
## ✨ Features
### Control Modes
- **DC Analog Mode**: Traditional PWM-based speed control with bidirectional operation
- **DCC Digital Mode**: Full DCC protocol support for digital model locomotives
- 128-step speed control
- Function control (F0-F28 capable)
- Short and long address support (1-10239)
### Track Configuration
- **2-Rail Mode**: Standard two-rail DC/DCC operation
- **3-Rail Mode**: Center rail configuration with relay switching
### Touchscreen Interface
- **320x240 ILI9341 TFT Display** with resistive touch
- Power ON/OFF control with visual indicators
- Mode switching (DCC/Analog) with automatic power-off safety
- Interactive speed slider (0-100%)
- Direction control (Forward/Reverse)
- Rail configuration selector (2-rail/3-rail)
- Real-time status display
- Persistent settings (saved to ESP32 NVS)
### Safety Features
- **Automatic power-off** when switching between DCC and Analog modes
- Emergency stop via power button
- Configuration persistence across reboots
## 🔧 Hardware Requirements
### Main Components
- **ESP32-2432S028R Module** (ESP32 with built-in ILI9341 touchscreen)
- **Motor Driver** (LM18200, L298N, or similar)
- **DCC Booster Circuit** (for DCC mode)
- **Relay Module** (5V single-channel for 2-rail/3-rail switching)
- **Power Supply**: Suitable for your locomotive scale (typically 12-18V)
- Model locomotive (DC or DCC compatible)
### ESP32-2432S028R Module Specifications
- **MCU**: ESP32-WROOM-32
- **Display**: 2.8" ILI9341 TFT (320x240)
- **Touch**: XPT2046 Resistive Touch Controller
- **Built-in**: USB-C, MicroSD slot, RGB LED
### Pin Connections
See **[WIRING_ESP32-2432S028R.md](WIRING_ESP32-2432S028R.md)** for complete wiring diagrams and connection details.
#### Quick Pin Reference
| Function | ESP32 GPIO | Connected To |
|----------|-----------|--------------|
| PWM/DCC_A | 18 | LM18200 PWM Input (dual purpose) |
| DIR/DCC_B | 19 | LM18200 DIR Input (dual purpose) |
| Motor Brake | 23 | LM18200 Brake Input |
| Relay Control | 4 | Relay Module Signal |
| TFT/Touch | 2,12-15,21,22 | Built-in (no wiring needed) |
## 📦 Software Setup
### Prerequisites
- [Visual Studio Code](https://code.visualstudio.com/)
- [PlatformIO IDE Extension](https://platformio.org/install/ide?install=vscode)
### Installation Steps
1. **Clone or download this project**
```bash
git clone <repository-url>
cd DCC-Bench
```
2. **Open in VS Code**
- Open VS Code
- File → Open Folder → Select `DCC-Bench` folder
3. **Install Dependencies**
- PlatformIO will automatically download required libraries:
- TFT_eSPI (Display driver)
- XPT2046_Touchscreen (Touch controller)
- ArduinoJson (Configuration)
- DCCpp (DCC protocol)
4. **Build the project**
```bash
pio run
```
5. **Upload to ESP32-2432S028R**
```bash
pio run --target upload
```
6. **Monitor Serial Output** (optional)
```bash
pio device monitor
```
- Default baud rate: 115200
## 🎮 Usage
### First Power-On
1. **Connect USB-C cable** to ESP32-2432S028R
2. **Display initializes** - you should see the touchscreen UI
3. **Default state**:
- Power: OFF
- Mode: DC Analog
- Rails: 2-Rail
- Speed: 0%
### Basic Operation
#### Power Control
- Tap **[POWER]** button to toggle power ON/OFF
- Green = ON, Red = OFF
- Power must be ON for motor/DCC output
#### Mode Selection
- Tap **[MODE]** button to switch between DCC and DC Analog
- **⚠️ IMPORTANT**: Power automatically turns OFF when changing modes
- Cyan = DCC mode, Yellow = DC Analog mode
#### Rail Configuration
- Tap **[RAILS]** button to switch between 2-Rail and 3-Rail
- Relay activates in 3-Rail mode
- Can be changed while power is on
#### Speed Control
- Use the **horizontal slider** to adjust speed (0-100%)
- Drag the white knob or tap anywhere on the slider
- Real-time speed updates to motor/DCC controller
#### Direction Control
- Tap **[DIR]** button to toggle Forward/Reverse
- FWD = Forward, REV = Reverse
- Changes immediately if power is on
### Status Bar
The bottom status bar shows:
- Current power state
- Active mode (DCC/DC)
- Rail configuration (2-Rail/3-Rail)
- DCC address (if in DCC mode)
- Current speed and direction
## ⚙️ Configuration
### Settings Persistence
All settings are automatically saved to ESP32's Non-Volatile Storage (NVS):
- Power state
- Mode selection (DCC/Analog)
- Rail configuration (2-rail/3-rail)
- Speed value
- Direction
- DCC address
- DCC functions
Settings persist across power cycles and reboots.
### DCC Address Configuration
To change the DCC locomotive address:
1. Edit `src/main.cpp` or add a UI element
2. Default address is **3** (configurable in code)
3. Supports addresses 1-10239 (short and long addresses)
### Touch Calibration
If touch response is inaccurate, adjust calibration in `include/TouchscreenUI.h`:
```cpp
#define TS_MIN_X 200 // Adjust if needed
#define TS_MAX_X 3700 // Adjust if needed
#define TS_MIN_Y 200 // Adjust if needed
#define TS_MAX_Y 3750 // Adjust if needed
```
## 📝 Pin Customization
To change pin assignments, edit these files:
### Motor Controller Pins
Edit `include/MotorController.h`:
```cpp
#define MOTOR_PWM_PIN 18 // PWM speed control
#define MOTOR_DIR_PIN 19 // Direction control
#define MOTOR_BRAKE_PIN 23 // Brake control
```
### DCC Output Pins
Edit `include/DCCGenerator.h`:
```cpp
#define DCC_PIN_A 17 // DCC Signal A
#define DCC_PIN_B 16 // DCC Signal B (inverted)
```
### Relay Control Pin
Edit `include/RelayController.h`:
```cpp
#define RELAY_PIN 4 // 2-rail/3-rail relay control
```
## 📚 API Documentation
This project includes comprehensive API documentation using Doxygen.
### Generate Documentation
```bash
# Install Doxygen (if not already installed)
# Ubuntu/Debian: sudo apt-get install doxygen graphviz
# macOS: brew install doxygen graphviz
# Generate documentation
./generate_docs.sh
# View documentation
xdg-open doc/html/index.html # Linux
open doc/html/index.html # macOS
```
The documentation includes:
- Detailed class descriptions
- Function/method documentation
- Parameter and return value descriptions
- Code examples and usage notes
- Cross-referenced source code
See `doc/README.md` for more information.
## Project Structure
```
LocomotiveTestBench/
├── platformio.ini # PlatformIO configuration
├── Doxyfile # Doxygen configuration for API docs
├── generate_docs.sh # Script to generate documentation
├── README.md # This file
├── doc/ # Generated API documentation
│ └── html/ # HTML documentation (generated)
├── data/ # Filesystem (uploaded to LittleFS)
│ ├── index.html # Main web interface
│ ├── css/
│ │ ├── bootstrap.min.css # Bootstrap CSS (local)
│ │ └── style.css # Custom styles
│ └── js/
## 📂 Project Structure
```
DCC-Bench/
├── platformio.ini # PlatformIO configuration (ESP32-2432S028R)
├── README.md # This file
├── ESP32-2432S028R_MIGRATION.md # Migration details
├── WIRING_ESP32-2432S028R.md # Wiring guide
├── include/ # Header files
│ ├── Config.h # Configuration management (NVS)
│ ├── MotorController.h # DC motor control
│ ├── DCCGenerator.h # DCC signal generation
│ ├── RelayController.h # 2-rail/3-rail relay control
│ └── TouchscreenUI.h # Touchscreen interface
└── src/ # Source files
├── main.cpp # Main application
├── Config.cpp # Configuration implementation
├── MotorController.cpp # Motor control implementation
├── DCCGenerator.cpp # DCC implementation
├── RelayController.cpp # Relay control implementation
└── TouchscreenUI.cpp # UI implementation
```
## 🔧 Troubleshooting
### Display Issues
- **Blank screen**: Check USB power connection, verify 5V supply
- **Touch not responding**: Adjust touch calibration values in `TouchscreenUI.h`
- **Inverted display**: Change rotation in `TouchscreenUI::begin()`
- **Wrong colors**: Verify ILI9341 driver configuration in `platformio.ini`
### Motor Not Running (DC Mode)
- Verify mode is set to "DC Analog" (yellow button)
- Check power is ON (green button)
- Verify motor controller connections
- Check pin assignments match your wiring
- Use serial monitor to verify commands
### DCC Not Working
- Verify mode is set to "DCC" (cyan button)
- Check power is ON
- Verify DCC booster is connected and powered
- Check DCC signal with oscilloscope (GPIO 17, 16)
- Verify DCC address matches your locomotive
- Check locomotive is DCC-compatible
- Verify correct address is programmed in locomotive
### Upload Failed
- Check USB cable connection
- Try different USB port
- Press BOOT button on ESP32 during upload
- Check correct board selected in platformio.ini
## Technical Details
### DCC Protocol Implementation
- NMRA DCC Standard compliant
- 128-step speed control
- Function groups support (F0-F12 currently implemented)
- Configurable preamble (14 bits)
- Error detection with XOR checksum
### PWM Specifications (DC Mode)
- Frequency: 20 kHz
- Resolution: 8-bit (0-255)
- Duty cycle: 0-100% (mapped from speed)
### WiFi Specifications
- AP Mode: 802.11 b/g/n
- Client Mode: Auto-reconnect enabled
- Default reconnect interval: 30 seconds
## Safety Notes
⚠️ **Important Safety Information**
- Always disconnect power before wiring changes
- Use appropriate fuses for your scale
- Never exceed voltage ratings of your locomotives
- LM18200 requires adequate heat sinking
- Test with low voltage before full power
- Emergency stop should be easily accessible
## Future Enhancements
Potential features for future versions:
- [ ] PWM frequency adjustment
- [ ] Current monitoring and overload protection
- [ ] Multiple locomotive support
- [ ] Consist/multi-unit control
- [ ] Extended DCC functions (F13-F28)
- [ ] MQTT integration
- [ ] Locomotive profile storage
- [ ] Mobile app
## License
This project is provided as-is for educational and hobbyist purposes.
## Credits
### Relay Not Switching
- Check relay module power (5V and GND)
- Verify GPIO 4 connection to relay signal pin
- Listen for relay click when toggling 2-rail/3-rail
- Test relay with multimeter (continuity test)
### Settings Not Saving
- Check serial monitor for NVS errors
- Try factory reset (clear NVS partition)
- Verify ESP32 flash has NVS partition
### Serial Monitor Shows Errors
- Check all #include statements resolved
- Verify all libraries installed via PlatformIO
- Check for pin conflicts
- Review error messages for specific issues
## 📋 Technical Specifications
### Software
- **Platform**: PlatformIO with Arduino framework
- **Libraries**:
- TFT_eSPI (Display driver)
- XPT2046_Touchscreen (Touch controller)
- ArduinoJson (Configuration)
- DCCpp (DCC protocol from Locoduino)
- **Storage**: ESP32 NVS (Non-Volatile Storage)
### Hardware Limits
- **PWM Frequency**: 20kHz (motor control)
- **DCC Timing**: NMRA standard compliant
- **Touch**: Resistive (pressure-sensitive)
- **Display**: 320x240 pixels, 65K colors
## 🤝 Support & Contributing
For issues, questions, or contributions:
- Check serial monitor output for debugging (115200 baud)
- Verify hardware connections match pin assignments
- Review **[WIRING_ESP32-2432S028R.md](WIRING_ESP32-2432S028R.md)**
- Check **[ESP32-2432S028R_MIGRATION.md](ESP32-2432S028R_MIGRATION.md)** for migration details
- Test with known-good locomotive
## 📄 License
This project is open source. Check repository for license details.
---
**Version**: 2.0 (ESP32-2432S028R Edition)
**Last Updated**: December 2025
**Compatible Hardware**: ESP32-2432S028R (ESP32 with ILI9341 touchscreen)
**Framework**: Arduino for ESP32 via PlatformIO

117
ESP32/DCC-Bench/SIMPLIFIED_WIRING.md Normal file
View File

@@ -0,0 +1,117 @@
# Simplified Wiring Diagram
## The Key Insight: One Driver for Everything! 🎯
**You only need ONE LM18200 H-Bridge driver** - it handles both DC and DCC modes.
The ESP32 just sends different signals to the same pins depending on which mode you select:
```
ESP32-2432S028R
┌─────────────┐
│ │
GPIO 18 ─┤PWM / DCC_A │───┐
GPIO 19 ─┤DIR / DCC_B │───┤
GPIO 23 ─┤BRAKE │───┤
GPIO 4 ─┤RELAY │───┼──→ To Relay Module
GND ─┤ │───┤
5V ─┤ │───┤
└─────────────┘ │
│
↓
LM18200 H-Bridge
┌──────────────┐
GPIO 18 ───┤ PWM Input │
GPIO 19 ───┤ DIR Input │
GPIO 23 ───┤ BRAKE │
GND ───┤ GND │
5V ───┤ VCC (logic) │
12-18V ───┤ VS (power) │
│ │
│ OUT1 OUT2 │
└───┬──────┬───┘
│ │
↓ ↓
Track Rail 1 & 2
```
## How It Works
### DC Analog Mode
When you select **DC Analog** mode in the UI:
- GPIO 18 outputs **20kHz PWM** (0-100% duty cycle for speed)
- GPIO 19 outputs **HIGH or LOW** (sets direction: FWD or REV)
- LM18200 amplifies this to create variable DC voltage on the track
- Your DC locomotive responds to the voltage
### DCC Digital Mode
When you select **DCC** mode in the UI:
- GPIO 18 outputs **DCC Signal A** (square wave: 58μs or 100μs pulses)
- GPIO 19 outputs **DCC Signal B** (inverted version of Signal A)
- LM18200 amplifies these to create DCC waveform on the track
- Your DCC decoder locomotive responds to the digital commands
## Complete Connection List
### LM18200 to ESP32
| LM18200 Pin | ESP32 GPIO | Purpose |
|-------------|------------|---------|
| PWM Input | 18 | Speed (DC) / DCC Signal A (DCC) |
| Direction Input | 19 | Direction (DC) / DCC Signal B (DCC) |
| Brake Input | 23 | Emergency stop |
| GND | GND | Ground reference |
| VCC (logic) | 5V | Control logic power |
### LM18200 Power & Outputs
| LM18200 Pin | Connection | Purpose |
|-------------|------------|---------|
| VS (motor power) | 12-18V supply + | High current power |
| GND (power) | 12-18V supply - | Power ground |
| OUT1 | Track Rail 1 | Amplified output |
| OUT2 | Track Rail 2 | Amplified output |
### Relay Module (2-rail/3-rail switching)
| Relay Pin | ESP32 GPIO | Purpose |
|-----------|------------|---------|
| Signal IN | 4 | Relay control |
| VCC | 5V | Relay power |
| GND | GND | Ground |
### Power Supply Connections
```
12-18V Power Supply
├─→ LM18200 VS (motor power)
├─→ DC-DC Buck Converter → 5V → ESP32 + Relay + LM18200 VCC
└─→ GND (common ground)
```
## Why This Works
The LM18200 is just an amplifier. It doesn't care if you're feeding it:
- PWM signals (for DC speed control)
- DCC square waves (for digital commands)
It simply takes the 3.3V logic signals from the ESP32 and amplifies them to track voltage (12-18V).
**In DC mode**: The amplified PWM creates variable DC voltage
**In DCC mode**: The amplified square waves create the DCC signal
## Safety Notes
✅ **Always power OFF before switching modes** (automatic in the UI)
✅ **Common ground** - All GND connections must be tied together
✅ **Heat sink** - LM18200 can get hot, use appropriate heat sinking
✅ **Fusing** - Add fuse on track output for overcurrent protection
## No Separate DCC Booster Needed!
You do **NOT** need:
- ❌ Separate DCC booster circuit
- ❌ Different outputs for DC vs DCC
- ❌ Mode selection switches in hardware
Everything is handled in software by the ESP32 touchscreen UI.
---
**Bottom Line**: Wire up ONE LM18200, and you're done. The ESP32 software handles the rest!

284
ESP32/DCC-Bench/TESTING_CHECKLIST.md Normal file
View File

@@ -0,0 +1,284 @@
# 🔍 Pre-Flight Checklist for ESP32-2432S028R DCC Bench
## ✅ Hardware Assembly Checklist
### ESP32-2432S028R Module
- [ ] Module has USB-C port
- [ ] Display is ILI9341 (320x240)
- [ ] Touch controller is XPT2046
- [ ] Module powers on via USB-C
### Motor Driver Connection
- [ ] Motor driver is LM18200, L298N, or compatible
- [ ] ESP32 GPIO 18 → Motor Driver PWM
- [ ] ESP32 GPIO 19 → Motor Driver DIR
- [ ] ESP32 GPIO 23 → Motor Driver BRAKE
- [ ] ESP32 GND → Motor Driver GND
- [ ] ESP32 5V → Motor Driver VCC (logic)
- [ ] Power supply → Motor Driver Power In
- [ ] Motor/Track → Motor Driver Output
### DCC Booster Connection
- [ ] DCC booster compatible with logic-level inputs
- [ ] ESP32 GPIO 17 → DCC Booster IN_A
- [ ] ESP32 GPIO 16 → DCC Booster IN_B
- [ ] ESP32 GND → DCC Booster GND
- [ ] Power supply → DCC Booster Power
- [ ] Track → DCC Booster Output
### Relay Module Connection
- [ ] Relay module is 5V type
- [ ] ESP32 GPIO 4 → Relay IN
- [ ] ESP32 GND → Relay GND
- [ ] ESP32 5V → Relay VCC
- [ ] Track wiring connected to relay outputs (2-rail/3-rail config)
### Power Supply
- [ ] 12-18V power supply (depending on scale)
- [ ] DC-DC buck converter to 5V (if using single supply)
- [ ] All grounds connected together (common ground)
- [ ] Proper fusing on track outputs
## ✅ Software Checklist
### Development Environment
- [ ] Visual Studio Code installed
- [ ] PlatformIO extension installed
- [ ] Project opens without errors
- [ ] Git branch: `ESP32-2432` (feature branch)
### Project Configuration
- [ ] `platformio.ini` shows `[env:esp32-2432s028r]`
- [ ] Libraries in `lib_deps`:
- [ ] TFT_eSPI
- [ ] XPT2046_Touchscreen
- [ ] ArduinoJson
- [ ] DCCpp
- [ ] Build flags include TFT configuration
### Code Files Present
- [ ] `include/TouchscreenUI.h`
- [ ] `src/TouchscreenUI.cpp`
- [ ] `include/RelayController.h`
- [ ] `src/RelayController.cpp`
- [ ] Updated `Config.h` (no WiFi structs)
- [ ] Updated `Config.cpp`
- [ ] Updated `main.cpp`
### Pin Assignments Verified
- [ ] DCC: GPIO 17, 16 (not conflicting)
- [ ] Motor: GPIO 18, 19, 23
- [ ] Relay: GPIO 4
- [ ] Touch CS: GPIO 22 (defined in platformio.ini)
## ✅ Build and Upload Checklist
### Build Process
- [ ] Run `pio run` - builds without errors
- [ ] Check for warnings - resolve if critical
- [ ] Verify binary size fits in flash
### Upload Process
- [ ] ESP32-2432S028R connected via USB-C
- [ ] Correct COM port selected
- [ ] Run `pio run --target upload`
- [ ] Upload completes successfully (100%)
### Serial Monitor
- [ ] Run `pio device monitor`
- [ ] Baud rate: 115200
- [ ] See boot messages
- [ ] See "Locomotive Test Bench v2.0"
- [ ] See "Configuration loaded"
- [ ] See "Relay Controller initialized"
- [ ] See "Touchscreen UI initialized"
- [ ] No error messages
## ✅ Functional Testing Checklist
### Display Testing
- [ ] Display shows UI immediately
- [ ] All buttons visible
- [ ] Text is readable
- [ ] Colors correct (not inverted)
- [ ] Status bar shows at bottom
### Touch Testing
- [ ] Tap [POWER] button - responds
- [ ] Tap [MODE] button - responds
- [ ] Tap [RAILS] button - responds
- [ ] Tap [DIR] button - responds
- [ ] Drag speed slider - responds
- [ ] Touch accuracy is good (±5mm)
### Power Control Testing
- [ ] Power starts OFF (red button)
- [ ] Tap power - turns ON (green)
- [ ] Status bar shows "PWR:ON"
- [ ] Tap again - turns OFF (red)
- [ ] Serial shows power state changes
### Mode Switching Testing
- [ ] Default mode shows (DC/Analog - yellow)
- [ ] Tap mode button
- [ ] Power automatically turns OFF
- [ ] Mode switches (DCC - cyan)
- [ ] Serial shows "Power automatically turned OFF"
- [ ] Tap mode again - switches back
- [ ] Power still OFF (safety feature working)
### Rail Configuration Testing
- [ ] Default: 2-Rail
- [ ] Tap [RAILS] button
- [ ] Relay clicks (audible)
- [ ] Button shows "3-Rail"
- [ ] Status bar updates
- [ ] Tap again - relay clicks again
- [ ] Button shows "2-Rail"
### Direction Control Testing
- [ ] Default: FWD
- [ ] Tap [DIR] button
- [ ] Changes to REV
- [ ] Status bar updates
- [ ] Tap again - back to FWD
### Speed Control Testing
- [ ] Slider starts at 0%
- [ ] Drag slider right
- [ ] Speed value updates in real-time
- [ ] Status bar shows new speed
- [ ] Slider visual updates (active portion grows)
- [ ] Tap directly on slider - jumps to that position
### Settings Persistence Testing
- [ ] Set specific values:
- [ ] Power: ON
- [ ] Mode: DCC
- [ ] Rails: 3-Rail
- [ ] Speed: 50%
- [ ] Direction: REV
- [ ] Note all values
- [ ] Power cycle ESP32 (unplug/replug USB)
- [ ] Verify all settings retained after reboot
- [ ] Serial shows loaded values match
## ✅ Output Testing Checklist
### DC Analog Mode Testing (No Load)
- [ ] Select DC Analog mode
- [ ] Power ON
- [ ] Set speed to 25%
- [ ] Measure voltage on motor driver outputs
- [ ] Voltage increases with speed slider
- [ ] Change direction
- [ ] Polarity reverses
- [ ] Emergency stop (power OFF) - voltage goes to 0
### DCC Mode Testing (with Oscilloscope)
- [ ] Select DCC mode
- [ ] Power ON
- [ ] Connect oscilloscope to GPIO 17 and 16
- [ ] Verify square wave signals
- [ ] Signals are inverted relative to each other
- [ ] Measure timing:
- [ ] '1' bit: ~58μs half-cycle
- [ ] '0' bit: ~100μs half-cycle
- [ ] Signals clean (no ringing or noise)
### Relay Testing
- [ ] Toggle 2-Rail/3-Rail multiple times
- [ ] Relay clicks each time
- [ ] No missed toggles
- [ ] Test with multimeter on relay contacts
- [ ] Continuity changes with relay state
## ✅ Safety Testing Checklist
### Mode Change Safety
- [ ] Power ON in DC mode
- [ ] Switch to DCC mode
- [ ] Verify power turns OFF automatically
- [ ] Serial confirms automatic power-off
- [ ] Repeat with DCC → DC
- [ ] Safety feature works both ways
### Emergency Stop
- [ ] Power ON with speed at 50%
- [ ] Tap power button
- [ ] Output stops immediately
- [ ] Speed value retained (but no output)
- [ ] Can restart by tapping power again
### Overload Protection
- [ ] Motor driver has current limiting
- [ ] Track has appropriate fuse
- [ ] Test emergency stop with load
## ✅ Integration Testing Checklist
### With DC Locomotive
- [ ] Connect DC locomotive to track
- [ ] Select DC Analog mode
- [ ] Power ON
- [ ] Start at low speed (10-20%)
- [ ] Locomotive moves smoothly
- [ ] Increase speed gradually - smooth acceleration
- [ ] Change direction - locomotive reverses
- [ ] Emergency stop works
- [ ] No unusual sounds or heating
### With DCC Locomotive
- [ ] Connect DCC locomotive to track (via booster)
- [ ] Verify DCC address matches locomotive
- [ ] Select DCC mode
- [ ] Power ON
- [ ] Start at low speed (10-20%)
- [ ] Locomotive responds to DCC commands
- [ ] Increase speed - smooth operation
- [ ] Change direction - locomotive reverses
- [ ] Power OFF - locomotive stops
## ⚠️ Known Issues / Notes
### To Monitor
- [ ] ESP32 temperature during extended use
- [ ] Motor driver heat dissipation
- [ ] Power supply voltage under load
- [ ] Touch calibration drift over time
### Future Improvements
- [ ] Add DCC address entry via touchscreen
- [ ] Add DCC function buttons (F0-F12)
- [ ] Add current monitoring display
- [ ] Add speed presets
- [ ] Add locomotive profiles
## 📋 Test Results
**Test Date**: __________
**Tester**: __________
**ESP32 S/N**: __________
**Firmware Version**: 2.0
### Overall Results
- [ ] All hardware tests PASS
- [ ] All software tests PASS
- [ ] All functional tests PASS
- [ ] All safety tests PASS
- [ ] Ready for production use
### Issues Found
1. ________________________________________________
2. ________________________________________________
3. ________________________________________________
### Notes
___________________________________________________
___________________________________________________
___________________________________________________
---
**Checklist Version**: 1.0
**Last Updated**: December 2025

312
ESP32/DCC-Bench/WIRING.md Normal file
View File

@@ -0,0 +1,312 @@
# Simplified Wiring Diagram
## The Key Insight: One Driver for Everything! 🎯
**You only need ONE LM18200 H-Bridge driver** - it handles both DC and DCC modes.
The ESP32 just sends different signals to the same pins depending on which mode you select:
```
ESP32-2432S028R
┌─────────────┐
│ │
GPIO 18 ─┤PWM / DCC_A │───┐
GPIO 19 ─┤DIR / DCC_B │───┤
GPIO 23 ─┤BRAKE │───┤
GPIO 4 ─┤RELAY │───┼──→ To Relay Module
GPIO 35 ─┤ADC (ACK) │◄──┼──→ From ACS712 OUT
GND ─┤ │───┤
5V ─┤ │───┤
└─────────────┘ │
│
↓
LM18200 H-Bridge Module
┌──────────────┐
GPIO 18 ───┤ PWM Input │
GPIO 19 ───┤ DIR Input │
GPIO 23 ───┤ BRAKE │
GND ───┤ GND │
5V ───┤ VCC (logic) │
12-18V ───┤ VS (power) │
│ │
│ OUT1 OUT2 │
└───┬──────┬───┘
│ │
↓ ↓
ACS712 Current Sensor
┌──────────────┐
OUT1 ───┤ IP+ │
│ │
To Track ◄──┤ IP- OUT ├──→ GPIO 35 (ADC)
Rail 1 │ │
│ VCC GND ├──→ GND
5V ───┤ │
└──────────────┘
│
↓
Track Rail 1
│
(Rail 2 from OUT2)
```
## How It Works
### DC Analog Mode
When you select **DC Analog** mode in the UI:
- GPIO 18 outputs **20kHz PWM** (0-100% duty cycle for speed)
- GPIO 19 outputs **HIGH or LOW** (sets direction: FWD or REV)
- LM18200 amplifies this to create variable DC voltage on the track
- Your DC locomotive responds to the voltage
- ACS712 monitors current (optional - can display on screen)
### DCC Digital Mode
When you select **DCC** mode in the UI:
- GPIO 18 outputs **DCC Signal A** (square wave: 58μs or 100μs pulses)
- GPIO 19 outputs **DCC Signal B** (inverted version of Signal A)
- LM18200 amplifies these to create DCC waveform on the track
- Your DCC decoder locomotive responds to the digital commands
- ACS712 monitors current for normal operation
### DCC Programming Mode
When you press **[PROG]** button in DCC mode:
- GPIO 18/19 send **service mode packets** (22-bit preamble)
- Decoder receives CV programming commands
- Decoder responds with **60mA ACK pulse** for 6ms if command valid
- ACS712 detects current spike and sends voltage to GPIO 35
- ESP32 reads ADC and confirms successful programming
- UI shows "Verified!" or "Failed - No ACK"
## Complete Connection List
### LM18200 Module to ESP32
| LM18200 Pin | ESP32 GPIO | Purpose |
|-------------|------------|---------|
| PWM Input | 18 | Speed (DC) / DCC Signal A (DCC) |
| Direction Input | 19 | Direction (DC) / DCC Signal B (DCC) |
| Brake Input | 23 | Emergency stop |
| GND | GND | Ground reference |
| VCC (logic) | 5V | Control logic power |
### LM18200 Module Power & Outputs
| LM18200 Pin | Connection | Purpose |
|-------------|------------|---------|
| VS (motor power) | 12-18V supply + | High current power |
| GND (power) | 12-18V supply - | Power ground |
| OUT1 | ACS712 IP+ | To current sensor |
| OUT2 | Track Rail 2 | Direct to track |
### ACS712 Current Sensor Module
| ACS712 Pin | Connection | Purpose |
|------------|------------|---------|
| IP+ | LM18200 OUT1 | Current input (from driver) |
| IP- | Track Rail 1 | Current output (to track) |
| VCC | 5V | Sensor power |
| GND | GND | Ground reference |
| OUT | GPIO 35 (ADC) | Analog current reading |
**ACS712 Variants:**
- **ACS712-05A**: ±5A max (recommended for small locomotives)
- **ACS712-20A**: ±20A max (for larger locos or multiple)
- **ACS712-30A**: ±30A max (overkill, but works)
**Output Voltage:**
- At 0A: 2.5V (Vcc/2)
- Sensitivity:
- 5A model: 185 mV/A
- 20A model: 100 mV/A
- 30A model: 66 mV/A
- ACK Detection (60mA): ~2.5V + (0.06A × sensitivity)
### Relay Module (2-rail/3-rail switching)
| Relay Pin | ESP32 GPIO | Purpose |
|-----------|------------|---------|
| Signal IN | 4 | Relay control |
| VCC | 5V | Relay power |
| GND | GND | Ground |
### Power Supply Connections
```
12-18V Power Supply
├─→ LM18200 VS (motor power)
├─→ DC-DC Buck Converter → 5V → ESP32 + Relay + LM18200 VCC + ACS712 VCC
└─→ GND (common ground for all modules)
```
## ACS712 Current Sensor Details
### Why ACS712?
✅ **Hall-effect sensor** - Electrically isolated, no voltage drop
✅ **Analog output** - Easy to read with ESP32 ADC
✅ **Bi-directional** - Measures current in both directions
✅ **Module available** - Pre-built boards with 5V supply
✅ **ACK Detection** - Sensitive enough to detect 60mA programming pulses
### Wiring the ACS712
The ACS712 goes **in series** with ONE track rail:
```
LM18200 OUT1 ──→ [ACS712 IP+]──[IP-] ──→ Track Rail 1
│
[OUT] ──→ GPIO 35 (ESP32 ADC)
│
[VCC] ──← 5V
│
[GND] ──← GND
LM18200 OUT2 ──────────────────────────→ Track Rail 2
```
### Reading Current in Software
The ACS712 outputs an analog voltage proportional to current:
```cpp
// ACS712 5A model example
#define ACS712_PIN 35
#define ACS712_SENSITIVITY 0.185 // 185 mV/A for 5A model
#define ACS712_ZERO 2.5 // 2.5V at 0A (Vcc/2)
float readCurrent() {
int adcValue = analogRead(ACS712_PIN);
float voltage = (adcValue / 4095.0) * 3.3; // Convert to voltage
float current = (voltage - ACS712_ZERO) / ACS712_SENSITIVITY;
return current; // Returns current in Amps
}
```
### ACK Detection with ACS712
For DCC programming track ACK (60mA pulse):
```cpp
bool DCCGenerator::waitForAck() {
#define CURRENT_SENSE_PIN 35
#define ACS712_ZERO_VOLTAGE 2.5
#define ACS712_SENSITIVITY 0.185 // For 5A model
#define ACK_CURRENT_THRESHOLD 0.060 // 60mA in Amps
unsigned long startTime = millis();
// Wait up to 20ms for ACK pulse
while (millis() - startTime < 20) {
int adcValue = analogRead(CURRENT_SENSE_PIN);
float voltage = (adcValue / 4095.0) * 3.3;
float current = abs((voltage - ACS712_ZERO_VOLTAGE) / ACS712_SENSITIVITY);
// If current spike detected (60mA+)
if (current > ACK_CURRENT_THRESHOLD) {
Serial.println("ACK detected!");
return true;
}
delayMicroseconds(100);
}
Serial.println("No ACK");
return false;
}
```
### Calibration
Before using ACK detection, calibrate the zero point:
1. **Power on** with no locomotive on track
2. **Read GPIO 35** multiple times and average
3. **Calculate zero voltage** (should be ~2.5V)
4. **Update ACS712_ZERO** in code if needed
```cpp
// Calibration routine (run once)
void calibrateCurrentSensor() {
float sum = 0;
for (int i = 0; i < 100; i++) {
int adc = analogRead(35);
float voltage = (adc / 4095.0) * 3.3;
sum += voltage;
delay(10);
}
float zeroVoltage = sum / 100.0;
Serial.printf("ACS712 Zero Point: %.3fV\n", zeroVoltage);
}
```
## Why This Works
The LM18200 is just an amplifier. It doesn't care if you're feeding it:
- PWM signals (for DC speed control)
- DCC square waves (for digital commands)
It simply takes the 3.3V logic signals from the ESP32 and amplifies them to track voltage (12-18V).
**In DC mode**: The amplified PWM creates variable DC voltage
**In DCC mode**: The amplified square waves create the DCC signal
**In Programming mode**: The ACS712 detects decoder ACK pulses
### Benefits of Using ACS712
✅ **No voltage drop** - Hall-effect sensor doesn't load the circuit
✅ **Isolated measurement** - Safe for ESP32 ADC input
✅ **Both directions** - Works with forward/reverse current
✅ **Module form** - Easy to wire, includes filtering capacitors
✅ **DCC ACK capable** - Sensitive enough for 60mA detection
✅ **Current monitoring** - Can display real-time current on UI
✅ **Overcurrent detect** - Software can trigger emergency stop
## Safety Notes
✅ **Always power OFF before switching modes** (automatic in the UI)
✅ **Common ground** - All GND connections must be tied together
✅ **Heat sink** - LM18200 can get hot, use appropriate heat sinking
✅ **Fusing** - Add fuse on track output for overcurrent protection
✅ **ACS712 rating** - Use 5A model for most O-scale locos, 20A for larger
✅ **Short circuit** - Monitor current and auto-shutdown on excessive draw
## Shopping List
### Required Components
- ✅ **ESP32-2432S028R** module (includes display + touch)
- ✅ **LM18200 H-Bridge module** (or bare IC + heatsink)
- ✅ **ACS712 current sensor module** (5A or 20A version)
- ✅ **5V relay module** (for 2-rail/3-rail switching)
- ✅ **12-18V power supply** (2A minimum)
- ✅ **DC-DC buck converter** (12-18V to 5V, 1A)
- ✅ **Wires** (22-24 AWG for logic, 18-20 AWG for track)
- ✅ **Fuse holder** + appropriate fuse
### Optional but Recommended
- 🔧 Heatsink for LM18200 (if using bare IC)
- 🔧 Terminal blocks for easy track connections
- 🔧 Emergency stop button (wired to GPIO 23 or power)
- 🔧 Case/enclosure for professional finish
## No Separate DCC Booster Needed!
You do **NOT** need:
- ❌ Separate DCC booster circuit
- ❌ Different outputs for DC vs DCC
- ❌ Mode selection switches in hardware
- ❌ Separate programming track booster
- ❌ Complex current sensing circuits (ACS712 handles it!)
Everything is handled in software by the ESP32 touchscreen UI.
## Connection Summary
**Minimum wiring** for full functionality:
1. **ESP32 to LM18200**: 5 wires (GPIO 18, 19, 23, GND, 5V)
2. **LM18200 to ACS712**: 2 wires (OUT1 to IP+, IP- continues to track)
3. **ACS712 to ESP32**: 3 wires (OUT to GPIO 35, VCC to 5V, GND)
4. **ESP32 to Relay**: 3 wires (GPIO 4, 5V, GND)
5. **Power supply**: 12-18V to LM18200, 5V to all logic
Total: **~16 connections** for a complete dual-mode test bench with programming!
---
**Bottom Line**: Wire up ONE LM18200 + ONE ACS712, and you get:
- ✅ DC analog speed control
- ✅ DCC digital operation
- ✅ DCC programming track with ACK verification
- ✅ Real-time current monitoring
- ✅ Overcurrent protection capability

203
ESP32/DCC-Bench/WIRING_ESP32-2432S028R.md Normal file
View File

@@ -0,0 +1,203 @@
# ESP32-2432S028R Wiring Guide
## Overview
This document describes the external connections needed for the DCC-Bench project using the ESP32-2432S028R module.
## Built-in Components (No Wiring Needed)
The ESP32-2432S028R module includes:
- ✅ ILI9341 TFT Display (320x240)
- ✅ XPT2046 Touch Controller
- ✅ MicroSD Card Slot
- ✅ USB-C Power/Programming
## External Connections Required
### 1. LM18200 H-Bridge Driver (Universal DC/DCC Output)
The LM18200 serves as **BOTH** the DC motor controller AND DCC signal booster.
It's the same hardware - the ESP32 just sends different signals depending on mode:
- **DC Mode**: ESP32 sends PWM + direction signals
- **DCC Mode**: ESP32 sends DCC digital signals
```
ESP32 GPIO 18 (PWM/DCC_A) ──→ LM18200 PWM Input
ESP32 GPIO 19 (DIR/DCC_B) ──→ LM18200 Direction Input
ESP32 GPIO 23 (BRAKE) ──→ LM18200 Brake Input
ESP32 GND ──→ LM18200 GND
ESP32 5V ──→ LM18200 Logic VCC
Power Supply (12-18V) ──→ LM18200 Motor Power
```
**LM18200 Outputs (to Track):**
```
0.1Ω 1W Current Sense
LM18200 OUT1 ──→ ───┬──────╱╲╲╲────── Track Rail 1
│
├── 1kΩ ──┬──── GPIO 35 (ADC - ACK Detect)
│ 10kΩ
│ │
LM18200 OUT2 ──→ ───┴──────────┴──── Track Rail 2 (GND)
```
**How it Works:**
- **DC Analog Mode**: GPIO 18 outputs PWM for speed, GPIO 19 sets direction
- **DCC Digital Mode**: GPIO 18 outputs DCC signal A, GPIO 19 outputs DCC signal B (inverted)
- The LM18200 amplifies whichever signal type to track voltage
- GPIO 23 (BRAKE) can force both outputs LOW for emergency stop
- **Programming Track**: Current sense resistor (0.1Ω) detects 60mA ACK pulses from decoder
### 2. 2-Rail/3-Rail Relay Module
```
ESP32 GPIO 4 ──→ Relay Module Signal Input
ESP32 GND ──→ Relay Module GND
ESP32 5V ──→ Relay Module VCC
```
**Relay Outputs:**
Configure the relay to switch between 2-rail and 3-rail track wiring:
- **2-Rail Mode** (Relay OFF): Standard two-rail configuration
- **3-Rail Mode** (Relay ON): Center rail + outer rails configuration
### 3. Power Supply
The ESP32-2432S028R can be powered via:
- **USB-C**: 5V from USB (programming and operation)
- **5V Pin**: External 5V power supply (500mA minimum)
**Recommended Setup:**
```
12-18V Power Supply ──→ DC-DC Buck Converter ──→ 5V @ 1A ──→ ESP32 5V Pin
└──→ Motor Controller Power
└──→ DCC Booster Power
```
## Pin Summary Table
| Connection | ESP32 Pin | External Device | Notes |
|------------|-----------|-----------------|-------|
| PWM/DCC_A | GPIO 18 | LM18200 PWM | DC mode: 20kHz PWM / DCC mode: DCC signal A |
| DIR/DCC_B | GPIO 19 | LM18200 DIR | DC mode: Direction / DCC mode: DCC signal B |
| Brake | GPIO 23 | LM18200 BRAKE | Active LOW brake / Emergency stop |
| Relay Control | GPIO 4 | Relay Module IN | HIGH=3-Rail |
| ACK Detect | GPIO 35 | Current Sense | ADC input for programming track ACK |
| Ground | GND | All GNDs | Common ground |
| Power | 5V | Logic Power | 500mA-1A |
## Safety Notes
⚠️ **IMPORTANT SAFETY WARNINGS:**
1. **Electrical Isolation**: Keep low-voltage control circuits (ESP32) separated from high-voltage motor/track circuits
2. **Common Ground**: Ensure all components share a common ground reference
3. **Power Rating**: Motor controller must be rated for your locomotive's current draw
4. **Fusing**: Install appropriate fuses on track outputs
5. **Emergency Stop**: Implement physical emergency stop button if needed
6. **Polarity**: Double-check DCC booster polarity before connecting to track
## Track Connection
The LM18200 outputs connect directly to the track in both modes:
```
LM18200 OUT1 ──→ Track Rail 1
LM18200 OUT2 ──→ Track Rail 2
```
**Operation:**
- **DC Mode**: LM18200 outputs PWM voltage (polarity sets direction)
- **DCC Mode**: LM18200 outputs amplified DCC square wave signals
- Same physical connections, different signal types
## Testing Procedure
1. **Power Up Test**
- Connect only USB power
- Verify display shows UI
- Touch screen should be responsive
2. **Relay Test**
- Toggle 2-Rail/3-Rail button
- Listen for relay click
- Verify relay LED changes state
3. **DCC Signal Test** (use oscilloscope)
- Select DCC mode
- Power ON
- Measure GPIO 18 and 19 for square wave signals
- Verify ~58μs for '1' bits, ~100μs for '0' bits
- Signals should be inverted relative to each other
- Check LM18200 outputs for amplified signals (track voltage)
4. **DC Motor Test** (without load)
- Select DC Analog mode
- Power ON
- Adjust speed slider
- Measure PWM on GPIO 18 with multimeter (average voltage should increase with speed)
- Measure LM18200 outputs for amplified PWM
5. **Track Test** (with locomotive)
- Start with low speed (10-20%)
- Gradually increase speed
- Test direction change
- Verify emergency stop (Power OFF button)
## Troubleshooting
| Problem | Possible Cause | Solution |
|---------|----------------|----------|
| Display blank | No power | Check USB/5V power connection |
| Touch not working | Wrong calibration | Adjust TS_MIN/MAX values in code |
| No DCC signal | Not powered on | Press Power button in UI |
| Motor not running | Wrong mode | Verify DC Analog mode selected |
| Relay not switching | No 5V power | Check relay module power |
| Erratic behavior | Ground loop | Ensure single common ground point |
## Component Recommendations
### H-Bridge Driver (DC & DCC):
- **LM18200T** (3A continuous, 6A peak) - **RECOMMENDED**
- Single chip handles both DC and DCC modes
- Built-in thermal shutdown
- Built-in current limiting
- **L298N module** (2A per channel)
- Readily available, inexpensive
- Less efficient than LM18200
- **BTS7960 motor driver** (43A capable)
- Overkill for most model trains
- Good for large scale locomotives
### Relay Module:
- 5V single-channel relay module
- Optocoupler isolated
- Active HIGH trigger
## Schematic Reference
```
┌─────────────────┐
│ ESP32-2432S028R│
│ (Built-in) │
│ - TFT Display │
│ - Touch Screen │
└────────┬────────┘
│
┌───────────────┬────────┼────────┬───────────────┐
│ │ │ │ │
GPIO 17 GPIO 16 GPIO 18 GPIO 19 GPIO 4
(DCC_A) (DCC_B) (PWM) (DIR) (RELAY)
│ │ │ │ │
┌─────▼─────┐ │ │ │ ┌─────▼─────┐
│ DCC │◄────────┘ │ │ │ Relay │
│ Booster │ │ │ │ Module │
└─────┬─────┘ │ │ └─────┬─────┘
│ ┌─────▼────────▼─┐ │
│ │ Motor Driver │ │
│ │ (LM18200) │ │
│ └────────┬───────┘ │
│ │ │
┌─────▼──────────────────────────┼─────────────────────▼─────┐
│ Track Output │
│ (DCC or DC Analog depending on mode selection in UI) │
└──────────────────────────────────────────────────────────────┘
```

110
ESP32/DCC-Bench/data/README.md Normal file
View File

@@ -0,0 +1,110 @@
# Web Interface Files Setup
This directory contains the web interface files that will be uploaded to the ESP32's LittleFS filesystem.
## Structure
```
data/
├── index.html # Main HTML page
├── css/
│ ├── bootstrap.min.css # Bootstrap CSS (local copy)
│ └── style.css # Custom styles
└── js/
├── bootstrap.bundle.min.js # Bootstrap JS (local copy)
└── app.js # Application JavaScript
```
## How to Upload Files to ESP32
### Method 1: Using PlatformIO (Recommended)
1. **Install LittleFS Uploader**:
- In VS Code, open PlatformIO Home
- Go to Platforms → Espressif 32
- Make sure it's installed/updated
2. **Download Bootstrap Files** (if not already present):
Download these files and place them in the appropriate directories:
- **Bootstrap CSS** (v5.3.0):
- URL: https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css
- Save to: `data/css/bootstrap.min.css`
- **Bootstrap JS** (v5.3.0):
- URL: https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js
- Save to: `data/js/bootstrap.bundle.min.js`
3. **Upload Filesystem**:
- In VS Code, click PlatformIO icon
- Under PROJECT TASKS → env:wemos_d1_mini32
- Click "Upload Filesystem Image"
- Wait for upload to complete
### Method 2: Manual Download and Upload
If you need to download Bootstrap files manually:
```bash
# Navigate to data directories
cd data/css
wget https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css
cd ../js
wget https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js
```
Or use curl:
```bash
cd data/css
curl -o bootstrap.min.css https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css
cd ../js
curl -o bootstrap.bundle.min.js https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js
```
### Verifying Upload
After uploading, you can verify the files are present by:
1. Opening Serial Monitor (115200 baud)
2. Look for "LittleFS mounted successfully" message
3. Access the web interface and check browser console for any 404 errors
## File Sizes (Approximate)
- `bootstrap.min.css`: ~190 KB
- `bootstrap.bundle.min.js`: ~220 KB
- `style.css`: ~1 KB
- `app.js`: ~4 KB
- `index.html`: ~4 KB
**Total**: ~420 KB (ESP32 has 1.5MB+ available for LittleFS)
## Benefits of LittleFS Approach
✅ **Better Organization**: Separate HTML, CSS, and JS files
✅ **Offline Operation**: Works without internet connection
✅ **Easier Maintenance**: Edit files without recompiling firmware
✅ **Faster Updates**: Only upload filesystem when web files change
✅ **Better Performance**: No need to parse embedded strings
✅ **Standard Development**: Use familiar web development workflow
## Troubleshooting
### LittleFS Mount Failed
- Ensure filesystem is properly formatted
- Try uploading filesystem image again
- Check serial output for detailed error messages
### 404 Errors on Static Files
- Verify files are in correct directories
- Check file names match exactly (case-sensitive)
- Re-upload filesystem image
### Bootstrap Not Loading
- Download Bootstrap files to `data/css/` and `data/js/`
- Upload filesystem image
- Clear browser cache and reload

6
ESP32/DCC-Bench/data/css/bootstrap.min.css vendored Normal file
View File

File diff suppressed because one or more lines are too long

44
ESP32/DCC-Bench/data/css/style.css Normal file
View File

@@ -0,0 +1,44 @@
body {
padding: 20px;
background-color: #f5f5f5;
}
.container {
max-width: 800px;
background: white;
padding: 30px;
border-radius: 10px;
box-shadow: 0 0 20px rgba(0,0,0,0.1);
}
.status-indicator {
width: 20px;
height: 20px;
border-radius: 50%;
display: inline-block;
margin-right: 10px;
}
.status-connected {
background-color: #28a745;
}
.status-disconnected {
background-color: #dc3545;
}
.speed-value {
font-size: 2em;
font-weight: bold;
text-align: center;
margin: 20px 0;
}
.function-btn {
margin: 5px;
}
.direction-indicator {
font-size: 1.2em;
margin-left: 10px;
}

27
ESP32/DCC-Bench/data/download_bootstrap.sh Normal file
View File

@@ -0,0 +1,27 @@
#!/bin/bash
# Script to download Bootstrap files for offline use
echo "Downloading Bootstrap 5.3.0 files..."
# Create directories if they don't exist
mkdir -p css
mkdir -p js
# Download Bootstrap CSS
echo "Downloading Bootstrap CSS..."
curl -L -o css/bootstrap.min.css https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css
# Download Bootstrap JS Bundle (includes Popper)
echo "Downloading Bootstrap JS Bundle..."
curl -L -o js/bootstrap.bundle.min.js https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js
echo ""
echo "Download complete!"
echo ""
echo "Files downloaded:"
echo " - css/bootstrap.min.css ($(du -h css/bootstrap.min.css | cut -f1))"
echo " - js/bootstrap.bundle.min.js ($(du -h js/bootstrap.bundle.min.js | cut -f1))"
echo ""
echo "Now you can upload the filesystem to your ESP32:"
echo " 1. In VS Code, open PlatformIO"
echo " 2. Click 'Upload Filesystem Image' under PROJECT TASKS"

124
ESP32/DCC-Bench/data/index.html Normal file
View File

@@ -0,0 +1,124 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Locomotive Test Bench</title>
<link href="/css/bootstrap.min.css" rel="stylesheet">
<link href="/css/style.css" rel="stylesheet">
</head>
<body>
<div class="container">
<h1 class="text-center mb-4">🚂 Locomotive Test Bench</h1>
<!-- Status Section -->
<div class="card mb-3">
<div class="card-body">
<h5 class="card-title">Status</h5>
<p><span class="status-indicator" id="statusIndicator"></span>
<span id="statusText">Connecting...</span></p>
<p class="mb-0"><small>IP: <span id="ipAddress">-</span></small></p>
</div>
</div>
<!-- Control Mode Section -->
<div class="card mb-3">
<div class="card-body">
<h5 class="card-title">Control Mode</h5>
<div class="btn-group w-100" role="group">
<input type="radio" class="btn-check" name="mode" id="modeAnalog" value="analog" autocomplete="off">
<label class="btn btn-outline-primary" for="modeAnalog">DC Analog</label>
<input type="radio" class="btn-check" name="mode" id="modeDCC" value="dcc" autocomplete="off">
<label class="btn btn-outline-primary" for="modeDCC">DCC Digital</label>
</div>
</div>
</div>
<!-- DCC Address Section -->
<div class="card mb-3" id="dccSection" style="display: none;">
<div class="card-body">
<h5 class="card-title">DCC Configuration</h5>
<div class="row">
<div class="col-md-8">
<label for="dccAddress" class="form-label">Locomotive Address</label>
<input type="number" class="form-control" id="dccAddress" min="1" max="10239" value="3">
</div>
<div class="col-md-4">
<label class="form-label">&nbsp;</label>
<button class="btn btn-primary w-100" onclick="setDCCAddress()">Set</button>
</div>
</div>
</div>
</div>
<!-- Speed Control Section -->
<div class="card mb-3">
<div class="card-body">
<h5 class="card-title">Speed Control
<span class="direction-indicator" id="directionIndicator">→</span>
</h5>
<div class="speed-value" id="speedValue">0%</div>
<input type="range" class="form-range" id="speedSlider" min="0" max="100" value="0">
<div class="d-flex justify-content-between mt-3">
<button class="btn btn-danger" onclick="emergencyStop()">⏹ STOP</button>
<button class="btn btn-secondary" onclick="reverseDirection()">🔄 Reverse</button>
</div>
</div>
</div>
<!-- DCC Functions Section -->
<div class="card mb-3" id="functionsSection" style="display: none;">
<div class="card-body">
<h5 class="card-title">DCC Functions</h5>
<div id="functionButtons" class="d-flex flex-wrap">
<!-- Function buttons will be generated dynamically -->
</div>
</div>
</div>
<!-- WiFi Configuration Section -->
<div class="card">
<div class="card-body">
<h5 class="card-title">WiFi Configuration</h5>
<button class="btn btn-info w-100 mb-3" type="button" data-bs-toggle="collapse" data-bs-target="#wifiConfig">
Show WiFi Settings
</button>
<div class="collapse" id="wifiConfig">
<div class="mb-3">
<label class="form-label">WiFi Mode</label>
<select class="form-select" id="wifiMode">
<option value="ap">Access Point</option>
<option value="client">Client (Connect to Network)</option>
</select>
</div>
<div id="apSettings">
<div class="mb-3">
<label for="apSSID" class="form-label">AP SSID</label>
<input type="text" class="form-control" id="apSSID" value="LocoTestBench">
</div>
<div class="mb-3">
<label for="apPassword" class="form-label">AP Password</label>
<input type="password" class="form-control" id="apPassword" value="12345678">
</div>
</div>
<div id="clientSettings" style="display: none;">
<div class="mb-3">
<label for="wifiSSID" class="form-label">Network SSID</label>
<input type="text" class="form-control" id="wifiSSID">
</div>
<div class="mb-3">
<label for="wifiPassword" class="form-label">Network Password</label>
<input type="password" class="form-control" id="wifiPassword">
</div>
</div>
<button class="btn btn-warning w-100" onclick="saveWiFiSettings()">Save & Restart</button>
</div>
</div>
</div>
</div>
<script src="/js/bootstrap.bundle.min.js"></script>
<script src="/js/app.js"></script>
</body>
</html>

182
ESP32/DCC-Bench/data/js/app.js Normal file
View File

@@ -0,0 +1,182 @@
let currentMode = 'analog';
let currentDirection = 1;
let dccFunctions = 0;
// Initialize
document.addEventListener('DOMContentLoaded', function() {
loadStatus();
setupEventListeners();
generateFunctionButtons();
setInterval(loadStatus, 2000);
});
function setupEventListeners() {
document.getElementById('speedSlider').addEventListener('input', function(e) {
updateSpeed(e.target.value);
});
document.querySelectorAll('input[name="mode"]').forEach(radio => {
radio.addEventListener('change', function(e) {
setMode(e.target.value);
});
});
document.getElementById('wifiMode').addEventListener('change', function(e) {
toggleWiFiSettings(e.target.value);
});
}
function generateFunctionButtons() {
const container = document.getElementById('functionButtons');
for (let i = 0; i <= 12; i++) {
const btn = document.createElement('button');
btn.className = 'btn btn-outline-secondary function-btn';
btn.id = 'f' + i;
btn.textContent = 'F' + i;
btn.onclick = () => toggleFunction(i);
container.appendChild(btn);
}
}
async function loadStatus() {
try {
const response = await fetch('/api/status');
const data = await response.json();
document.getElementById('statusIndicator').className = 'status-indicator status-connected';
document.getElementById('statusText').textContent = 'Connected';
document.getElementById('ipAddress').textContent = data.ip || '-';
currentMode = data.mode;
currentDirection = data.direction;
document.getElementById(data.mode === 'dcc' ? 'modeDCC' : 'modeAnalog').checked = true;
document.getElementById('speedSlider').value = data.speed;
document.getElementById('speedValue').textContent = data.speed + '%';
document.getElementById('dccAddress').value = data.dccAddress;
updateUIForMode(data.mode);
updateDirectionIndicator();
} catch (error) {
document.getElementById('statusIndicator').className = 'status-indicator status-disconnected';
document.getElementById('statusText').textContent = 'Disconnected';
}
}
function updateUIForMode(mode) {
currentMode = mode;
document.getElementById('dccSection').style.display = mode === 'dcc' ? 'block' : 'none';
document.getElementById('functionsSection').style.display = mode === 'dcc' ? 'block' : 'none';
}
async function setMode(mode) {
try {
await fetch('/api/mode', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({mode: mode})
});
updateUIForMode(mode);
} catch (error) {
console.error('Error setting mode:', error);
}
}
async function updateSpeed(speed) {
document.getElementById('speedValue').textContent = speed + '%';
try {
await fetch('/api/speed', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({
speed: parseInt(speed),
direction: currentDirection
})
});
} catch (error) {
console.error('Error setting speed:', error);
}
}
async function emergencyStop() {
document.getElementById('speedSlider').value = 0;
updateSpeed(0);
}
async function reverseDirection() {
currentDirection = currentDirection === 1 ? 0 : 1;
updateDirectionIndicator();
const speed = document.getElementById('speedSlider').value;
updateSpeed(speed);
}
function updateDirectionIndicator() {
document.getElementById('directionIndicator').textContent = currentDirection === 1 ? '→' : '←';
}
async function setDCCAddress() {
const address = document.getElementById('dccAddress').value;
try {
await fetch('/api/dcc/address', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({address: parseInt(address)})
});
} catch (error) {
console.error('Error setting DCC address:', error);
}
}
async function toggleFunction(fn) {
const btn = document.getElementById('f' + fn);
const isActive = btn.classList.contains('btn-secondary');
if (isActive) {
btn.classList.remove('btn-secondary');
btn.classList.add('btn-outline-secondary');
} else {
btn.classList.remove('btn-outline-secondary');
btn.classList.add('btn-secondary');
}
try {
await fetch('/api/dcc/function', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({
function: fn,
state: !isActive
})
});
} catch (error) {
console.error('Error setting function:', error);
}
}
function toggleWiFiSettings(mode) {
document.getElementById('apSettings').style.display = mode === 'ap' ? 'block' : 'none';
document.getElementById('clientSettings').style.display = mode === 'client' ? 'block' : 'none';
}
async function saveWiFiSettings() {
const mode = document.getElementById('wifiMode').value;
const config = {
isAPMode: mode === 'ap',
apSSID: document.getElementById('apSSID').value,
apPassword: document.getElementById('apPassword').value,
ssid: document.getElementById('wifiSSID').value,
password: document.getElementById('wifiPassword').value
};
if (confirm('Save WiFi settings and restart?')) {
try {
await fetch('/api/wifi', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify(config)
});
alert('Settings saved. Device will restart...');
} catch (error) {
console.error('Error saving WiFi settings:', error);
}
}
}

7
ESP32/DCC-Bench/data/js/bootstrap.bundle.min.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

9
ESP32/DCC-Bench/doc/.gitignore vendored Normal file
View File

@@ -0,0 +1,9 @@
# Ignore generated documentation
html/
latex/
man/
rtf/
xml/
# Keep this README
!README.md

246
ESP32/DCC-Bench/doc/LM18200_DUAL_MODE.md Normal file
View File

@@ -0,0 +1,246 @@
# LM18200 Dual-Mode Operation
## System Architecture
```
┌─────────────────────────────────────────────────────────────┐
│ ESP32-2432S028R Module │
│ │
│ ┌──────────────┐ ┌────────────┐ ┌──────────────────┐ │
│ │ Touchscreen │ │ DCC │ │ Motor │ │
│ │ UI Control │→→│ Generator │ │ Controller │ │
│ └──────────────┘ └────────────┘ └──────────────────┘ │
│ │ │ │
│ ▼ ▼ │
│ GPIO 18 (PWM/DCC_A) │
│ GPIO 19 (DIR/DCC_B) │
│ GPIO 23 (BRAKE) │
│ GPIO 35 (ADC - ACK Detect) │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────┐
│ LM18200 │
│ H-Bridge │
│ │
│ Universal │
│ DC/DCC Driver │
└─────────────────┘
│
▼
┌─────────────────┐
│ Current Sense │
│ 0.1Ω 1W │
└─────────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
Track Rail 1 Track Rail 2
│ │
└────── LOCOMOTIVE ───────┘
```
## Mode Comparison
### DC Analog Mode
```
GPIO 18 ──→ PWM Signal (20kHz, 0-100% duty) ──→ LM18200 ──→ Variable Voltage
GPIO 19 ──→ Direction (HIGH/LOW) ──→ LM18200 ──→ Polarity
GPIO 23 ──→ Brake (active when needed) ──→ LM18200 ──→ Both outputs LOW
Result: Traditional DC motor control with variable speed
```
### DCC Digital Mode
```
GPIO 18 ──→ DCC Signal A (58μs/100μs pulses) ──→ LM18200 ──→ Track +
GPIO 19 ──→ DCC Signal B (inverted A) ──→ LM18200 ──→ Track -
GPIO 23 ──→ Brake (emergency stop) ──→ LM18200 ──→ Both outputs LOW
Result: NMRA DCC digital control with 128 speed steps + functions
```
### Programming Track Mode (DCC Service Mode)
```
GPIO 18 ──→ Service Mode Packets (22-bit preamble) ──→ LM18200 ──→ Track +
GPIO 19 ──→ Inverted service packets ──→ LM18200 ──→ Track -
│
▼
Current Sense (0.1Ω)
│
▼
Voltage Divider
│
▼
GPIO 35 ◄──────────────── ADC reads ACK pulse (60mA = 6mV across 0.1Ω)
Result: Decoder programming with ACK verification
```
## Signal Characteristics
### DC Mode Signals
```
GPIO 18 (PWM):
▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
▔▔▔▔▔▔▔▔▔▔ (20kHz square wave, variable duty cycle)
GPIO 19 (Direction):
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔ (Forward: HIGH)
▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁ (Reverse: LOW)
```
### DCC Mode Signals
```
GPIO 18 (DCC Signal A):
▔▁▔▁▔▁▔▁▔▁▔▁▔▁▔▁ ← '1' bits (58μs per half)
▔▔▁▁▔▔▁▁▔▔▁▁▔▔▁▁ ← '0' bits (100μs per half)
GPIO 19 (DCC Signal B):
▁▔▁▔▁▔▁▔▁▔▁▔▁▔▁▔ ← Inverted from Signal A
▁▁▔▔▁▁▔▔▁▁▔▔▁▁▔▔
```
### Programming Track ACK
```
Current Draw During Programming:
Normal: ───────────────────────────── (baseline ~10-20mA)
ACK: ────────┏━━━━━━┓───────────── (60mA spike for 6ms)
↑ ↑
Valid End
Command ACK
ADC Reading (GPIO 35):
─────────┏━━━━━┓────────────── (voltage spike detected)
```
## LM18200 Pin Configuration
```
┌────────────────────────────────┐
│ LM18200 H-Bridge │
├────────────────────────────────┤
│ │
│ PWM (Pin 3) ← GPIO 18 │ } Dual purpose:
│ DIR (Pin 5) ← GPIO 19 │ } DC: PWM+Direction
│ BRAKE(Pin 4) ← GPIO 23 │ } DCC: Signal A+B
│ │
│ VCC (Pin 1) ← 5V Logic │
│ GND (Pin 2) ← GND │
│ │
│ VS (Pin 10) ← 12-18V Track │
│ │
│ OUT1 (Pin 8) → Rail 1 ────┐ │
│ OUT2 (Pin 9) → Rail 2 ────┤ │
└────────────────────────────┼───┘
│
┌──────┴──────┐
│ 0.1Ω Sense │
└──────┬──────┘
│
To Track
```
## Current Flow and ACK Detection
### Programming Track Current Sensing
```
LM18200 OUT1
│
▼
┌─────────┐
│ 0.1Ω 1W │ ← Sense Resistor
└─────────┘
│
┌────┴────┐
│ │
1kΩ To Track Rail 1
│
GPIO 35 (ADC)
│
10kΩ
│
GND ──── Track Rail 2 ──── LM18200 OUT2
Voltage Calculation:
- Decoder ACK = 60mA
- Voltage across 0.1Ω = I × R = 0.06A × 0.1Ω = 6mV
- Voltage divider (1kΩ/10kΩ): V_adc = 6mV × (10/(1+10)) ≈ 5.45mV
- ESP32 ADC: 12-bit (0-4095) for 0-3.3V
- Expected ADC value: (5.45mV / 3300mV) × 4095 ≈ 6-7 counts
Note: In practice, use higher resistance for better ADC reading,
or amplify signal with op-amp for more reliable detection.
```
## Why This Works for Programming
### Traditional DCC System
- **Main Track**: 3-5A continuous, many locomotives
- **Programming Track**: 250mA max, one decoder at a time
- **Separation Required**: Different boosters to prevent overcurrent
### DCC-Bench Approach
- **Single Track**: Only one locomotive under test
- **Low Current**: Programming current well within LM18200 limits
- **No Isolation Needed**: Same track for operation and programming
- **Mode Selection**: Software-controlled (touchscreen UI)
### LM18200 Specifications
- **Continuous Current**: 3A (plenty for single loco)
- **Peak Current**: 6A (handles inrush)
- **Current Limit**: Built-in thermal protection
- **Perfect for**: Small test bench with one locomotive
## Safety Features
### Hardware Protection
1. **LM18200 thermal shutdown**: 165°C junction temperature
2. **Current limiting**: Automatic under-voltage lockout
3. **Brake function**: Forces outputs LOW (GPIO 23)
4. **Optional fuse**: 250mA on track output for extra safety
### Software Safety
1. **Power-off on mode change**: Prevents accidental high current
2. **CV range validation**: Only CV 1-1024 allowed
3. **Address validation**: 1-10239 range check
4. **Write verification**: Confirms successful programming
5. **Timeout handling**: Aborts if no ACK after retries
## Limitations and Considerations
### Current Implementation ✅
- Sends NMRA-compliant programming packets
- Proper timing and packet structure
- Retry logic for reliability
- Basic ACK detection framework
### With Hardware Addition 📋
- Full ACK detection with current sensing
- Verified programming success
- Reliable decoder communication
- Professional-grade test bench
### Not Supported ⚠️
- **Operations Mode Programming**: Requires main track operation
- **RailCom**: Needs additional hardware and timing
- **Multiple Locomotives**: Bench designed for single loco testing
- **High Current Ops**: Not a layout controller (test bench only)
## Advantages Summary
✅ **Simplicity**: One driver for everything
✅ **Cost**: No separate programming booster
✅ **Reliability**: LM18200 proven design
✅ **Flexibility**: Easy mode switching
✅ **Safety**: Built-in protection
✅ **Completeness**: Full NMRA compliance
✅ **Practicality**: Perfect for test bench use
This design leverages the fact that a test bench only ever has ONE locomotive,
eliminating the need for separate main track and programming track boosters!

308
ESP32/DCC-Bench/doc/PROGRAMMING_TRACK.md Normal file
View File

@@ -0,0 +1,308 @@
# DCC Programming Track Implementation
## Overview
The DCC-Bench uses the **LM18200 H-Bridge** for both normal DCC operation AND programming track functionality. Since this is a dedicated test bench with only one locomotive at a time, the same driver can handle both modes without issue.
## Why This Works
### Traditional DCC Systems
- **Main Track**: High current (3-5A) for running multiple locomotives
- **Programming Track**: Limited current (250mA max) with ACK detection
### DCC-Bench Approach
- **Single Track**: Only one locomotive under test
- **LM18200**: Can handle both operation and programming
- **Current Limit**: LM18200 has built-in current limiting
- **ACK Detection**: Monitor current draw through sense resistor
## Hardware Requirements
### Essential Components
1. **LM18200 H-Bridge** (already in design)
- Dual-purpose: DCC signal amplification + programming
- Built-in current limiting and thermal protection
- Pins: GPIO 18 (Signal A), GPIO 19 (Signal B), GPIO 23 (Brake)
2. **Current Sense Resistor** (0.1Ω, 1W)
- Monitor programming track current
- Placed in series with LM18200 output
- Creates voltage drop proportional to current
3. **ADC Input for ACK Detection**
- ESP32 ADC pin (e.g., GPIO 35)
- Connected to current sense resistor voltage
- Detects 60mA+ ACK pulse from decoder
### Optional Enhancements
- **Current Limiter Circuit**: Additional 250mA fuse for extra safety
- **LED Indicator**: Visual feedback during programming
- **Isolation**: Optocouplers for additional protection
## Wiring Diagram
```
ESP32 GPIO 18 ──────┐
├──> LM18200 ──> Current Sense ──> TRACK
ESP32 GPIO 19 ──────┘ │
│
ESP32 GPIO 35 (ADC) <──── Voltage Divider ┘
(for ACK detect)
Current Sense Circuit:
0.1Ω, 1W
Track+ ────┬──────╱╲╲╲───── LM18200 Output
│
├─── 1kΩ ───┬──── GPIO 35 (ADC)
│ │
│ 10kΩ
│ │
Track- ────┴───────────┴──── GND
```
## DCC Programming Protocol
### Service Mode (Programming Track)
The DCC-Bench implements NMRA DCC Service Mode:
1. **Factory Reset** (CV8 = 8)
- Resets decoder to factory defaults
- Standard NMRA reset command
2. **Set Address**
- **Short Address (1-127)**: Write to CV1
- **Long Address (128-10239)**: Write to CV17 + CV18
- Automatically updates CV29 for address mode
3. **CV Read** (Bit-wise Verify)
- Tests each bit (0-7) individually
- More reliable than direct read
- Requires ACK detection for each bit
4. **CV Write** (Write + Verify)
- Writes value with 3 retry attempts
- Verifies write with ACK detection
- NMRA-compliant packet structure
### ACK Detection
**How It Works:**
1. Decoder receives programming command
2. If command is valid and matches, decoder draws 60mA pulse for 6ms
3. Current sense resistor creates voltage spike
4. ESP32 ADC detects voltage above threshold
5. ACK confirmed = command successful
**Threshold Values:**
- **ACK Current**: 60mA minimum (NMRA standard)
- **ACK Duration**: 6ms typical
- **Timeout**: 20ms wait for response
## Current Implementation Status
### ✅ Implemented
- NMRA-compliant packet encoding
- Service mode packet structure (22-bit preamble)
- Factory reset command (CV8 = 8)
- Address programming (short and long)
- CV read (bit-wise verify method)
- CV write (write + verify)
- Programming screen UI with numeric keypad
### ⚠️ Needs Hardware
- **ACK Detection**: Currently returns `true` (assumed success)
- **Current Sensing**: ADC reading not yet implemented
- **Calibration**: Threshold tuning for specific hardware
## Adding ACK Detection
### Step 1: Wire Current Sense
```cpp
// Add current sense resistor (0.1Ω) in series with track output
// Connect voltage divider to ESP32 GPIO 35 (ADC1_CH7)
```
### Step 2: Update `waitForAck()` Method
```cpp
bool DCCGenerator::waitForAck() {
#define CURRENT_SENSE_PIN 35
#define ACK_THRESHOLD 100 // Adjust based on calibration
unsigned long startTime = millis();
// Wait up to 20ms for ACK pulse
while (millis() - startTime < 20) {
int adcValue = analogRead(CURRENT_SENSE_PIN);
// If current spike detected (60mA+)
if (adcValue > ACK_THRESHOLD) {
Serial.println("ACK detected!");
return true;
}
delayMicroseconds(100);
}
Serial.println("No ACK");
return false;
}
```
### Step 3: Calibrate Threshold
```cpp
// Test with known-good decoder
// Measure ADC values during programming
// Adjust ACK_THRESHOLD to reliably detect 60mA pulse
```
## Safety Features
### Built-in Protection
1. **LM18200 Thermal Shutdown**: Protects against overheating
2. **Current Limiting**: Prevents excessive current draw
3. **Brake Pin**: Emergency stop capability (GPIO 23)
### Software Safety
1. **Power-Off on Mode Change**: Prevents accidental high current
2. **CV Range Validation**: Only allows CV 1-1024
3. **Address Range Check**: Validates 1-10239
4. **Write Verification**: Confirms successful programming
### Recommended Additions
1. **250mA Fuse**: Additional protection for programming track
2. **Timeout Handling**: Abort if no response after retries
3. **Error Logging**: Track failed programming attempts
## Usage
### From Touchscreen UI
1. **Enter DCC Mode**
- Press [MODE] button until "DCC" selected
- Press [POWER] to enable
2. **Open Programming Screen**
- Press [PROG] button (appears in DCC mode)
3. **Factory Reset**
- Press [FACTORY RESET] button
- Wait for confirmation (or timeout)
4. **Set Address**
- Enter address using keypad (field auto-selected)
- Press [SET ADDR] button
- Wait for verification
5. **Read CV**
- Enter CV number (tap CV field, then use keypad)
- Press [READ] button
- Value appears in CV Value field
6. **Write CV**
- Enter CV number and value
- Press [WRITE] button
- Wait for verification
### From Serial Monitor
```cpp
DCCGenerator dcc;
// Factory reset
dcc.factoryReset();
// Set address to 42
dcc.setDecoderAddress(42);
// Read CV7 (Version)
uint8_t version;
if (dcc.readCV(7, &version)) {
Serial.printf("Decoder version: %d\n", version);
}
// Write CV3 (Acceleration) = 20
dcc.writeCV(3, 20);
```
## Troubleshooting
### No ACK Detected
**Possible Causes:**
- Current sense not connected
- Threshold too high/low
- Decoder not responding
- Wrong CV number/value
**Solutions:**
1. Verify current sense wiring
2. Test with multimeter (should see 60mA spike)
3. Calibrate ADC threshold
4. Try factory-reset decoder first
5. Check decoder is DCC-compatible
### Programming Fails
**Check:**
1. Only one locomotive on track
2. Decoder supports NMRA DCC
3. Track connections solid
4. LM18200 powered and enabled
5. No shorts on track
### Inconsistent Results
**Causes:**
- Dirty track/wheels
- Poor electrical contact
- Noise on current sense line
- Decoder in bad state
**Solutions:**
1. Clean track and wheels
2. Verify all connections tight
3. Add filtering capacitor on ADC input
4. Factory reset decoder
5. Check for ground loops
## Technical References
### NMRA Standards
- **S-9.2.3**: Service Mode (Programming Track)
- **RP-9.2.3**: Recommended Practices for Service Mode
- **CV Definitions**: Standard configuration variables
### Service Mode Packet Format
```
┌──────────┬───┬──────────┬───┬──────────┬───┬──────────┬───┐
│ Preamble │ 0 │ Address │ 0 │ Instruction│ 0 │ Checksum│ 1 │
│ (22 bits)│ │ (1 byte) │ │ (1-2 byte) │ │ (1 byte) │ │
└──────────┴───┴──────────┴───┴──────────┴───┴──────────┴───┘
```
### CV Addresses
- **CV1**: Short Address (1-127)
- **CV7**: Decoder Version
- **CV8**: Manufacturer ID (8 = Factory Reset)
- **CV17-18**: Long Address (128-10239)
- **CV29**: Configuration (address mode, speed steps, etc.)
## Future Enhancements
1. **Advanced Programming**
- Operations mode (programming on main track)
- Read on Main (RailCom support)
- Indexed CV access
2. **Decoder Detection**
- Auto-detect decoder manufacturer (CV8)
- Read decoder version (CV7)
- Capability detection
3. **Batch Programming**
- Save/load decoder configurations
- Bulk CV programming
- Profile management
4. **Diagnostics**
- Current monitoring during operation
- ACK pulse visualization
- Programming success statistics

143
ESP32/DCC-Bench/doc/README.md Normal file
View File

@@ -0,0 +1,143 @@
# API Documentation
This directory contains the auto-generated API documentation for the Locomotive Test Bench project.
## Generating Documentation
### Prerequisites
Install Doxygen (and optionally Graphviz for diagrams):
**Ubuntu/Debian:**
```bash
sudo apt-get install doxygen graphviz
```
**macOS:**
```bash
brew install doxygen graphviz
```
**Fedora/RHEL:**
```bash
sudo dnf install doxygen graphviz
```
**Windows:**
Download from [doxygen.nl](https://www.doxygen.nl/download.html)
### Generate Documentation
Run the generation script from the project root:
```bash
./generate_docs.sh
```
Or manually:
```bash
doxygen Doxyfile
```
### View Documentation
Open the generated HTML documentation:
```bash
# Linux
xdg-open doc/html/index.html
# macOS
open doc/html/index.html
# Windows
start doc/html/index.html
```
Or navigate to: `doc/html/index.html` in your browser.
## Documentation Structure
The generated documentation includes:
### Main Pages
- **Main Page**: Project overview and introduction
- **Classes**: All class definitions with member details
- **Files**: Source and header file listings
- **Namespaces**: Code organization structure
### For Each Class
- **Detailed Description**: Purpose and functionality
- **Member Functions**: All public/private methods
- **Member Variables**: All data members
- **Constructor/Destructor**: Object lifecycle
- **Usage Examples**: Where available
### Key Classes Documented
1. **Config** - Configuration management and persistent storage
2. **WiFiManager** - WiFi connectivity (AP and Client modes)
3. **MotorController** - DC motor control via LM18200
4. **DCCGenerator** - DCC protocol signal generation
5. **LEDIndicator** - WS2812 LED status indicators
6. **WebServerManager** - Web interface and REST API
## Customizing Documentation
Edit `Doxyfile` in the project root to customize:
- `PROJECT_NAME` - Project title
- `PROJECT_NUMBER` - Version number
- `PROJECT_BRIEF` - Short description
- `OUTPUT_DIRECTORY` - Where to generate docs
- `EXTRACT_PRIVATE` - Include private members
- `GENERATE_LATEX` - Generate PDF documentation
- `HAVE_DOT` - Enable class diagrams (requires Graphviz)
## Documentation Format
The code uses **Doxygen-style comments**:
```cpp
/**
* @brief Short description
*
* Detailed description can span
* multiple lines.
*
* @param paramName Description of parameter
* @return Description of return value
* @note Additional notes
* @warning Important warnings
*/
void exampleFunction(int paramName);
```
## Updating Documentation
When you modify code:
1. Update Doxygen comments in source files
2. Run `./generate_docs.sh` to regenerate
3. Review changes in browser
4. Commit updated source files (not generated HTML)
## CI/CD Integration
To auto-generate docs in CI/CD:
```yaml
# Example GitHub Actions
- name: Generate Documentation
run: |
sudo apt-get install doxygen
./generate_docs.sh
```
## Notes
- The `doc/` directory is typically added to `.gitignore`
- Only source comments are version controlled
- Documentation is regenerated as needed
- HTML output is ~2-5 MB depending on project size

37
ESP32/DCC-Bench/generate_docs.sh Normal file
View File

@@ -0,0 +1,37 @@
#!/bin/bash
# Script to generate API documentation using Doxygen
echo "Generating API documentation with Doxygen..."
echo ""
# Check if Doxygen is installed
if ! command -v doxygen &> /dev/null
then
echo "ERROR: Doxygen is not installed!"
echo ""
echo "To install Doxygen:"
echo " Ubuntu/Debian: sudo apt-get install doxygen graphviz"
echo " macOS: brew install doxygen graphviz"
echo " Fedora: sudo dnf install doxygen graphviz"
echo ""
exit 1
fi
# Run Doxygen
doxygen Doxyfile
if [ $? -eq 0 ]; then
echo ""
echo "Documentation generated successfully!"
echo ""
echo "Output location: ./doc/html/index.html"
echo ""
echo "To view the documentation:"
echo " Open in browser: file://$(pwd)/doc/html/index.html"
echo " Or run: xdg-open doc/html/index.html"
echo ""
else
echo ""
echo "ERROR: Documentation generation failed!"
exit 1
fi

70
ESP32/DCC-Bench/get-platformio.py Normal file
View File

File diff suppressed because one or more lines are too long

91
ESP32/DCC-Bench/include/Config.h Normal file
View File

@@ -0,0 +1,91 @@
/**
* @file Config.h
* @brief Configuration management for the Locomotive Test Bench
*
* This module handles persistent storage of system settings
* using ESP32's Preferences library (NVS - Non-Volatile Storage).
*
* @author Locomotive Test Bench Project
* @date 2025
*/
#ifndef CONFIG_H
#define CONFIG_H
#include <Arduino.h>
#include <Preferences.h>
/**
* @struct SystemConfig
* @brief System operation configuration
*
* Stores current control mode and locomotive parameters.
*/
struct SystemConfig {
bool isDCCMode; ///< True = DCC digital, False = DC analog
bool is3Rail; ///< True = 3-rail mode, False = 2-rail mode
bool powerOn; ///< True = power enabled, False = power off
uint16_t dccAddress; ///< DCC locomotive address (1-10239)
uint8_t speed; ///< Speed setting (0-100%)
uint8_t direction; ///< Direction: 0 = reverse, 1 = forward
uint32_t dccFunctions; ///< Bit field for DCC functions F0-F28
};
/**
* @class Config
* @brief Configuration manager with persistent storage
*
* Manages all configuration parameters and provides persistent
* storage using ESP32's NVS (Non-Volatile Storage) via Preferences.
*
* @note All settings are automatically saved to flash memory
* and persist across reboots.
*/
class Config {
public:
/**
* @brief Constructor - initializes with default values
*/
Config();
/**
* @brief Initialize preferences and load saved settings
*
* Must be called during setup() before using configuration.
* Loads previously saved settings from NVS.
*/
void begin();
/**
* @brief Save current configuration to NVS
*
* Writes all system settings to persistent storage.
* Should be called after any configuration changes.
*/
void save();
/**
* @brief Load configuration from NVS
*
* Reads previously saved settings. Called automatically
* by begin(), but can be called manually to reload.
*/
void load();
/**
* @brief Reset all settings to defaults
*
* Clears all stored preferences and resets to factory defaults.
* Use with caution - all saved settings will be lost.
*/
void reset();
SystemConfig system; ///< System operation settings
private:
Preferences preferences; ///< ESP32 NVS preferences object
};
#endif // CONFIG_H
#endif

226
ESP32/DCC-Bench/include/DCCGenerator.h Normal file
View File

@@ -0,0 +1,226 @@
/**
* @file DCCGenerator.h
* @brief NMRA DCC (Digital Command Control) signal generator
*
* Generates DCC protocol signals for controlling digital model locomotives.
* Implements NMRA DCC standard with support for:
* - Short addresses (1-127) and long addresses (128-10239)
* - 128-step speed control
* - Function control (F0-F12 implemented, expandable to F28)
*
* @note Requires external DCC booster circuit for track output
* @author Locomotive Test Bench Project
* @date 2025
*/
#ifndef DCC_GENERATOR_H
#define DCC_GENERATOR_H
#include <Arduino.h>
// Pin definitions for DCC output
// These share the same pins as the motor controller (LM18200)
// In DCC mode: GPIO 18 = DCC Signal A, GPIO 19 = DCC Signal B
// In DC mode: GPIO 18 = PWM, GPIO 19 = Direction
#define DCC_PIN_A 18 ///< DCC Signal A output pin (shared with MOTOR_PWM_PIN)
#define DCC_PIN_B 19 ///< DCC Signal B output pin (shared with MOTOR_DIR_PIN)
// DCC timing constants (microseconds) - NMRA standard
#define DCC_ONE_BIT_TOTAL_DURATION_MAX 64 ///< Max duration for '1' bit
#define DCC_ONE_BIT_TOTAL_DURATION_MIN 55 ///< Min duration for '1' bit
#define DCC_ZERO_BIT_TOTAL_DURATION_MAX 10000 ///< Max duration for '0' bit
#define DCC_ZERO_BIT_TOTAL_DURATION_MIN 95 ///< Min duration for '0' bit
#define DCC_ONE_BIT_PULSE_DURATION 58 ///< Half-cycle for '1' bit (58μs)
#define DCC_ZERO_BIT_PULSE_DURATION 100 ///< Half-cycle for '0' bit (100μs)
/**
* @class DCCGenerator
* @brief DCC protocol signal generator
*
* Generates NMRA-compliant DCC signals for digital locomotive control.
* Supports variable speed, direction, and function commands.
*
* @warning Output signals are low-power logic level.
* Requires external booster circuit for track connection.
*/
class DCCGenerator {
public:
/**
* @brief Constructor
*/
DCCGenerator();
/**
* @brief Initialize DCC generator hardware
*
* Configures output pins to idle state.
*/
void begin();
/**
* @brief Enable DCC signal generation
*
* Starts sending DCC packets to the track.
*/
void enable();
/**
* @brief Disable DCC signal generation
*
* Stops DCC output and sets pins to safe state.
*/
void disable();
/**
* @brief Set locomotive speed and direction
* @param address DCC address (1-10239)
* @param speed Speed value (0-100%)
* @param direction Direction: 0 = reverse, 1 = forward
*/
void setLocoSpeed(uint16_t address, uint8_t speed, uint8_t direction);
/**
* @brief Control DCC function
* @param address DCC address (1-10239)
* @param function Function number (0-28)
* @param state true = ON, false = OFF
*/
void setFunction(uint16_t address, uint8_t function, bool state);
/**
* @brief Update DCC signal generation
*
* Must be called regularly from main loop to send DCC packets.
* Sends speed and function packets at appropriate intervals.
*/
void update();
/**
* @brief Check if DCC is enabled
* @return true if DCC mode is active
*/
bool isEnabled() { return enabled; }
// Programming Track Methods
/**
* @brief Factory reset decoder (send CV8 = 8)
* @return true if successful
*/
bool factoryReset();
/**
* @brief Set decoder address
* @param address New address (1-10239)
* @return true if successful
*/
bool setDecoderAddress(uint16_t address);
/**
* @brief Read CV value from decoder
* @param cv CV number (1-1024)
* @param value Pointer to store read value
* @return true if successful
*/
bool readCV(uint16_t cv, uint8_t* value);
/**
* @brief Write CV value to decoder
* @param cv CV number (1-1024)
* @param value Value to write (0-255)
* @return true if successful
*/
bool writeCV(uint16_t cv, uint8_t value);
private:
bool enabled; ///< DCC generator enabled flag
uint16_t currentAddress; ///< Current locomotive address
uint8_t currentSpeed; ///< Current speed setting
uint8_t currentDirection; ///< Current direction (0=rev, 1=fwd)
uint32_t functionStates; ///< Function states bit field
unsigned long lastPacketTime; ///< Timestamp of last packet sent
static const unsigned long PACKET_INTERVAL = 30; ///< Packet interval (ms)
// DCC packet construction and transmission
/**
* @brief Send a complete DCC packet
* @param data Byte array containing packet data
* @param length Number of bytes in packet
*/
void sendPacket(uint8_t* data, uint8_t length);
/**
* @brief Send a single DCC bit
* @param value true = '1' bit, false = '0' bit
*/
void sendBit(bool value);
/**
* @brief Send DCC preamble (14 '1' bits)
*/
void sendPreamble();
/**
* @brief Send a single byte
* @param data Byte to send
*/
void sendByte(uint8_t data);
/**
* @brief Send speed command packet
*/
void sendSpeedPacket();
/**
* @brief Send function group packet
* @param group Function group number
*/
void sendFunctionPacket(uint8_t group);
/**
* @brief Calculate XOR checksum
* @param data Data bytes
* @param length Number of bytes
* @return XOR checksum byte
*/
uint8_t calculateChecksum(uint8_t* data, uint8_t length);
// Programming track helper methods
/**
* @brief Send service mode packet (programming track)
* @param data Packet data bytes
* @param length Number of bytes
*/
void sendServiceModePacket(uint8_t* data, uint8_t length);
/**
* @brief Verify byte write on programming track
* @param cv CV number
* @param value Expected value
* @return true if ACK detected
*/
bool verifyByte(uint16_t cv, uint8_t value);
/**
* @brief Wait for ACK pulse from decoder
* @return true if ACK detected within timeout
*/
bool waitForAck();
/**
* @brief Calibrate ACS712 current sensor zero point
*
* Reads current sensor with no load to establish baseline.
* Should be called during initialization.
*/
void calibrateCurrentSensor();
};
// Programming track current sensing threshold (mA)
#define PROG_ACK_CURRENT_THRESHOLD 60 ///< Minimum ACK current (mA)
#endif

105
ESP32/DCC-Bench/include/LEDIndicator.h Normal file
View File

@@ -0,0 +1,105 @@
/**
* @file LEDIndicator.h
* @brief WS2812 RGB LED status indicators
*
* Provides visual feedback using two WS2812 LEDs:
* - LED 0: Power status (Green = ON, Red = OFF)
* - LED 1: Mode indicator (Blue = DCC, Yellow = Analog)
*
* @author Locomotive Test Bench Project
* @date 2025
*/
#ifndef LED_INDICATOR_H
#define LED_INDICATOR_H
#include <Arduino.h>
// #include <FastLED.h>
// Pin definition for WS2812 LEDs
#define LED_DATA_PIN 4 ///< Data pin for WS2812 strip
#define NUM_LEDS 4 ///< Number of LEDs (Power + Mode)
// // LED indices
#define LED_POWER 0 ///< Power status indicator
#define LED_MODE 1 ///< Mode indicator (DCC/Analog)
// /**
// * @class LEDIndicator
// * @brief Manages WS2812 RGB LED status displays
// *
// * Controls two LEDs for system status indication:
// * - Power LED: Shows system power state with boot animation
// * - Mode LED: Shows control mode with pulsing effect
// */
class LEDIndicator {
public:
/**
* @brief Constructor
*/
LEDIndicator();
/**
* @brief Initialize LED hardware
*
* Configures FastLED library and sets LEDs to off state.
*/
void begin();
/**
* @brief Update LED display
*
* Must be called regularly from main loop to update
* pulsing effects and animations.
*/
void update();
/**
* @brief Set power status
* @param on true = power on (green), false = off (red)
*/
void setPowerOn(bool on);
/**
* @brief Set operating mode
* @param isDCC true = DCC mode (blue), false = Analog (yellow)
*/
void setMode(bool isDCC);
/**
* @brief Set LED brightness
* @param brightness Brightness level (0-255)
*/
void setBrightness(uint8_t brightness);
/**
* @brief Play power-on animation sequence
*
* Shows 3-flash boot sequence on power LED.
*/
void powerOnSequence();
/**
* @brief Play mode change animation
*
* Smooth fade transition when switching modes.
*/
void modeChangeEffect();
// private:
// CRGB leds[NUM_LEDS]; ///< LED array
// bool powerOn; ///< Power status flag
// bool dccMode; ///< Mode flag (DCC/Analog)
// uint8_t brightness; ///< Current brightness level
// unsigned long lastUpdate; ///< Last update timestamp
// uint8_t pulsePhase; ///< Pulse animation phase
// // LED color definitions
// static constexpr CRGB COLOR_POWER_ON = CRGB::Green; ///< Power ON color
// static constexpr CRGB COLOR_POWER_OFF = CRGB::Red; ///< Power OFF color
// static constexpr CRGB COLOR_DCC = CRGB::Blue; ///< DCC mode color
// static constexpr CRGB COLOR_ANALOG = CRGB::Yellow; ///< Analog mode color
// static constexpr CRGB COLOR_OFF = CRGB::Black; ///< LED off state
};
#endif

101
ESP32/DCC-Bench/include/MotorController.h Normal file
View File

@@ -0,0 +1,101 @@
/**
* @file MotorController.h
* @brief DC motor control using LM18200 H-Bridge driver
*
* Provides bidirectional PWM motor control with brake functionality.
* Suitable for DC analog model locomotive control.
*
* @author Locomotive Test Bench Project
* @date 2025
*/
#ifndef MOTOR_CONTROLLER_H
#define MOTOR_CONTROLLER_H
#include <Arduino.h>
// Pin definitions for LM18200
// Adjusted for ESP32-2432S028R available GPIOs
#define MOTOR_PWM_PIN 18 ///< PWM signal output pin
#define MOTOR_DIR_PIN 19 ///< Direction control pin
#define MOTOR_BRAKE_PIN 23 ///< Brake control pin (active low)
/**
* @class MotorController
* @brief Controls DC motor via LM18200 H-Bridge
*
* Features:
* - Variable speed control (0-100%)
* - Bidirectional operation (forward/reverse)
* - Electronic braking
* - 20kHz PWM frequency for silent operation
* - 8-bit resolution (256 speed steps)
*/
class MotorController {
public:
/**
* @brief Constructor
*/
MotorController();
/**
* @brief Initialize motor controller hardware
*
* Configures GPIO pins and PWM channels.
* Sets motor to safe stopped state.
*/
void begin();
/**
* @brief Set motor speed and direction
* @param speed Speed value (0-100%)
* @param direction Direction: 0 = reverse, 1 = forward
*/
void setSpeed(uint8_t speed, uint8_t direction);
/**
* @brief Stop motor (coast to stop)
*
* Sets speed to zero and releases brake.
* Motor will coast to a stop.
*/
void stop();
/**
* @brief Apply electronic brake
*
* Activates LM18200 brake function for quick stop.
* More aggressive than stop().
*/
void brake();
/**
* @brief Update motor controller state
*
* Called from main loop for safety checks.
* Currently placeholder for future features.
*/
void update();
/**
* @brief Get current speed setting
* @return Speed (0-100%)
*/
uint8_t getCurrentSpeed() { return currentSpeed; }
/**
* @brief Get current direction
* @return Direction: 0 = reverse, 1 = forward
*/
uint8_t getCurrentDirection() { return currentDirection; }
private:
uint8_t currentSpeed; ///< Current speed setting (0-100)
uint8_t currentDirection; ///< Current direction (0=rev, 1=fwd)
static const int PWM_CHANNEL = 0; ///< ESP32 PWM channel
static const int PWM_FREQUENCY = 20000; ///< PWM frequency in Hz
static const int PWM_RESOLUTION = 8; ///< PWM resolution in bits
};
#endif

59
ESP32/DCC-Bench/include/RelayController.h Normal file
View File

@@ -0,0 +1,59 @@
/**
* @file RelayController.h
* @brief Relay control for switching between 2-rail and 3-rail track configurations
*
* Controls a relay module to switch track wiring between:
* - 2-rail mode: Standard DC/DCC operation
* - 3-rail mode: Center rail + outer rails configuration
*
* @author Locomotive Test Bench Project
* @date 2025
*/
#ifndef RELAY_CONTROLLER_H
#define RELAY_CONTROLLER_H
#include <Arduino.h>
// Pin definition for relay control
#define RELAY_PIN 4 ///< Relay control pin (active HIGH)
/**
* @class RelayController
* @brief Controls relay for track configuration switching
*
* Simple relay control for switching between 2-rail and 3-rail modes.
* Relay energized = 3-rail mode
* Relay de-energized = 2-rail mode
*/
class RelayController {
public:
/**
* @brief Constructor
*/
RelayController();
/**
* @brief Initialize relay controller hardware
*
* Configures GPIO pin and sets to default 2-rail mode.
*/
void begin();
/**
* @brief Set rail mode
* @param is3Rail true = 3-rail mode, false = 2-rail mode
*/
void setRailMode(bool is3Rail);
/**
* @brief Get current rail mode
* @return true if 3-rail mode, false if 2-rail mode
*/
bool is3RailMode() { return is3Rail; }
private:
bool is3Rail; ///< Current rail mode state
};
#endif // RELAY_CONTROLLER_H

188
ESP32/DCC-Bench/include/TouchscreenUI.h Normal file
View File

@@ -0,0 +1,188 @@
/**
* @file TouchscreenUI.h
* @brief Touchscreen user interface for locomotive test bench
*
* Provides a graphical interface on the ILI9341 TFT display with touch controls for:
* - Power ON/OFF button
* - DCC/Analog mode switching
* - Speed slider (0-100%)
* - 2-rail/3-rail configuration selector
* - Direction control
* - Status display
*
* @author Locomotive Test Bench Project
* @date 2025
*/
#ifndef TOUCHSCREEN_UI_H
#define TOUCHSCREEN_UI_H
#include <Arduino.h>
#include <TFT_eSPI.h>
#include <XPT2046_Touchscreen.h>
#include "Config.h"
#include "MotorController.h"
#include "DCCGenerator.h"
#include "RelayController.h"
// Touch calibration values for ESP32-2432S028R
#define TS_MIN_X 200
#define TS_MAX_X 3700
#define TS_MIN_Y 200
#define TS_MAX_Y 3750
// UI Colors
#define COLOR_BG 0x0000 // Black
#define COLOR_PANEL 0x2945 // Dark gray
#define COLOR_TEXT 0xFFFF // White
#define COLOR_POWER_ON 0x07E0 // Green
#define COLOR_POWER_OFF 0xF800 // Red
#define COLOR_DCC 0x07FF // Cyan
#define COLOR_ANALOG 0xFFE0 // Yellow
#define COLOR_SLIDER 0x435C // Gray
#define COLOR_SLIDER_ACTIVE 0x07E0 // Green
#define COLOR_BUTTON 0x4A49 // Button gray
#define COLOR_BUTTON_ACTIVE 0x2124 // Darker gray
#define COLOR_FUNCTION_OFF 0x31A6 // Dark blue-gray
#define COLOR_FUNCTION_ON 0xFD20 // Orange
/**
* @struct Button
* @brief Simple button structure for touch areas
*/
struct Button {
int16_t x, y, w, h;
String label;
uint16_t color;
bool visible;
};
/**
* @class TouchscreenUI
* @brief Manages touchscreen display and user interactions
*
* Provides complete UI for controlling the locomotive test bench,
* handling touch events, updating displays, and coordinating with
* motor controller, DCC generator, and relay controller.
*/
class TouchscreenUI {
public:
/**
* @brief Constructor
* @param cfg Pointer to configuration object
* @param motor Pointer to motor controller
* @param dcc Pointer to DCC generator
* @param relay Pointer to relay controller
*/
TouchscreenUI(Config* cfg, MotorController* motor, DCCGenerator* dcc, RelayController* relay);
/**
* @brief Initialize touchscreen and display
*
* Sets up TFT display, touch controller, and draws initial UI.
*/
void begin();
/**
* @brief Update UI and handle touch events
*
* Must be called regularly from main loop.
* Handles touch detection, UI updates, and state changes.
*/
void update();
/**
* @brief Force full screen redraw
*/
void redraw();
/**
* @brief Get power state
* @return true if power is ON
*/
bool isPowerOn() { return powerOn; }
private:
TFT_eSPI tft;
XPT2046_Touchscreen touch;
Config* config;
MotorController* motorController;
DCCGenerator* dccGenerator;
RelayController* relayController;
bool powerOn;
uint8_t lastSpeed;
bool lastDirection;
bool lastIsDCC;
bool lastIs3Rail;
uint32_t lastDccFunctions;
// Programming screen state
bool programmingMode;
uint16_t cvNumber;
uint8_t cvValue;
uint16_t newAddress;
uint8_t keypadMode; // 0=address, 1=CV number, 2=CV value
// UI element positions
Button btnPower;
Button btnMode;
Button btnRails;
Button btnDirection;
Button btnDccAddress;
// DCC function buttons (F0-F12)
#define NUM_FUNCTIONS 13
Button btnFunctions[NUM_FUNCTIONS];
// Programming mode buttons
Button btnProgramming;
Button btnProgBack;
Button btnFactoryReset;
Button btnSetAddress;
Button btnReadCV;
Button btnWriteCV;
// Numeric keypad (0-9, backspace, enter)
#define NUM_KEYPAD_BUTTONS 12
Button btnKeypad[NUM_KEYPAD_BUTTONS];
// Slider position and state
int16_t sliderX, sliderY, sliderW, sliderH;
int16_t sliderKnobX;
bool sliderPressed;
// Private methods
void drawUI();
void drawPowerButton();
void drawModeButton();
void drawRailsButton();
void drawDirectionButton();
void drawSpeedSlider();
void drawStatusBar();
void drawDccFunctions();
void drawDccAddressButton();
void drawProgrammingScreen();
void drawNumericKeypad();
void drawProgrammingStatus();
void handleTouch(int16_t x, int16_t y);
void updatePowerState(bool state);
void updateMode(bool isDCC);
void updateRailMode(bool is3Rail);
void updateDirection();
void updateSpeed(uint8_t newSpeed);
void toggleDccFunction(uint8_t function);
void enterProgrammingMode();
void exitProgrammingMode();
void handleKeypadPress(uint8_t key);
void performFactoryReset();
void performSetAddress();
void performReadCV();
void performWriteCV();
int16_t mapTouch(int16_t value, int16_t inMin, int16_t inMax, int16_t outMin, int16_t outMax);
};
#endif // TOUCHSCREEN_UI_H

40
ESP32/DCC-Bench/platformio.ini Normal file
View File

@@ -0,0 +1,40 @@
; PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
; ESP32-2432S028R (ESP32 with ILI9341 TFT touchscreen)
[env:esp32-2432s028r]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
upload_speed = 921600
build_flags =
-D ARDUINO_ARCH_ESP32
-D USER_SETUP_LOADED=1
-D ILI9341_DRIVER=1
-D TFT_WIDTH=240
-D TFT_HEIGHT=320
-D TFT_MISO=12
-D TFT_MOSI=13
-D TFT_SCLK=14
-D TFT_CS=15
-D TFT_DC=2
-D TFT_RST=-1
-D TFT_BL=21
-D TOUCH_CS=22
-D SPI_FREQUENCY=55000000
-D SPI_READ_FREQUENCY=20000000
-D SPI_TOUCH_FREQUENCY=2500000
lib_deps =
bblanchon/ArduinoJson@^6.21.3
bodmer/TFT_eSPI@^2.5.43
paulstoffregen/XPT2046_Touchscreen@^1.4
https://github.com/Locoduino/DCCpp
board_build.filesystem = littlefs

92
ESP32/DCC-Bench/src/Config.cpp Normal file
View File

@@ -0,0 +1,92 @@
/**
* @file Config.cpp
* @brief Implementation of configuration management
*
* @author Locomotive Test Bench Project
* @date 2025
*/
#include "Config.h"
/**
* @brief Constructor - sets default configuration values
*
* Initializes all settings to safe defaults:
* - System: DC analog mode, 2-rail, power off, address 3, stopped
*/
Config::Config() {
// Default system values
system.isDCCMode = false;
system.is3Rail = false;
system.powerOn = false;
system.dccAddress = 3;
system.speed = 0;
system.direction = 1;
system.dccFunctions = 0;
}
/**
* @brief Initialize configuration system
*
* Opens NVS namespace and loads saved configuration.
* If no saved config exists, defaults are used.
*/
void Config::begin() {
preferences.begin("loco-config", false);
load();
}
/**
* @brief Save all configuration to persistent storage
*
* Writes system settings to NVS flash memory.
* Settings persist across power cycles and reboots.
*/
void Config::save() {
// System settings
preferences.putBool("is_dcc", system.isDCCMode);
preferences.putBool("is_3rail", system.is3Rail);
preferences.putBool("power_on", system.powerOn);
preferences.putUShort("dcc_addr", system.dccAddress);
preferences.putUChar("speed", system.speed);
preferences.putUChar("direction", system.direction);
preferences.putUInt("dcc_func", system.dccFunctions);
}
/**
* @brief Load configuration from persistent storage
*
* Reads all settings from NVS. If a setting doesn't exist,
* the current (default) value is retained.
*/
void Config::load() {
// System settings
system.isDCCMode = preferences.getBool("is_dcc", false);
system.is3Rail = preferences.getBool("is_3rail", false);
system.powerOn = preferences.getBool("power_on", false);
system.dccAddress = preferences.getUShort("dcc_addr", 3);
system.speed = preferences.getUChar("speed", 0);
system.direction = preferences.getUChar("direction", 1);
system.dccFunctions = preferences.getUInt("dcc_func", 0);
}
/**
* @brief Reset all settings to factory defaults
*
* Clears NVS storage and reinitializes with default values.
* @warning All saved configuration will be permanently lost!
*/
void Config::reset() {
preferences.clear();
// Reset to defaults
system.isDCCMode = false;
system.is3Rail = false;
system.powerOn = false;
system.dccAddress = 3;
system.speed = 0;
system.direction = 1;
system.dccFunctions = 0;
save();
}

455
ESP32/DCC-Bench/src/DCCGenerator.cpp Normal file
View File

@@ -0,0 +1,455 @@
/**
* @file DCCGenerator.cpp
* @brief Implementation of DCC signal generation
*/
#include "DCCGenerator.h"
/**
* @brief Constructor - initialize with safe defaults
*/
DCCGenerator::DCCGenerator() :
enabled(false),
currentAddress(3),
currentSpeed(0),
currentDirection(1),
functionStates(0),
lastPacketTime(0) {
}
void DCCGenerator::begin() {
pinMode(DCC_PIN_A, OUTPUT);
pinMode(DCC_PIN_B, OUTPUT);
digitalWrite(DCC_PIN_A, LOW);
digitalWrite(DCC_PIN_B, LOW);
Serial.println("DCC Generator initialized");
Serial.printf("DCC Pin A: %d, DCC Pin B: %d\n", DCC_PIN_A, DCC_PIN_B);
// Calibrate ACS712 current sensor zero point
calibrateCurrentSensor();
}
void DCCGenerator::calibrateCurrentSensor() {
#define CURRENT_SENSE_PIN 35
Serial.println("Calibrating ACS712 current sensor...");
Serial.println("Ensure no locomotive is on track and power is OFF");
delay(500); // Give time for user to see message
float sum = 0;
const int samples = 100;
for (int i = 0; i < samples; i++) {
int adc = analogRead(CURRENT_SENSE_PIN);
float voltage = (adc / 4095.0) * 3.3;
sum += voltage;
delay(10);
}
float zeroVoltage = sum / samples;
Serial.printf("ACS712 Zero Point: %.3fV (expected ~2.5V)\n", zeroVoltage);
if (abs(zeroVoltage - 2.5) > 0.3) {
Serial.println("WARNING: Zero voltage significantly different from 2.5V");
Serial.println("Check ACS712 wiring and 5V power supply");
} else {
Serial.println("ACS712 calibration OK");
}
}
void DCCGenerator::enable() {
enabled = true;
Serial.println("DCC mode enabled");
}
void DCCGenerator::disable() {
enabled = false;
digitalWrite(DCC_PIN_A, LOW);
digitalWrite(DCC_PIN_B, LOW);
Serial.println("DCC mode disabled");
}
void DCCGenerator::setLocoSpeed(uint16_t address, uint8_t speed, uint8_t direction) {
currentAddress = address;
currentSpeed = speed;
currentDirection = direction;
Serial.printf("DCC: Addr=%d, Speed=%d, Dir=%s\n",
address, speed, direction ? "FWD" : "REV");
}
void DCCGenerator::setFunction(uint16_t address, uint8_t function, bool state) {
currentAddress = address;
if (function <= 28) {
if (state) {
functionStates |= (1UL << function);
} else {
functionStates &= ~(1UL << function);
}
Serial.printf("DCC: Function F%d = %s\n", function, state ? "ON" : "OFF");
}
}
void DCCGenerator::update() {
if (!enabled) return;
unsigned long now = millis();
if (now - lastPacketTime >= PACKET_INTERVAL) {
lastPacketTime = now;
sendSpeedPacket();
// Periodically send function packets
static uint8_t packetCount = 0;
packetCount++;
if (packetCount % 3 == 0) {
sendFunctionPacket(1); // F0-F4
}
}
}
void DCCGenerator::sendBit(bool value) {
int duration = value ? DCC_ONE_BIT_PULSE_DURATION : DCC_ZERO_BIT_PULSE_DURATION;
// First half-cycle
digitalWrite(DCC_PIN_A, HIGH);
digitalWrite(DCC_PIN_B, LOW);
delayMicroseconds(duration);
// Second half-cycle
digitalWrite(DCC_PIN_A, LOW);
digitalWrite(DCC_PIN_B, HIGH);
delayMicroseconds(duration);
}
void DCCGenerator::sendPreamble() {
for (int i = 0; i < 14; i++) {
sendBit(1); // Send '1' bits
}
}
void DCCGenerator::sendByte(uint8_t data) {
for (int i = 7; i >= 0; i--) {
sendBit((data >> i) & 0x01);
}
}
void DCCGenerator::sendPacket(uint8_t* data, uint8_t length) {
sendPreamble();
// Packet start bit
sendBit(0);
// Send data bytes with separator bits
for (uint8_t i = 0; i < length; i++) {
sendByte(data[i]);
if (i < length - 1) {
sendBit(0); // Data byte separator
}
}
// Packet end bit
sendBit(1);
}
uint8_t DCCGenerator::calculateChecksum(uint8_t* data, uint8_t length) {
uint8_t checksum = 0;
for (uint8_t i = 0; i < length; i++) {
checksum ^= data[i];
}
return checksum;
}
void DCCGenerator::sendSpeedPacket() {
uint8_t packet[4];
uint8_t packetLength = 0;
// Address byte (short address: 1-127)
if (currentAddress <= 127) {
packet[packetLength++] = currentAddress & 0x7F;
} else {
// Long address (128-10239)
packet[packetLength++] = 0xC0 | ((currentAddress >> 8) & 0x3F);
packet[packetLength++] = currentAddress & 0xFF;
}
// Speed and direction instruction (128-step mode)
// Instruction: 0b00111111
uint8_t speedByte = 0b00111111; // 128-step speed control
// Convert speed (0-100) to DCC speed (0-126)
uint8_t dccSpeed = map(currentSpeed, 0, 100, 0, 126);
// Encode direction and speed
if (dccSpeed == 0) {
speedByte = 0b00111111; // Stop
} else {
// Bit 7: direction (1=forward, 0=reverse)
// Bits 0-6: speed (1-126, with 0 and 1 both meaning stop)
speedByte = 0b00111111;
speedByte |= (currentDirection ? 0x80 : 0x00);
speedByte = (speedByte & 0x80) | (dccSpeed & 0x7F);
}
packet[packetLength++] = speedByte;
// Error detection byte
packet[packetLength++] = calculateChecksum(packet, packetLength);
sendPacket(packet, packetLength);
}
void DCCGenerator::sendFunctionPacket(uint8_t group) {
uint8_t packet[4];
uint8_t packetLength = 0;
// Address byte
if (currentAddress <= 127) {
packet[packetLength++] = currentAddress & 0x7F;
} else {
packet[packetLength++] = 0xC0 | ((currentAddress >> 8) & 0x3F);
packet[packetLength++] = currentAddress & 0xFF;
}
// Function group 1 (F0-F4)
if (group == 1) {
uint8_t functionByte = 0b10000000; // Function group 1
functionByte |= ((functionStates & 0x01) ? 0x10 : 0x00); // F0
functionByte |= ((functionStates & 0x02) ? 0x01 : 0x00); // F1
functionByte |= ((functionStates & 0x04) ? 0x02 : 0x00); // F2
functionByte |= ((functionStates & 0x08) ? 0x04 : 0x00); // F3
functionByte |= ((functionStates & 0x10) ? 0x08 : 0x00); // F4
packet[packetLength++] = functionByte;
}
// Error detection byte
packet[packetLength++] = calculateChecksum(packet, packetLength);
sendPacket(packet, packetLength);
}
// ========================================
// Programming Track Methods
// ========================================
bool DCCGenerator::factoryReset() {
Serial.println("DCC Programming: Factory Reset (CV8 = 8)");
// Factory reset is CV8 = 8
bool success = writeCV(8, 8);
if (success) {
Serial.println("Factory reset successful");
} else {
Serial.println("Factory reset failed - no ACK");
}
return success;
}
bool DCCGenerator::setDecoderAddress(uint16_t address) {
Serial.printf("DCC Programming: Set Address = %d\n", address);
bool success = false;
if (address >= 1 && address <= 127) {
// Short address - write to CV1
success = writeCV(1, address);
if (success) {
// Also set CV29 bit 5 = 0 for short address mode
uint8_t cv29;
if (readCV(29, &cv29)) {
cv29 &= ~0x20; // Clear bit 5
writeCV(29, cv29);
}
Serial.printf("Short address %d set successfully\n", address);
}
} else if (address >= 128 && address <= 10239) {
// Long address - write to CV17 and CV18
uint8_t cv17 = 0xC0 | ((address >> 8) & 0x3F);
uint8_t cv18 = address & 0xFF;
bool cv17ok = writeCV(17, cv17);
bool cv18ok = writeCV(18, cv18);
if (cv17ok && cv18ok) {
// Set CV29 bit 5 = 1 for long address mode
uint8_t cv29;
if (readCV(29, &cv29)) {
cv29 |= 0x20; // Set bit 5
writeCV(29, cv29);
}
Serial.printf("Long address %d set successfully (CV17=%d, CV18=%d)\n",
address, cv17, cv18);
success = true;
}
} else {
Serial.println("Invalid address (must be 1-10239)");
return false;
}
if (!success) {
Serial.println("Set address failed - no ACK");
}
return success;
}
bool DCCGenerator::readCV(uint16_t cv, uint8_t* value) {
if (cv < 1 || cv > 1024) {
Serial.println("Invalid CV number (must be 1-1024)");
return false;
}
Serial.printf("DCC Programming: Read CV%d\n", cv);
// Use bit-wise verify method (more reliable than direct read)
uint8_t result = 0;
for (int bit = 0; bit < 8; bit++) {
// Test if bit is set
uint8_t packet[4];
uint8_t packetLength = 0;
// Service mode instruction: Verify Bit
packet[packetLength++] = 0x78 | ((cv >> 8) & 0x03); // 0111 10aa
packet[packetLength++] = cv & 0xFF;
packet[packetLength++] = 0xE8 | bit; // 111K 1BBB (K=1 for verify, BBB=bit position)
packet[packetLength++] = calculateChecksum(packet, packetLength);
// Send packet and check for ACK
sendServiceModePacket(packet, packetLength);
if (waitForAck()) {
result |= (1 << bit); // Bit is 1
}
delay(20); // Wait between bit verifications
}
*value = result;
Serial.printf("CV%d = %d (0x%02X)\n", cv, result, result);
return true; // Bit-wise verify always returns a value
}
bool DCCGenerator::writeCV(uint16_t cv, uint8_t value) {
if (cv < 1 || cv > 1024) {
Serial.println("Invalid CV number (must be 1-1024)");
return false;
}
Serial.printf("DCC Programming: Write CV%d = %d (0x%02X)\n", cv, value, value);
// Service mode instruction: Verify Byte (write with verification)
uint8_t packet[4];
uint8_t packetLength = 0;
packet[packetLength++] = 0x7C | ((cv >> 8) & 0x03); // 0111 11aa
packet[packetLength++] = cv & 0xFF;
packet[packetLength++] = value;
packet[packetLength++] = calculateChecksum(packet, packetLength);
// Send write packet multiple times for reliability
for (int i = 0; i < 3; i++) {
sendServiceModePacket(packet, packetLength);
delay(30);
}
// Verify the write
bool success = verifyByte(cv, value);
if (success) {
Serial.printf("CV%d write verified\n", cv);
} else {
Serial.printf("CV%d write failed - no ACK on verify\n", cv);
}
return success;
}
// ========================================
// Programming Track Helper Methods
// ========================================
void DCCGenerator::sendServiceModePacket(uint8_t* data, uint8_t length) {
// Service mode packets use longer preamble (20+ bits)
for (int i = 0; i < 22; i++) {
sendBit(1);
}
// Packet start bit
sendBit(0);
// Send data bytes
for (uint8_t i = 0; i < length; i++) {
sendByte(data[i]);
if (i < length - 1) {
sendBit(0); // Inter-byte bit
}
}
// Packet end bit
sendBit(1);
// Recovery time
delayMicroseconds(200);
}
bool DCCGenerator::verifyByte(uint16_t cv, uint8_t value) {
uint8_t packet[4];
uint8_t packetLength = 0;
// Service mode: Verify Byte
packet[packetLength++] = 0x74 | ((cv >> 8) & 0x03); // 0111 01aa
packet[packetLength++] = cv & 0xFF;
packet[packetLength++] = value;
packet[packetLength++] = calculateChecksum(packet, packetLength);
sendServiceModePacket(packet, packetLength);
return waitForAck();
}
bool DCCGenerator::waitForAck() {
// ACK detection using ACS712 current sensor
// Decoder draws 60mA+ pulse for 6ms to acknowledge
#define CURRENT_SENSE_PIN 35
#define ACS712_ZERO_VOLTAGE 2.5 // 2.5V at 0A (Vcc/2) - calibrate if needed
#define ACS712_SENSITIVITY 0.185 // 185 mV/A for ACS712-05A model
#define ACK_CURRENT_THRESHOLD 0.055 // 55mA threshold (slightly below 60mA for margin)
unsigned long startTime = millis();
int sampleCount = 0;
float maxCurrent = 0;
// Wait up to 20ms for ACK pulse
while (millis() - startTime < 20) {
int adcValue = analogRead(CURRENT_SENSE_PIN);
float voltage = (adcValue / 4095.0) * 3.3; // Convert ADC to voltage
float current = abs((voltage - ACS712_ZERO_VOLTAGE) / ACS712_SENSITIVITY);
if (current > maxCurrent) {
maxCurrent = current;
}
// If current spike detected (60mA+)
if (current > ACK_CURRENT_THRESHOLD) {
Serial.printf("ACK detected! Current: %.1fmA (ADC: %d, Voltage: %.3fV)\n",
current * 1000, adcValue, voltage);
return true;
}
sampleCount++;
delayMicroseconds(100); // Sample every 100μs
}
Serial.printf("No ACK detected (max current: %.1fmA, samples: %d)\n",
maxCurrent * 1000, sampleCount);
return false;
}

115
ESP32/DCC-Bench/src/LEDIndicator.cpp Normal file
View File

@@ -0,0 +1,115 @@
/**
* @file LEDIndicator.cpp
* @brief Implementation of LED status indicators
*/
#include "LEDIndicator.h"
/**
* @brief Constructor - initialize with default state
*/
// LEDIndicator::LEDIndicator() :
// powerOn(false),
// dccMode(false),
// brightness(128),
// lastUpdate(0),
// pulsePhase(0)
// {}
LEDIndicator::LEDIndicator(){}
void LEDIndicator::begin() {
// FastLED.addLeds<WS2812, LED_DATA_PIN, GRB>(leds, NUM_LEDS);
// FastLED.setBrightness(brightness);
// Initialize both LEDs to off
// leds[LED_POWER] = COLOR_OFF;
// leds[LED_MODE] = COLOR_OFF;
// FastLED.show();
// Serial.println("LED Indicator initialized");
// Serial.printf("LED Data Pin: %d, Num LEDs: %d\n", LED_DATA_PIN, NUM_LEDS);
}
void LEDIndicator::update() {
// unsigned long now = millis();
// // Update power LED
// if (powerOn) {
// leds[LED_POWER] = COLOR_POWER_ON;
// } else {
// leds[LED_POWER] = COLOR_POWER_OFF;
// }
// Update mode LED with subtle pulsing effect
// if (now - lastUpdate > 20) {
// lastUpdate = now;
// pulsePhase++;
// // Create gentle pulse effect
// uint8_t pulseBrightness = 128 + (sin8(pulsePhase * 2) / 4);
// CRGB baseColor = dccMode ? COLOR_DCC : COLOR_ANALOG;
// leds[LED_MODE] = baseColor;
// leds[LED_MODE].fadeToBlackBy(255 - pulseBrightness);
// }
// FastLED.show();
}
void LEDIndicator::setPowerOn(bool on) {
// if (powerOn != on) {
// powerOn = on;
// if (on) {
// powerOnSequence();
// }
// }
}
void LEDIndicator::setMode(bool isDCC) {
// if (dccMode != isDCC) {
// dccMode = isDCC;
// modeChangeEffect();
// }
}
void LEDIndicator::setBrightness(uint8_t newBrightness) {
// brightness = newBrightness;
// FastLED.setBrightness(brightness);
}
void LEDIndicator::powerOnSequence() {
// // Quick flash sequence on power on
// for (int i = 0; i < 3; i++) {
// leds[LED_POWER] = COLOR_POWER_ON;
// FastLED.show();
// delay(100);
// leds[LED_POWER] = COLOR_OFF;
// FastLED.show();
// delay(100);
// }
// leds[LED_POWER] = COLOR_POWER_ON;
// FastLED.show();
// Serial.println("LED: Power ON sequence");
}
void LEDIndicator::modeChangeEffect() {
// // Smooth transition effect when changing modes
// CRGB targetColor = dccMode ? COLOR_DCC : COLOR_ANALOG;
// // Fade out
// for (int i = 255; i >= 0; i -= 15) {
// leds[LED_MODE].fadeToBlackBy(15);
// FastLED.show();
// delay(10);
// }
// // Fade in new color
// for (int i = 0; i <= 255; i += 15) {
// leds[LED_MODE] = targetColor;
// leds[LED_MODE].fadeToBlackBy(255 - i);
// FastLED.show();
// delay(10);
// }
// Serial.printf("LED: Mode changed to %s\n", dccMode ? "DCC (Blue)" : "Analog (Yellow)");
}

68
ESP32/DCC-Bench/src/MotorController.cpp Normal file
View File

@@ -0,0 +1,68 @@
/**
* @file MotorController.cpp
* @brief Implementation of DC motor control
*/
#include "MotorController.h"
/**
* @brief Constructor - initialize with safe defaults
*/
MotorController::MotorController() : currentSpeed(0), currentDirection(1) {
}
void MotorController::begin() {
// Configure pins
pinMode(MOTOR_DIR_PIN, OUTPUT);
pinMode(MOTOR_BRAKE_PIN, OUTPUT);
// Setup PWM
ledcSetup(PWM_CHANNEL, PWM_FREQUENCY, PWM_RESOLUTION);
ledcAttachPin(MOTOR_PWM_PIN, PWM_CHANNEL);
// Initialize to safe state
digitalWrite(MOTOR_BRAKE_PIN, HIGH); // Release brake (active low)
digitalWrite(MOTOR_DIR_PIN, HIGH); // Forward direction
ledcWrite(PWM_CHANNEL, 0); // Zero speed
Serial.println("Motor Controller initialized");
Serial.printf("PWM Pin: %d, DIR Pin: %d, BRAKE Pin: %d\n",
MOTOR_PWM_PIN, MOTOR_DIR_PIN, MOTOR_BRAKE_PIN);
}
void MotorController::setSpeed(uint8_t speed, uint8_t direction) {
currentSpeed = speed;
currentDirection = direction;
// Release brake
digitalWrite(MOTOR_BRAKE_PIN, HIGH);
// Set direction
digitalWrite(MOTOR_DIR_PIN, direction ? HIGH : LOW);
// Set PWM duty cycle
// Speed is 0-100, convert to 0-255
uint16_t pwmValue = map(speed, 0, 100, 0, 255);
ledcWrite(PWM_CHANNEL, pwmValue);
Serial.printf("Motor: Speed=%d%%, Direction=%s, PWM=%d\n",
speed, direction ? "FWD" : "REV", pwmValue);
}
void MotorController::stop() {
currentSpeed = 0;
ledcWrite(PWM_CHANNEL, 0);
digitalWrite(MOTOR_BRAKE_PIN, HIGH); // Release brake
Serial.println("Motor stopped");
}
void MotorController::brake() {
ledcWrite(PWM_CHANNEL, 0);
digitalWrite(MOTOR_BRAKE_PIN, LOW); // Activate brake (active low)
currentSpeed = 0;
Serial.println("Motor brake activated");
}
void MotorController::update() {
// Placeholder for future safety checks or smooth acceleration
}

28
ESP32/DCC-Bench/src/RelayController.cpp Normal file
View File

@@ -0,0 +1,28 @@
/**
* @file RelayController.cpp
* @brief Implementation of relay controller for track configuration switching
*
* @author Locomotive Test Bench Project
* @date 2025
*/
#include "RelayController.h"
RelayController::RelayController() : is3Rail(false) {
}
void RelayController::begin() {
pinMode(RELAY_PIN, OUTPUT);
digitalWrite(RELAY_PIN, LOW); // Start in 2-rail mode
is3Rail = false;
Serial.println("Relay Controller initialized - 2-rail mode");
}
void RelayController::setRailMode(bool mode3Rail) {
is3Rail = mode3Rail;
digitalWrite(RELAY_PIN, is3Rail ? HIGH : LOW);
Serial.print("Rail mode changed to: ");
Serial.println(is3Rail ? "3-rail" : "2-rail");
}

943
ESP32/DCC-Bench/src/TouchscreenUI.cpp Normal file
View File

@@ -0,0 +1,943 @@
/**
* @file TouchscreenUI.cpp
* @brief Implementation of touchscreen user interface
*
* @author Locomotive Test Bench Project
* @date 2025
*/
#include "TouchscreenUI.h"
TouchscreenUI::TouchscreenUI(Config* cfg, MotorController* motor, DCCGenerator* dcc, RelayController* relay)
: touch(TOUCH_CS), config(cfg), motorController(motor), dccGenerator(dcc), relayController(relay) {
powerOn = false;
lastSpeed = 0;
lastDirection = 0;
lastIsDCC = true;
lastIs3Rail = false;
lastDccFunctions = 0;
sliderPressed = false;
programmingMode = false;
cvNumber = 1;
cvValue = 0;
newAddress = 3;
keypadMode = 0; // Start with address entry
}
void TouchscreenUI::begin() {
// Initialize TFT display
tft.init();
tft.setRotation(1); // Landscape orientation (320x240)
tft.fillScreen(COLOR_BG);
// Initialize touch
touch.begin();
touch.setRotation(1);
// Setup UI element positions
// Power button (top-left)
btnPower.x = 10;
btnPower.y = 10;
btnPower.w = 70;
btnPower.h = 50;
btnPower.label = "POWER";
btnPower.visible = true;
// Mode button (DCC/Analog)
btnMode.x = 90;
btnMode.y = 10;
btnMode.w = 70;
btnMode.h = 50;
btnMode.label = "MODE";
btnMode.visible = true;
// Rails button (2/3 rails)
btnRails.x = 170;
btnRails.y = 10;
btnRails.w = 70;
btnRails.h = 50;
btnRails.label = "RAILS";
btnRails.visible = true;
// Direction button
btnDirection.x = 250;
btnDirection.y = 10;
btnDirection.w = 60;
btnDirection.h = 50;
btnDirection.label = "DIR";
btnDirection.visible = true;
// DCC function buttons (F0-F12) - 13 buttons in compact grid
// Layout: 2 rows of function buttons below main controls
int btnW = 38;
int btnH = 28;
int startX = 10;
int startY = 68;
int spacing = 2;
for (int i = 0; i < NUM_FUNCTIONS; i++) {
int col = i % 8; // 8 buttons per row
int row = i / 8;
btnFunctions[i].x = startX + col * (btnW + spacing);
btnFunctions[i].y = startY + row * (btnH + spacing);
btnFunctions[i].w = btnW;
btnFunctions[i].h = btnH;
btnFunctions[i].label = "F" + String(i);
btnFunctions[i].visible = config->system.isDCCMode; // Only visible in DCC mode
}
// DCC Address button (only in DCC mode)
btnDccAddress.x = 10;
btnDccAddress.y = 68 + 2 * (btnH + spacing);
btnDccAddress.w = 80;
btnDccAddress.h = 28;
btnDccAddress.label = "ADDR";
btnDccAddress.visible = config->system.isDCCMode;
// Programming button (only in DCC mode)
btnProgramming.x = 100;
btnProgramming.y = 68 + 2 * (btnH + spacing);
btnProgramming.w = 80;
btnProgramming.h = 28;
btnProgramming.label = "PROG";
btnProgramming.visible = config->system.isDCCMode;
// Speed slider (horizontal, bottom half)
sliderX = 20;
sliderY = 120;
sliderW = 280;
sliderH = 40;
sliderKnobX = sliderX;
// Draw initial UI
drawUI();
Serial.println("Touchscreen UI initialized");
}
void TouchscreenUI::update() {
// Check for touch events
if (touch.touched()) {
TS_Point p = touch.getPoint();
// Map touch coordinates to screen coordinates
int16_t x = mapTouch(p.x, TS_MIN_X, TS_MAX_X, 0, 320);
int16_t y = mapTouch(p.y, TS_MIN_Y, TS_MAX_Y, 0, 240);
// Bounds checking
x = constrain(x, 0, 319);
y = constrain(y, 0, 239);
handleTouch(x, y);
// Debounce
delay(100);
}
// Update UI if state changed
if (lastSpeed != config->system.speed ||
lastDirection != config->system.direction ||
lastIsDCC != config->system.isDCCMode ||
lastIs3Rail != config->system.is3Rail ||
(config->system.isDCCMode && lastDccFunctions != config->system.dccFunctions)) {
// If mode changed, redraw everything
if (lastIsDCC != config->system.isDCCMode) {
redraw();
} else {
drawStatusBar();
if (config->system.isDCCMode && lastDccFunctions != config->system.dccFunctions) {
drawDccFunctions();
}
}
lastSpeed = config->system.speed;
lastDirection = config->system.direction;
lastIsDCC = config->system.isDCCMode;
lastIs3Rail = config->system.is3Rail;
lastDccFunctions = config->system.dccFunctions;
}
}
void TouchscreenUI::redraw() {
tft.fillScreen(COLOR_BG);
drawUI();
}
void TouchscreenUI::drawUI() {
if (programmingMode) {
drawProgrammingScreen();
return;
}
drawPowerButton();
drawModeButton();
drawRailsButton();
drawDirectionButton();
if (config->system.isDCCMode) {
drawDccFunctions();
drawDccAddressButton();
}
drawSpeedSlider();
drawStatusBar();
}
void TouchscreenUI::drawPowerButton() {
uint16_t color = powerOn ? COLOR_POWER_ON : COLOR_POWER_OFF;
tft.fillRoundRect(btnPower.x, btnPower.y, btnPower.w, btnPower.h, 5, color);
tft.drawRoundRect(btnPower.x, btnPower.y, btnPower.w, btnPower.h, 5, COLOR_TEXT);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(MC_DATUM);
tft.drawString(powerOn ? "ON" : "OFF", btnPower.x + btnPower.w/2, btnPower.y + btnPower.h/2, 2);
}
void TouchscreenUI::drawModeButton() {
uint16_t color = config->system.isDCCMode ? COLOR_DCC : COLOR_ANALOG;
tft.fillRoundRect(btnMode.x, btnMode.y, btnMode.w, btnMode.h, 5, color);
tft.drawRoundRect(btnMode.x, btnMode.y, btnMode.w, btnMode.h, 5, COLOR_TEXT);
tft.setTextColor(COLOR_BG);
tft.setTextDatum(MC_DATUM);
tft.drawString(config->system.isDCCMode ? "DCC" : "DC", btnMode.x + btnMode.w/2, btnMode.y + btnMode.h/2, 2);
}
void TouchscreenUI::drawRailsButton() {
uint16_t color = config->system.is3Rail ? COLOR_SLIDER_ACTIVE : COLOR_BUTTON;
tft.fillRoundRect(btnRails.x, btnRails.y, btnRails.w, btnRails.h, 5, color);
tft.drawRoundRect(btnRails.x, btnRails.y, btnRails.w, btnRails.h, 5, COLOR_TEXT);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(MC_DATUM);
tft.drawString(config->system.is3Rail ? "3-Rail" : "2-Rail", btnRails.x + btnRails.w/2, btnRails.y + btnRails.h/2, 2);
}
void TouchscreenUI::drawDirectionButton() {
tft.fillRoundRect(btnDirection.x, btnDirection.y, btnDirection.w, btnDirection.h, 5, COLOR_BUTTON);
tft.drawRoundRect(btnDirection.x, btnDirection.y, btnDirection.w, btnDirection.h, 5, COLOR_TEXT);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(MC_DATUM);
tft.drawString(config->system.direction ? "FWD" : "REV", btnDirection.x + btnDirection.w/2, btnDirection.y + btnDirection.h/2, 2);
}
void TouchscreenUI::drawSpeedSlider() {
// Draw slider track
tft.fillRoundRect(sliderX, sliderY, sliderW, sliderH, 5, COLOR_SLIDER);
// Calculate knob position based on speed
sliderKnobX = sliderX + (config->system.speed * (sliderW - 20)) / 100;
// Draw speed text above slider
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(MC_DATUM);
tft.fillRect(sliderX, sliderY - 30, sliderW, 25, COLOR_BG);
String speedText = "Speed: " + String(config->system.speed) + "%";
tft.drawString(speedText, sliderX + sliderW/2, sliderY - 15, 4);
// Draw active portion of slider
if (config->system.speed > 0) {
tft.fillRoundRect(sliderX, sliderY, sliderKnobX - sliderX + 10, sliderH, 5, COLOR_SLIDER_ACTIVE);
}
// Draw knob
tft.fillCircle(sliderKnobX + 10, sliderY + sliderH/2, 15, COLOR_TEXT);
}
void TouchscreenUI::drawStatusBar() {
// Status bar at bottom
int y = 200;
tft.fillRect(0, y, 320, 40, COLOR_PANEL);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(TL_DATUM);
String status = "PWR:" + String(powerOn ? "ON" : "OFF");
status += " | Mode:" + String(config->system.isDCCMode ? "DCC" : "DC");
status += " | " + String(config->system.is3Rail ? "3-Rail" : "2-Rail");
if (config->system.isDCCMode && powerOn) {
status += " | Addr:" + String(config->system.dccAddress);
}
tft.drawString(status, 5, y + 5, 2);
tft.drawString("Speed:" + String(config->system.speed) + "% " + String(config->system.direction ? "FWD" : "REV"),
5, y + 20, 2);
}
void TouchscreenUI::handleTouch(int16_t x, int16_t y) {
// If in programming mode, handle differently
if (programmingMode) {
// Check back button
if (x >= btnProgBack.x && x <= btnProgBack.x + btnProgBack.w &&
y >= btnProgBack.y && y <= btnProgBack.y + btnProgBack.h) {
exitProgrammingMode();
return;
}
// Check factory reset button
if (x >= btnFactoryReset.x && x <= btnFactoryReset.x + btnFactoryReset.w &&
y >= btnFactoryReset.y && y <= btnFactoryReset.y + btnFactoryReset.h) {
performFactoryReset();
return;
}
// Check set address button
if (x >= btnSetAddress.x && x <= btnSetAddress.x + btnSetAddress.w &&
y >= btnSetAddress.y && y <= btnSetAddress.y + btnSetAddress.h) {
performSetAddress();
return;
}
// Check read CV button
if (x >= btnReadCV.x && x <= btnReadCV.x + btnReadCV.w &&
y >= btnReadCV.y && y <= btnReadCV.y + btnReadCV.h) {
performReadCV();
return;
}
// Check write CV button
if (x >= btnWriteCV.x && x <= btnWriteCV.x + btnWriteCV.w &&
y >= btnWriteCV.y && y <= btnWriteCV.y + btnWriteCV.h) {
performWriteCV();
return;
}
// Check numeric keypad
for (int i = 0; i < NUM_KEYPAD_BUTTONS; i++) {
if (x >= btnKeypad[i].x && x <= btnKeypad[i].x + btnKeypad[i].w &&
y >= btnKeypad[i].y && y <= btnKeypad[i].y + btnKeypad[i].h) {
handleKeypadPress(i);
return;
}
}
return;
}
// Normal mode touch handling
// Check power button
if (x >= btnPower.x && x <= btnPower.x + btnPower.w &&
y >= btnPower.y && y <= btnPower.y + btnPower.h) {
updatePowerState(!powerOn);
return;
}
// Check mode button
if (x >= btnMode.x && x <= btnMode.x + btnMode.w &&
y >= btnMode.y && y <= btnMode.y + btnMode.h) {
updateMode(!config->system.isDCCMode);
return;
}
// Check rails button
if (x >= btnRails.x && x <= btnRails.x + btnRails.w &&
y >= btnRails.y && y <= btnRails.y + btnRails.h) {
updateRailMode(!config->system.is3Rail);
return;
}
// Check direction button
if (x >= btnDirection.x && x <= btnDirection.x + btnDirection.w &&
y >= btnDirection.y && y <= btnDirection.y + btnDirection.h) {
updateDirection();
return;
}
// Check DCC function buttons (only in DCC mode)
if (config->system.isDCCMode) {
for (int i = 0; i < NUM_FUNCTIONS; i++) {
if (x >= btnFunctions[i].x && x <= btnFunctions[i].x + btnFunctions[i].w &&
y >= btnFunctions[i].y && y <= btnFunctions[i].y + btnFunctions[i].h) {
toggleDccFunction(i);
return;
}
}
// Check DCC address button (placeholder for future address entry)
if (x >= btnDccAddress.x && x <= btnDccAddress.x + btnDccAddress.w &&
y >= btnDccAddress.y && y <= btnDccAddress.y + btnDccAddress.h) {
// Future: Show numeric keypad for address entry
Serial.println("DCC Address button pressed - feature coming soon");
return;
}
// Check programming button
if (x >= btnProgramming.x && x <= btnProgramming.x + btnProgramming.w &&
y >= btnProgramming.y && y <= btnProgramming.y + btnProgramming.h) {
enterProgrammingMode();
return;
}
}
// Check slider
if (x >= sliderX && x <= sliderX + sliderW &&
y >= sliderY - 10 && y <= sliderY + sliderH + 10) {
// Calculate speed from touch position
int newSpeed = ((x - sliderX) * 100) / sliderW;
newSpeed = constrain(newSpeed, 0, 100);
updateSpeed(newSpeed);
return;
}
}
void TouchscreenUI::updatePowerState(bool state) {
powerOn = state;
if (!powerOn) {
// Turn everything off
config->system.speed = 0;
motorController->stop();
dccGenerator->disable();
} else {
// Power on - restore based on mode
if (config->system.isDCCMode) {
dccGenerator->enable();
dccGenerator->setLocoSpeed(config->system.dccAddress, config->system.speed, config->system.direction);
} else {
motorController->setSpeed(config->system.speed, config->system.direction);
}
}
config->save();
drawPowerButton();
drawSpeedSlider();
drawStatusBar();
Serial.print("Power: ");
Serial.println(powerOn ? "ON" : "OFF");
}
void TouchscreenUI::updateMode(bool isDCC) {
// Always power off when changing modes
powerOn = false;
config->system.speed = 0;
config->system.isDCCMode = isDCC;
// Stop both controllers
motorController->stop();
dccGenerator->disable();
config->save();
drawPowerButton();
drawModeButton();
drawSpeedSlider();
drawStatusBar();
Serial.print("Mode changed to: ");
Serial.println(isDCC ? "DCC" : "DC Analog");
Serial.println("Power automatically turned OFF");
}
void TouchscreenUI::updateRailMode(bool is3Rail) {
config->system.is3Rail = is3Rail;
relayController->setRailMode(is3Rail);
config->save();
drawRailsButton();
drawStatusBar();
}
void TouchscreenUI::updateDirection() {
config->system.direction = !config->system.direction;
if (powerOn) {
if (config->system.isDCCMode) {
dccGenerator->setLocoSpeed(config->system.dccAddress, config->system.speed, config->system.direction);
} else {
motorController->setSpeed(config->system.speed, config->system.direction);
}
}
config->save();
drawDirectionButton();
drawStatusBar();
Serial.print("Direction: ");
Serial.println(config->system.direction ? "Forward" : "Reverse");
}
void TouchscreenUI::updateSpeed(uint8_t newSpeed) {
config->system.speed = newSpeed;
if (powerOn) {
if (config->system.isDCCMode) {
dccGenerator->setLocoSpeed(config->system.dccAddress, config->system.speed, config->system.direction);
} else {
motorController->setSpeed(config->system.speed, config->system.direction);
}
}
config->save();
drawSpeedSlider();
drawStatusBar();
}
int16_t TouchscreenUI::mapTouch(int16_t value, int16_t inMin, int16_t inMax, int16_t outMin, int16_t outMax) {
return (value - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
}
void TouchscreenUI::drawDccFunctions() {
// Only draw if in DCC mode
if (!config->system.isDCCMode) {
// Clear the function button area
tft.fillRect(0, 68, 320, 60, COLOR_BG);
return;
}
// Draw all function buttons
for (int i = 0; i < NUM_FUNCTIONS; i++) {
bool isActive = (config->system.dccFunctions >> i) & 0x01;
uint16_t color = isActive ? COLOR_FUNCTION_ON : COLOR_FUNCTION_OFF;
tft.fillRoundRect(btnFunctions[i].x, btnFunctions[i].y,
btnFunctions[i].w, btnFunctions[i].h, 3, color);
tft.drawRoundRect(btnFunctions[i].x, btnFunctions[i].y,
btnFunctions[i].w, btnFunctions[i].h, 3, COLOR_TEXT);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(MC_DATUM);
tft.drawString(btnFunctions[i].label,
btnFunctions[i].x + btnFunctions[i].w/2,
btnFunctions[i].y + btnFunctions[i].h/2, 1);
}
}
void TouchscreenUI::drawDccAddressButton() {
if (!config->system.isDCCMode) {
return;
}
tft.fillRoundRect(btnDccAddress.x, btnDccAddress.y,
btnDccAddress.w, btnDccAddress.h, 3, COLOR_BUTTON);
tft.drawRoundRect(btnDccAddress.x, btnDccAddress.y,
btnDccAddress.w, btnDccAddress.h, 3, COLOR_TEXT);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(MC_DATUM);
String addrText = "A:" + String(config->system.dccAddress);
tft.drawString(addrText,
btnDccAddress.x + btnDccAddress.w/2,
btnDccAddress.y + btnDccAddress.h/2, 2);
// Draw programming button
tft.fillRoundRect(btnProgramming.x, btnProgramming.y,
btnProgramming.w, btnProgramming.h, 3, COLOR_DCC);
tft.drawRoundRect(btnProgramming.x, btnProgramming.y,
btnProgramming.w, btnProgramming.h, 3, COLOR_TEXT);
tft.setTextColor(COLOR_BG);
tft.drawString("PROG",
btnProgramming.x + btnProgramming.w/2,
btnProgramming.y + btnProgramming.h/2, 2);
}
void TouchscreenUI::toggleDccFunction(uint8_t function) {
if (!config->system.isDCCMode || function >= NUM_FUNCTIONS) {
return;
}
// Toggle the function bit
config->system.dccFunctions ^= (1 << function);
// Send to DCC generator if power is on
if (powerOn) {
bool state = (config->system.dccFunctions >> function) & 0x01;
dccGenerator->setFunction(config->system.dccAddress, function, state);
}
// Save configuration
config->save();
// Redraw function buttons
drawDccFunctions();
Serial.print("DCC Function F");
Serial.print(function);
Serial.print(": ");
Serial.println((config->system.dccFunctions >> function) & 0x01 ? "ON" : "OFF");
}
void TouchscreenUI::enterProgrammingMode() {
programmingMode = true;
cvNumber = 1;
cvValue = 0;
newAddress = config->system.dccAddress;
keypadMode = 0; // Start with address entry
tft.fillScreen(COLOR_BG);
drawProgrammingScreen();
Serial.println("Entered DCC Programming Mode");
}
void TouchscreenUI::exitProgrammingMode() {
programmingMode = false;
tft.fillScreen(COLOR_BG);
drawUI();
Serial.println("Exited DCC Programming Mode");
}
void TouchscreenUI::drawProgrammingScreen() {
tft.fillScreen(COLOR_BG);
// Title
tft.setTextColor(COLOR_DCC);
tft.setTextDatum(TC_DATUM);
tft.drawString("DCC PROGRAMMING", 160, 5, 4);
// Back button
btnProgBack.x = 5;
btnProgBack.y = 5;
btnProgBack.w = 60;
btnProgBack.h = 30;
tft.fillRoundRect(btnProgBack.x, btnProgBack.y, btnProgBack.w, btnProgBack.h, 5, COLOR_POWER_OFF);
tft.drawRoundRect(btnProgBack.x, btnProgBack.y, btnProgBack.w, btnProgBack.h, 5, COLOR_TEXT);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(MC_DATUM);
tft.drawString("BACK", btnProgBack.x + btnProgBack.w/2, btnProgBack.y + btnProgBack.h/2, 2);
// Factory Reset button
btnFactoryReset.x = 10;
btnFactoryReset.y = 45;
btnFactoryReset.w = 140;
btnFactoryReset.h = 35;
tft.fillRoundRect(btnFactoryReset.x, btnFactoryReset.y, btnFactoryReset.w, btnFactoryReset.h, 5, COLOR_POWER_OFF);
tft.drawRoundRect(btnFactoryReset.x, btnFactoryReset.y, btnFactoryReset.w, btnFactoryReset.h, 5, COLOR_TEXT);
tft.setTextColor(COLOR_TEXT);
tft.drawString("FACTORY RESET", btnFactoryReset.x + btnFactoryReset.w/2, btnFactoryReset.y + btnFactoryReset.h/2, 2);
// Set Address section
btnSetAddress.x = 170;
btnSetAddress.y = 45;
btnSetAddress.w = 140;
btnSetAddress.h = 35;
tft.fillRoundRect(btnSetAddress.x, btnSetAddress.y, btnSetAddress.w, btnSetAddress.h, 5, COLOR_POWER_ON);
tft.drawRoundRect(btnSetAddress.x, btnSetAddress.y, btnSetAddress.w, btnSetAddress.h, 5, COLOR_TEXT);
tft.setTextColor(COLOR_TEXT);
tft.drawString("SET ADDRESS", btnSetAddress.x + btnSetAddress.w/2, btnSetAddress.y + btnSetAddress.h/2, 2);
// Address display with selection indicator
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(TL_DATUM);
tft.drawString("New Addr:", 175, 85, 2);
// Highlight selected field
if (keypadMode == 0) {
tft.fillRoundRect(245, 83, 60, 22, 3, COLOR_FUNCTION_ON);
}
tft.setTextColor(keypadMode == 0 ? COLOR_BG : COLOR_FUNCTION_ON);
tft.setTextDatum(TR_DATUM);
tft.drawString(String(newAddress), 300, 85, 4);
// CV Programming section
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(TL_DATUM);
tft.drawString("CV#:", 10, 110, 2);
if (keypadMode == 1) {
tft.fillRoundRect(50, 108, 80, 22, 3, COLOR_DCC);
}
tft.setTextColor(keypadMode == 1 ? COLOR_BG : COLOR_DCC);
tft.setTextDatum(TR_DATUM);
tft.drawString(String(cvNumber), 125, 110, 4);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(TL_DATUM);
tft.drawString("Val:", 140, 110, 2);
if (keypadMode == 2) {
tft.fillRoundRect(180, 108, 60, 22, 3, COLOR_DCC);
}
tft.setTextColor(keypadMode == 2 ? COLOR_BG : COLOR_DCC);
tft.setTextDatum(TR_DATUM);
tft.drawString(String(cvValue), 235, 110, 4);
// Mode selector hint
tft.setTextColor(COLOR_BUTTON);
tft.setTextDatum(TL_DATUM);
String modeText = "Editing: ";
if (keypadMode == 0) modeText += "ADDRESS";
else if (keypadMode == 1) modeText += "CV NUMBER";
else modeText += "CV VALUE";
tft.drawString(modeText, 245, 110, 1);
// Read/Write CV buttons
btnReadCV.x = 10;
btnReadCV.y = 140;
btnReadCV.w = 145;
btnReadCV.h = 30;
tft.fillRoundRect(btnReadCV.x, btnReadCV.y, btnReadCV.w, btnReadCV.h, 5, COLOR_ANALOG);
tft.drawRoundRect(btnReadCV.x, btnReadCV.y, btnReadCV.w, btnReadCV.h, 5, COLOR_TEXT);
tft.setTextColor(COLOR_BG);
tft.setTextDatum(MC_DATUM);
tft.drawString("READ CV", btnReadCV.x + btnReadCV.w/2, btnReadCV.y + btnReadCV.h/2, 2);
btnWriteCV.x = 165;
btnWriteCV.y = 140;
btnWriteCV.w = 145;
btnWriteCV.h = 30;
tft.fillRoundRect(btnWriteCV.x, btnWriteCV.y, btnWriteCV.w, btnWriteCV.h, 5, COLOR_FUNCTION_ON);
tft.drawRoundRect(btnWriteCV.x, btnWriteCV.y, btnWriteCV.w, btnWriteCV.h, 5, COLOR_TEXT);
tft.setTextColor(COLOR_BG);
tft.drawString("WRITE CV", btnWriteCV.x + btnWriteCV.w/2, btnWriteCV.y + btnWriteCV.h/2, 2);
// Draw numeric keypad
drawNumericKeypad();
// Status area
drawProgrammingStatus();
}
void TouchscreenUI::drawNumericKeypad() {
// Numeric keypad layout: 3x4 grid (1-9, 0, backspace, enter)
int btnW = 60;
int btnH = 30;
int startX = 50;
int startY = 175;
int spacing = 5;
const char* labels[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "<", "0", "OK"};
for (int i = 0; i < NUM_KEYPAD_BUTTONS; i++) {
int col = i % 3;
int row = i / 3;
btnKeypad[i].x = startX + col * (btnW + spacing);
btnKeypad[i].y = startY + row * (btnH + spacing);
btnKeypad[i].w = btnW;
btnKeypad[i].h = btnH;
btnKeypad[i].label = labels[i];
uint16_t color = COLOR_BUTTON;
if (i == 9) color = COLOR_POWER_OFF; // Backspace in red
if (i == 11) color = COLOR_POWER_ON; // OK in green
tft.fillRoundRect(btnKeypad[i].x, btnKeypad[i].y, btnKeypad[i].w, btnKeypad[i].h, 3, color);
tft.drawRoundRect(btnKeypad[i].x, btnKeypad[i].y, btnKeypad[i].w, btnKeypad[i].h, 3, COLOR_TEXT);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(MC_DATUM);
tft.drawString(btnKeypad[i].label, btnKeypad[i].x + btnKeypad[i].w/2, btnKeypad[i].y + btnKeypad[i].h/2, 2);
}
}
void TouchscreenUI::drawProgrammingStatus() {
// Status message area at bottom
tft.fillRect(0, 215, 320, 25, COLOR_PANEL);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(TC_DATUM);
tft.drawString("Programming Track Mode - Loco on Prog Track", 160, 220, 1);
}
void TouchscreenUI::handleKeypadPress(uint8_t key) {
uint16_t* currentValue;
uint16_t maxValue;
// Select which value we're editing
if (keypadMode == 0) {
currentValue = &newAddress;
maxValue = 10239;
} else if (keypadMode == 1) {
currentValue = &cvNumber;
maxValue = 1024;
} else {
currentValue = (uint16_t*)&cvValue; // Cast for consistency
maxValue = 255;
}
if (key < 9) {
// Number keys 1-9
*currentValue = (*currentValue) * 10 + (key + 1);
if (*currentValue > maxValue) *currentValue = key + 1; // Reset if too large
} else if (key == 9) {
// Backspace
*currentValue = (*currentValue) / 10;
if (keypadMode == 0 && *currentValue == 0) *currentValue = 1; // Address min is 1
if (keypadMode == 1 && *currentValue == 0) *currentValue = 1; // CV min is 1
} else if (key == 10) {
// 0 key
*currentValue = (*currentValue) * 10;
if (*currentValue > maxValue) *currentValue = 0;
} else if (key == 11) {
// OK - move to next field
keypadMode = (keypadMode + 1) % 3;
Serial.print("Switched to mode: ");
if (keypadMode == 0) Serial.println("ADDRESS");
else if (keypadMode == 1) Serial.println("CV NUMBER");
else Serial.println("CV VALUE");
}
// Constrain to valid range
if (keypadMode == 2) {
cvValue = constrain(*currentValue, 0, 255);
}
// Redraw the screen to update values
drawProgrammingScreen();
}
void TouchscreenUI::performFactoryReset() {
Serial.println("FACTORY RESET - Sending CV8 = 8");
// Update status
tft.fillRect(0, 215, 320, 25, COLOR_POWER_OFF);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(TC_DATUM);
tft.drawString("Sending Factory Reset... CV8 = 8", 160, 220, 1);
// Call DCCGenerator factory reset
bool success = dccGen->factoryReset();
// Update status based on result
delay(500);
tft.fillRect(0, 215, 320, 25, success ? COLOR_FUNCTION_ON : COLOR_POWER_OFF);
tft.setTextColor(COLOR_BG);
tft.setTextDatum(TC_DATUM);
if (success) {
tft.drawString("Factory Reset Complete!", 160, 220, 1);
} else {
tft.drawString("Factory Reset Failed - No ACK", 160, 220, 1);
}
delay(2000);
drawProgrammingStatus();
Serial.println("Factory reset command sent");
}
void TouchscreenUI::performSetAddress() {
if (newAddress < 1 || newAddress > 10239) {
Serial.println("Invalid address range");
tft.fillRect(0, 215, 320, 25, COLOR_POWER_OFF);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(TC_DATUM);
tft.drawString("ERROR: Address must be 1-10239", 160, 220, 1);
delay(2000);
drawProgrammingStatus();
return;
}
Serial.print("Setting DCC Address to: ");
Serial.println(newAddress);
// Update status
tft.fillRect(0, 215, 320, 25, COLOR_FUNCTION_ON);
tft.setTextColor(COLOR_BG);
tft.setTextDatum(TC_DATUM);
tft.drawString("Programming Address " + String(newAddress) + "...", 160, 220, 1);
// Call DCCGenerator to set address
bool success = dccGen->setDecoderAddress(newAddress);
// Update status based on result
delay(500);
tft.fillRect(0, 215, 320, 25, success ? COLOR_FUNCTION_ON : COLOR_POWER_OFF);
tft.setTextColor(COLOR_BG);
tft.setTextDatum(TC_DATUM);
if (success) {
tft.drawString("Address " + String(newAddress) + " Set!", 160, 220, 1);
// Update config with new address
config->system.dccAddress = newAddress;
config->save();
} else {
tft.drawString("Address Programming Failed - No ACK", 160, 220, 1);
}
delay(2000);
drawProgrammingStatus();
Serial.println("Address programming complete");
}
void TouchscreenUI::performReadCV() {
if (cvNumber < 1 || cvNumber > 1024) {
Serial.println("Invalid CV number");
tft.fillRect(0, 215, 320, 25, COLOR_POWER_OFF);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(TC_DATUM);
tft.drawString("ERROR: CV must be 1-1024", 160, 220, 1);
delay(2000);
drawProgrammingStatus();
return;
}
Serial.print("Reading CV");
Serial.println(cvNumber);
// Update status
tft.fillRect(0, 215, 320, 25, COLOR_ANALOG);
tft.setTextColor(COLOR_BG);
tft.setTextDatum(TC_DATUM);
tft.drawString("Reading CV" + String(cvNumber) + "...", 160, 220, 1);
// Call DCCGenerator to read CV
uint8_t readValue = 0;
bool success = dccGen->readCV(cvNumber, &readValue);
if (success) {
cvValue = readValue;
Serial.print("CV");
Serial.print(cvNumber);
Serial.print(" = ");
Serial.println(cvValue);
// Update status
delay(500);
tft.fillRect(0, 215, 320, 25, COLOR_FUNCTION_ON);
tft.setTextColor(COLOR_BG);
tft.setTextDatum(TC_DATUM);
tft.drawString("CV" + String(cvNumber) + " = " + String(cvValue), 160, 220, 1);
delay(1500);
} else {
tft.fillRect(0, 215, 320, 25, COLOR_POWER_OFF);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(TC_DATUM);
tft.drawString("Read Failed - No Response", 160, 220, 1);
delay(1500);
}
drawProgrammingScreen();
}
void TouchscreenUI::performWriteCV() {
if (cvNumber < 1 || cvNumber > 1024) {
Serial.println("Invalid CV number");
tft.fillRect(0, 215, 320, 25, COLOR_POWER_OFF);
tft.setTextColor(COLOR_TEXT);
tft.setTextDatum(TC_DATUM);
tft.drawString("ERROR: CV must be 1-1024", 160, 220, 1);
delay(2000);
drawProgrammingStatus();
return;
}
Serial.print("Writing CV");
Serial.print(cvNumber);
Serial.print(" = ");
Serial.println(cvValue);
// Update status
tft.fillRect(0, 215, 320, 25, COLOR_FUNCTION_ON);
tft.setTextColor(COLOR_BG);
tft.setTextDatum(TC_DATUM);
tft.drawString("Writing CV" + String(cvNumber) + " = " + String(cvValue) + "...", 160, 220, 1);
// Call DCCGenerator to write CV
bool success = dccGen->writeCV(cvNumber, cvValue);
// Update status based on result
delay(500);
tft.fillRect(0, 215, 320, 25, success ? COLOR_FUNCTION_ON : COLOR_POWER_OFF);
tft.setTextColor(COLOR_BG);
tft.setTextDatum(TC_DATUM);
if (success) {
tft.drawString("CV" + String(cvNumber) + " = " + String(cvValue) + " Verified!", 160, 220, 1);
} else {
tft.drawString("Write Failed - No ACK", 160, 220, 1);
}
delay(1500);
drawProgrammingStatus();
Serial.println("CV write complete");
}

109
ESP32/DCC-Bench/src/main.cpp Normal file
View File

@@ -0,0 +1,109 @@
/**
* @file main.cpp
* @brief Main application entry point for Locomotive Test Bench
*
* Orchestrates all system components:
* - Configuration management
* - Touchscreen UI
* - Motor control (DC analog)
* - DCC signal generation
* - Relay control for 2-rail/3-rail switching
*
* @author Locomotive Test Bench Project
* @date 2025
* @version 2.0
*/
#include <Arduino.h>
#include "Config.h"
#include "MotorController.h"
#include "DCCGenerator.h"
#include "RelayController.h"
#include "TouchscreenUI.h"
// Global objects
Config config;
MotorController motorController;
DCCGenerator dccGenerator;
RelayController relayController;
TouchscreenUI touchUI(&config, &motorController, &dccGenerator, &relayController);
/**
* @brief Setup function - runs once at startup
*
* Initializes all hardware and software components in correct order:
* 1. Serial communication
* 2. Configuration system
* 3. Relay controller
* 4. Motor controller
* 5. DCC generator
* 6. Touchscreen UI
*/
void setup() {
// Initialize serial communication
Serial.begin(115200);
delay(1000);
Serial.println("\n\n=================================");
Serial.println(" Locomotive Test Bench v2.0");
Serial.println(" ESP32-2432S028R Edition");
Serial.println("=================================\n");
// Load configuration
config.begin();
Serial.println("Configuration loaded");
// Initialize relay controller
relayController.begin();
relayController.setRailMode(config.system.is3Rail);
// Initialize motor controller
motorController.begin();
// Initialize DCC generator
dccGenerator.begin();
// Initialize touchscreen UI
touchUI.begin();
// Set initial mode (but power is off by default)
if (config.system.isDCCMode && config.system.powerOn) {
dccGenerator.enable();
dccGenerator.setLocoSpeed(
config.system.dccAddress,
config.system.speed,
config.system.direction
);
} else if (!config.system.isDCCMode && config.system.powerOn) {
motorController.setSpeed(
config.system.speed,
config.system.direction
);
}
Serial.println("\n=================================");
Serial.println("Setup complete!");
Serial.println("=================================");
Serial.print("Mode: ");
Serial.println(config.system.isDCCMode ? "DCC" : "DC Analog");
Serial.print("Rail Mode: ");
Serial.println(config.system.is3Rail ? "3-Rail" : "2-Rail");
Serial.print("Power: ");
Serial.println(config.system.powerOn ? "ON" : "OFF");
Serial.println("=================================\n");
}
void loop() {
// Update touchscreen UI (handles all user interactions)
touchUI.update();
// Update DCC signal generation (if enabled)
if (config.system.isDCCMode && touchUI.isPowerOn()) {
dccGenerator.update();
} else if (!config.system.isDCCMode && touchUI.isPowerOn()) {
motorController.update();
}
// Small delay to prevent watchdog issues
delay(1);
}

314
ESP32/DCC-Loco/Hardware/README.md Normal file
View File

@@ -0,0 +1,314 @@
# Hardware Design Files
This folder is reserved for KiCad hardware design files for the DCC Locomotive Decoder.
## Planned Contents
- **Schematic**: Complete circuit schematic (`.kicad_sch`)
- **PCB Layout**: Printed circuit board design (`.kicad_pcb`)
- **Bill of Materials**: Component list (BOM.csv)
- **Gerber Files**: Manufacturing files
- **3D Models**: Component models
- **Assembly Drawings**: Assembly instructions
## Current Status
🚧 **Under Development**
Hardware design files will be added in future releases.
## Design Goals
- Compact form factor suitable for HO/N scale locomotives
- Single or dual-sided PCB (TBD)
- Through-hole or SMD components (TBD)
- Easy assembly and testing
- Robust protection circuits
- Proper EMI/EMC considerations
## Sections
The PCB will include the following sections:
1. **Power Supply**
- Track power input with TVS protection
- Schottky diode bridge rectifier (4x SS54: 5A, 40V)
- Bulk filtering capacitors (470µF-1000µF electrolytic)
- 3.3V LDO regulator for ESP32-H2 logic
- Separate motor power feed to TB67H450FNG VM pin
- Ceramic bypass capacitors (0.1µF near ICs)
2. **DCC Input Stage**
- Optocoupler isolation
- Signal conditioning
- Protection diodes
3. **Motor Driver**
- TB67H450FNG H-bridge
- Current sense circuit (0.1Ω shunt resistor)
- Bootstrap capacitors (if needed for gate drive)
- Flyback diodes (usually internal to TB67H450FNG)
- Bulk motor power capacitor (100µF near VM pin)
4. **Microcontroller**
- ESP32-H2 module or bare chip
- Programming header
- Reset and boot buttons
5. **LED Output**
- WS2812 connector
- Level shifter (if needed)
- Power filtering
6. **RailCom**
- RailCom transmitter circuit
- Cutout detection
- Track coupling circuit
7. **Accessory Outputs**
- 2x N-FET drivers
- Screw terminals or connectors
- Protection circuits
8. **Configuration**
- Configuration button
- Status LED
- Optional programming port
## Component Selection
### Key Components
- **Bridge Rectifier**: 4x SS54 Schottky diodes (5A, 40V, SMA/DO-214AC) or SS56 (5A, 60V)
- Lower forward drop (~0.5V per diode, 1V total vs 2V for standard bridge)
- Better efficiency = less heat
- Fast switching for DCC frequency
- Arrange in standard bridge configuration
- **Microcontroller**: ESP32-H2 (RISC-V, Zigbee/Thread)
- **Motor Driver**: Toshiba TB67H450FNG (dual H-bridge, 3.5A)
- **Optocoupler**: 6N137 (fast) or PC817 (general purpose)
- **N-FETs**: AO3400A (SOT-23, 4A, 44mΩ RDS(on) @ 2.5V)
- For accessory outputs (max 350mA each)
- Logic-level compatible with 3.3V GPIO
- Low cost (~$0.05-0.10)
- **Voltage Regulator**: AMS1117-3.3 (800mA) or HT7333 (LDO, low dropout)
- **Current Sense Resistor**: 0.1Ω, 1W metal film or wire-wound
- **LEDs**: WS2812B or compatible addressable RGB LEDs
### Connectors
- **Motor**: 2-pin screw terminal or JST-XH
- **Track Input**: 2-pin screw terminal
- **LED Strip**: 3-pin JST connector
- **Accessories**: 2x 2-pin screw terminals
- **Programming**: 6-pin header (GND, 3V3, TX, RX, IO0, EN)
## Design Considerations
### Power Supply Schematic
![Power Supply Schematic](power-supply.png)
```ditaa {cmd=true args=["-E"]}
DCC Track Input (12-18V AC/DC)
|
v
+-----+-----+
| TVS | P6KE24A bidirectional
| Diode |
+-----+-----+
|
+-------------+-------------+
| |
Track+ Track-
| |
+-------+-------+ +-------+-------+
| D1 | | D3 |
| SS54 5A | | SS54 5A |
+-------+-------+ +-------+-------+
| |
+--------->DC+<-------------+
|
| +----------------------------+
+--| 1000uF/25V Electrolytic |
| +----------------------------+
|
+---> TB67H450FNG VM (Motor Power)
|
| +----------------------------+
+--| AMS1117-3.3 or HT7333 LDO |
| +----------------------------+
| |
| +--| 100uF |---> 3.3V Logic
| |
+-------+-------+ | | +-------+-------+
| D2 | | | | D4 |
| SS54 5A | | | | SS54 5A |
+-------+-------+ | | +-------+-------+
| | | |
+--------->GND<--------+----------+
|
Common Ground
```
**Bridge Configuration:**
- Track inputs: Connect to DCC rails (polarity-independent)
- DC+ rail: 10-16V after rectification
- Forward drop: ~1V total (0.5V per diode pair)
- SS54 Schottky: 5A continuous, 40V rating
- Handles motor (1-3A) + logic (~200mA) simultaneously
**Component Values:**
- Bridge: 4x SS54 (SMA package)
- Bulk cap: 1000µF/25V electrolytic
- LDO input cap: 10µF ceramic
- LDO output cap: 100µF electrolytic + 0.1µF ceramic
- TVS: P6KE24A or 1.5KE24CA
### RailCom Transmitter Schematic
![RailCom Transmitter Schematic](railcom.png)
```ditaa {cmd=true args=["-E"]}
ESP32-H2 GPIO10 (UART1 TX)
|
v
+-----+-----+
| 1kΩ | Pull-up
+-----+-----+
|
+--------+
| |
+-----+-----+ |
| NPN BJT | | BC817 or 2N3904
| Q1 |<-+
+-----+-----+
|C
|
+-----------+
| |
+----+----+ +---+---+
| 10Ω | | 100pF | Snubber
+----+----+ +---+---+
| |
+-----------+--------> To Track (via DCC cutout)
|
|
+-----+-----+
| 10kΩ | Pull-down
+-----+-----+
|
v
GND
RailCom Cutout Detection (Optional GPIO11)
Track Signal ---+
|
+---+---+
|Voltage| Resistor divider
|Divider| 22kΩ / 10kΩ
+---+---+
|
+---> GPIO11 (Cutout Detect)
|
+---+---+
| 0.1µF | Filter capacitor
+---+---+
|
GND
```
**RailCom Operation:**
1. **Cutout Detection**: DCC command station creates ~450µs cutout window
2. **Channel Timing**:
- Channel 1: 26-177µs (address broadcast)
- Channel 2: 193-454µs (status data)
3. **Transmit**: UART TX at 250kbaud during cutout
4. **Encoding**: 4-to-8 bit encoding per RailCom spec
**Components:**
- Q1: BC817 NPN (SOT-23) or 2N3904
- R1: 1kΩ base resistor
- R2: 10Ω series resistor (current limit)
- R3: 10kΩ pull-down
- C1: 100pF snubber capacitor
- Cutout divider: 22kΩ + 10kΩ (scales track voltage to 3.3V)
**Important Notes:**
- RailCom transmits ONLY during DCC cutout window
- Requires command station with RailCom support
- Cutout detection is optional (can use timing from last DCC packet)
- Q1 must switch fast enough for 250kbaud (BC817: fT=100MHz)
### Thermal Management
- Adequate copper pour for motor driver heat dissipation
- Thermal vias under motor driver IC
- Consider adding heatsink mounting holes
- Keep power traces wide (minimum 2mm for motor power)
- Bridge diodes: Place on copper pour for heat spreading
### Layout Guidelines
- Keep DCC input traces short and isolated
- Star ground topology for power
- Separate analog and digital grounds near ADC
- Shield sensitive signals (DCC input, current sense)
- Keep high-speed traces short (WS2812 data <10cm)
- Proper decoupling capacitors near ICs (0.1µF within 5mm)
- Wide traces for rectifier output (2-3mm minimum)
### Protection
- TVS diode on track input (P6KE24A bidirectional)
- Schottky diodes provide inherent fast response
- Reverse polarity protection on track input
- TVS diodes on all external connections
- Overcurrent protection on motor output
- ESD protection on user-accessible pins
### Testing
- Test points for key signals (DC+, 3.3V, DCC signal, motor outputs)
- LED indicators for power (3.3V rail), DCC signal presence, status
- Easy access to programming pins
- Measure bridge rectifier forward drop (should be ~1V under load)
- Current sense test point for motor current monitoring
## Future Enhancements
- Dual motor driver option
- Sound module integration (I2S DAC)
- Additional function outputs
- Servo outputs (2-4 channels)
- SUSI interface
- Optional Bluetooth antenna
## Contributing
If you'd like to contribute to the hardware design:
1. Use KiCad 7.0 or newer
2. Follow IPC design standards
3. Include clear documentation
4. Provide design rationale for key decisions
5. Test thoroughly before sharing
## References
- [NMRA DCC Standards](https://www.nmra.org/dcc-standards)
- [TB67H450FNG Datasheet](https://toshiba.semicon-storage.com/ap-en/semiconductor/product/motor-driver-ics/brushed-dc-motor-driver-ics/detail.TB67H450FNG.html)
- [ESP32-H2 Datasheet](https://www.espressif.com/sites/default/files/documentation/esp32-h2_datasheet_en.pdf)
- [RailCom Specification](https://www.lenz-elektronik.de/railcom/)
## License
Hardware designs will be released under CERN Open Hardware License v2 - Permissive (CERN-OHL-P).
---
**Status**: Planned for future release
**Last Updated**: 2026-01-15

39
ESP32/DCC-Loco/Hardware/power-supply.ditaa Normal file
View File

@@ -0,0 +1,39 @@
DCC Track Input (12-18V AC/DC)
|
v
+-----+-----+
| TVS | P6KE24A bidirectional
| Diode |
+-----+-----+
|
+-------------+-------------+
| |
Track+ Track-
| |
+-------+-------+ +-------+-------+
| D1 | | D3 |
| SS54 5A | | SS54 5A |
+-------+-------+ +-------+-------+
| |
+--------->DC+<-------------+
|
| +----------------------------+
+--| 1000uF/25V Electrolytic |
| +----------------------------+
|
+---> TB67H450FNG VM (Motor Power)
|
| +----------------------------+
+--| AMS1117-3.3 or HT7333 LDO |
| +----------------------------+
| |
| +--| 100uF |---> 3.3V Logic
| |
+-------+-------+ | | +-------+-------+
| D2 | | | | D4 |
| SS54 5A | | | | SS54 5A |
+-------+-------+ | | +-------+-------+
| | | |
+--------->GND<--------+----------+
|
Common Ground

BIN
ESP32/DCC-Loco/Hardware/power-supply.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 26 KiB

47
ESP32/DCC-Loco/Hardware/railcom.ditaa Normal file
View File

@@ -0,0 +1,47 @@
ESP32-H2 GPIO10 (UART1 TX)
|
v
+-----+-----+
| 1kΩ | Pull-up
+-----+-----+
|
+--------+
| |
+-----+-----+ |
| NPN BJT | | BC817 or 2N3904
| Q1 |<-+
+-----+-----+
|C
|
+-----------+
| |
+----+----+ +---+---+
| 10Ω | | 100pF | Snubber
+----+----+ +---+---+
| |
+-----------+--------> To Track (via DCC cutout)
|
|
+-----+-----+
| 10kΩ | Pull-down
+-----+-----+
|
v
GND
RailCom Cutout Detection (Optional GPIO11)
Track Signal ---+
|
+---+---+
|Voltage| Resistor divider
|Divider| 22kΩ / 10kΩ
+---+---+
|
+---> GPIO11 (Cutout Detect)
|
+---+---+
| 0.1µF | Filter capacitor
+---+---+
|
GND

BIN
ESP32/DCC-Loco/Hardware/railcom.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 30 KiB

544
ESP32/DCC-Loco/README.md Normal file
View File

@@ -0,0 +1,544 @@
# DCC Locomotive Decoder
ESP32-H2 based DCC locomotive decoder with advanced features for model railroading.
## Features
- **DCC Signal Decoding**: Full NMRA-compliant DCC decoder supporting short (1-127) and long (128-10239) addresses
- **Motor Control**: TB67H450FNG H-bridge motor driver with:
- 128-step speed control
- Configurable acceleration/deceleration
- Load compensation with PID control
- Current sensing
- **LED Control**: WS2812 addressable LED support
- Multiple lighting effects (solid, blink, pulse, directional)
- Function-mapped lighting
- Adjustable brightness
- **RailCom Feedback**: Bidirectional communication with command station
- **Accessory Outputs**: 2x N-channel MOSFET outputs for accessories
- Smoke generators
- Sound modules
- Other low-side switched loads
- **Configuration**: WiFi/Bluetooth configuration via WebSocket
- Web-based interface
- CV (Configuration Variable) management
- Real-time status monitoring
## Hardware Requirements
### Components
- **ESP32-H2 Development Board** (e.g., ESP32-H2-DevKitM-1)
- **TB67H450FNG** Motor Driver IC
- **WS2812** or compatible addressable LEDs
- **N-channel MOSFETs** (2x) for accessory outputs (e.g., IRLZ44N)
- **Optocoupler** for DCC signal isolation (e.g., 6N137 or PC817)
- **Current sense resistor** (0.1Ω - 0.5Ω, 1W or higher)
- **Capacitors**: 100µF electrolytic, 0.1µF ceramic
- **Resistors**: Pull-ups/pull-downs as needed
- **Push button** for configuration mode
### Power Supply
- **Track Power**: 12-18V DC from DCC track
- **Logic Power**: 3.3V for ESP32-H2 (use onboard regulator or external LDO)
- **Motor Power**: Same as track power (filtered)
## Wiring Diagram
### DCC Input
```
DCC Track Signal
|
+---[1kΩ]---+---[Optocoupler Anode]
| |
[10kΩ] [0.1µF]
| |
GND GND
Optocoupler Cathode ---[470Ω]--- 3.3V
Optocoupler Output --- GPIO4 (PIN_DCC_INPUT)
Optocoupler Ground --- GND
```
### TB67H450FNG Motor Driver
```
ESP32-H2 TB67H450FNG Motor
GPIO5 ----------- IN1
GPIO6 ----------- IN2
GPIO7 ----------- PWM
OUT1 --------------- M+
OUT2 --------------- M-
VM ---------------- Track+ (12-18V)
VCC ---------------- 3.3V
GND ---------------- GND
Current Sensing:
IPROPI ------------- GPIO8 (via voltage divider)
[0.1Ω Rs between OUT2 and GND]
```
**TB67H450FNG Pin Configuration:**
| Pin | Connection | Description |
|-----|------------|-------------|
| VM | Track Power (12-18V) | Motor power supply |
| VCC | 3.3V | Logic power supply |
| IN1 | GPIO5 | Input 1 (phase A) |
| IN2 | GPIO6 | Input 2 (phase B) |
| PWM | GPIO7 | PWM speed control |
| OUT1 | Motor+ | Motor output 1 |
| OUT2 | Motor- | Motor output 2 |
| IPROPI | GPIO8 | Current monitor output |
| GND | GND | Ground |
**Motor Control Truth Table:**
| IN1 | IN2 | PWM | Operation |
|-----|-----|-----|-----------|
| L | L | X | Brake (standby) |
| H | L | PWM | Forward |
| L | H | PWM | Reverse |
| H | H | X | Brake (active) |
### WS2812 LED Strip
```
ESP32-H2 WS2812
GPIO9 ----------- DIN (Data In)
3.3V/5V --------- VCC (check LED voltage requirements)
GND ------------- GND
Note: Add a 330-470Ω resistor in series with DIN
Add a 100-1000µF capacitor across VCC and GND near LEDs
```
### RailCom
```
ESP32-H2 Circuit
GPIO10 ---------- UART TX (to RailCom transmitter)
GPIO11 ---------- DCC Cutout Detection (optional)
RailCom Transmitter Circuit:
UART TX --- [Transistor Driver] --- Track Signal
(Sends during DCC cutout window)
```
### Accessory Outputs (N-FETs)
```
ESP32-H2 N-FET (IRLZ44N) Load
GPIO12 ---------- Gate 1
Source 1 ---------- GND
Drain 1 ----------- Load 1 (-)
GPIO13 ---------- Gate 2
Source 2 ---------- GND
Drain 2 ----------- Load 2 (-)
Load (+) connects to positive supply
Add 10kΩ pull-down resistor from Gate to Source on each FET
```
### Configuration Button
```
GPIO14 ---------- Button ---------- GND
(Internal pull-up enabled)
```
### Complete Pin Assignment Table
| Pin | Function | Connection | Notes |
|-----|----------|------------|-------|
| GPIO4 | DCC Input | Optocoupler output | DCC signal from track |
| GPIO5 | Motor IN1 | TB67H450FNG IN1 | Motor phase A |
| GPIO6 | Motor IN2 | TB67H450FNG IN2 | Motor phase B |
| GPIO7 | Motor PWM | TB67H450FNG PWM | Speed control |
| GPIO8 | Current Sense | TB67H450FNG IPROPI | ADC input |
| GPIO9 | LED Data | WS2812 DIN | LED control |
| GPIO10 | RailCom TX | UART1 TX | RailCom feedback |
| GPIO11 | Cutout Detect | DCC cutout circuit | Optional |
| GPIO12 | Accessory 1 | N-FET Gate | Output 1 |
| GPIO13 | Accessory 2 | N-FET Gate | Output 2 |
| GPIO14 | Config Button | Push button to GND | Enter config mode |
**Note:** Pin assignments can be modified in `src/main.cpp` (PIN DEFINITIONS section).
## Software Setup
### Prerequisites
- [PlatformIO](https://platformio.org/) installed
- Git (optional)
### Installation
1. Clone or download this repository
2. Open the `DCC-Loco` folder in PlatformIO (VS Code with PlatformIO extension)
3. Build the project:
```bash
pio run
```
4. Upload to ESP32-H2:
```bash
pio run --target upload
```
5. Monitor serial output:
```bash
pio device monitor
```
### Configuration
#### Initial Setup
On first boot, the decoder initializes with default values:
- **Address**: 3 (short address)
- **Acceleration**: 10
- **Deceleration**: 10
- **LED Brightness**: 128 (50%)
- **RailCom**: Enabled
- **Load Compensation**: Enabled
#### Configuration Mode
To enter configuration mode:
1. Hold the configuration button (GPIO14) for 3 seconds
2. The decoder creates a WiFi Access Point:
- **SSID**: `DCC-Loco-XXXXXX` (XXXXXX = device ID)
- **Password**: `dcc12345`
3. Connect to the WiFi AP
4. Open a web browser and navigate to `http://192.168.4.1`
5. Use the web interface to:
- Read/Write Configuration Variables (CVs)
- Test outputs
- Monitor decoder status
- Reset to defaults
6. Press the configuration button again to exit config mode
#### Configuration Variables (CVs)
Standard NMRA CVs:
| CV | Name | Default | Description |
|----|------|---------|-------------|
| 1 | Primary Address | 3 | Short address (1-127) |
| 2 | Vstart | 1 | Start voltage |
| 3 | Acceleration Rate | 10 | Acceleration rate (0-255) |
| 4 | Deceleration Rate | 10 | Deceleration rate (0-255) |
| 5 | Vhigh | 255 | Maximum voltage |
| 6 | Vmid | 128 | Mid voltage |
| 7 | Version ID | 1 | Decoder version |
| 8 | Manufacturer ID | 13 | Manufacturer ID (DIY) |
| 17-18 | Extended Address | - | Long address (128-10239) |
| 29 | Configuration Data | 6 | Config bits (address mode, speed steps) |
Custom CVs:
| CV | Name | Default | Description |
|----|------|---------|-------------|
| 50 | Motor Kp | 50 | PID proportional gain (value/10) |
| 51 | Motor Ki | 5 | PID integral gain (value/10) |
| 52 | Motor Kd | 10 | PID derivative gain (value/10) |
| 53 | RailCom Enable | 1 | Enable RailCom (0=off, 1=on) |
| 54 | Load Comp Enable | 1 | Enable load compensation (0=off, 1=on) |
| 55 | LED Brightness | 128 | LED brightness (0-255) |
| 56 | Accessory 1 Mode | 2 | Accessory output 1 mode |
| 57 | Accessory 2 Mode | 2 | Accessory output 2 mode |
Accessory Modes:
- 0 = Always off
- 1 = Always on
- 2 = Function controlled
- 3 = PWM control
- 4 = Blinking
- 5 = Speed dependent
### WebSocket Protocol
The configuration server uses WebSocket for real-time communication.
**Connect:** `ws://<decoder-ip>/ws`
**Commands:**
Read CV:
```json
{
"command": "read_cv",
"cv": 1
}
```
Write CV:
```json
{
"command": "write_cv",
"cv": 1,
"value": 5
}
```
Get Status:
```json
{
"command": "get_status"
}
```
Reset to Defaults:
```json
{
"command": "reset"
}
```
**Responses:**
CV Read:
```json
{
"type": "cv_read",
"cv": 1,
"value": 3
}
```
Status:
```json
{
"type": "status",
"address": 3,
"speed": 0,
"direction": true,
"signal": true,
"current": 150,
"functions": [false, false, true, ...]
}
```
## Code Structure
```
DCC-Loco/
├── platformio.ini # PlatformIO configuration
├── README.md # This file
├── include/ # Header files
│ ├── DCCDecoder.h # DCC signal decoding
│ ├── CVManager.h # Configuration variable management
│ ├── LEDController.h # WS2812 LED control
│ ├── MotorDriver.h # TB67H450FNG motor control
│ ├── RailCom.h # RailCom feedback
│ ├── AccessoryOutputs.h # Accessory output control
│ └── ConfigServer.h # WiFi/Bluetooth config server
├── src/ # Implementation files
│ ├── main.cpp # Main application
│ ├── DCCDecoder.cpp
│ ├── CVManager.cpp
│ ├── LEDController.cpp
│ ├── MotorDriver.cpp
│ ├── RailCom.cpp
│ ├── AccessoryOutputs.cpp
│ └── ConfigServer.cpp
├── lib/ # Custom libraries (if any)
├── data/ # Web files (future use)
└── Hardware/ # KiCad project files (future)
```
## Module Descriptions
### DCCDecoder
Decodes DCC packets using interrupt-driven bit detection. Supports:
- Short and long addresses
- 128-step speed control
- Functions F0-F28
- Emergency stop
- Signal quality monitoring
### CVManager
Manages Configuration Variables in non-volatile storage using ESP32 Preferences:
- NMRA-compliant CV storage
- Factory reset functionality
- Address management (short/long)
### LEDController
Controls WS2812 addressable LEDs with FastLED:
- Multiple light modes (solid, blink, pulse, directional)
- Function mapping to LEDs
- Brightness control
- Up to 16 LEDs
### MotorDriver
Controls TB67H450FNG motor driver:
- Forward/reverse control
- PWM speed control
- Acceleration/deceleration curves
- Load compensation with PID
- Current monitoring
### RailCom
Implements RailCom feedback protocol:
- Channel 1: Address broadcast
- Channel 2: Status information
- 250kbaud communication
- Cutout detection
### AccessoryOutputs
Controls 2x N-FET outputs:
- Multiple modes (on/off, function, PWM, blink, speed-dependent)
- Function mapping
- Independent control
### ConfigServer
Web-based configuration interface:
- WiFi Access Point mode
- WebSocket real-time communication
- CV read/write
- Status monitoring
- Reset functionality
## Testing
### Basic Test Procedure
1. **Power Up Test**
- Connect decoder to track power (12-18V DC)
- Verify ESP32-H2 boots (check serial output)
- Verify no smoke or excessive heat
2. **DCC Signal Test**
- Apply DCC signal to track
- Check serial monitor for "DCC OK" messages
- Verify correct address detection
3. **Motor Test**
- Send speed commands via DCC controller
- Verify smooth acceleration/deceleration
- Test forward and reverse
- Check emergency stop
4. **LED Test**
- Verify headlights change with direction
- Test function-controlled LEDs (F1, F2, etc.)
- Check brightness adjustment
5. **Accessory Test**
- Activate mapped functions (F3, F4)
- Verify N-FET outputs switch correctly
- Test different output modes
6. **Configuration Test**
- Enter configuration mode (hold button 3s)
- Connect to WiFi AP
- Read/write CVs via web interface
- Verify changes take effect after exit
### Troubleshooting
**No DCC Signal:**
- Check optocoupler wiring
- Verify GPIO4 receives signal
- Check for proper DCC track voltage
**Motor doesn't run:**
- Verify TB67H450FNG connections
- Check motor power supply (VM)
- Verify PWM signal on GPIO7
- Check motor connections
**LEDs don't light:**
- Verify WS2812 data line connection
- Check LED power supply voltage
- Ensure correct NUM_LEDS setting
- Check for loose connections
**Can't enter config mode:**
- Verify button wiring (GPIO14 to GND)
- Check serial monitor for messages
- Try holding button longer (>3s)
**WiFi AP not visible:**
- Check ESP32-H2 WiFi support
- Verify sufficient power supply
- Check for WiFi interference
- Review serial output for errors
## Advanced Features
### Load Compensation
The decoder includes PID-based load compensation to maintain consistent speed under varying loads:
- Monitors motor current
- Adjusts PWM duty cycle
- Tunable via CVs 50-52
- Can be disabled via CV54
### Custom Function Mapping
Edit `src/main.cpp` to customize LED and accessory mappings:
```cpp
// Example: Map F5 to LED 2 with pulse effect
ledController.mapFunctionToLED(5, 2, LIGHT_PULSE);
// Example: Map F6 to accessory output 1
accessories.mapFunction(1, 6);
```
### RailCom Customization
Extend RailCom data transmission in `src/RailCom.cpp`:
- Add more status information in Channel 2
- Implement CV read-back
- Add custom data fields
## Future Enhancements
- [ ] Sound decoder support
- [ ] SUSI interface for external sound modules
- [ ] Bluetooth configuration
- [ ] Advanced lighting effects (mars light, ditch lights)
- [ ] Function remapping via CV
- [ ] Dual motor support
- [ ] ABC brake support
- [ ] Servo outputs
## Hardware Design Files
KiCad schematic and PCB files will be added to the `Hardware/` folder in future releases.
## License
This project is open-source and available under the MIT License.
## Contributing
Contributions are welcome! Please:
1. Fork the repository
2. Create a feature branch
3. Commit your changes
4. Submit a pull request
## Support
For issues, questions, or suggestions:
- Open an issue on GitHub
- Check documentation in `doc/` folder
- Review source code comments
## Credits
- NMRA DCC specifications
- ESP32-H2 Arduino core
- FastLED library
- AsyncWebServer library
## Version History
- **v1.0** (2026-01-15): Initial release
- DCC decoding
- Motor control with load compensation
- WS2812 LED support
- RailCom feedback
- Accessory outputs
- WiFi configuration
---
**Happy Model Railroading!** 🚂

101
ESP32/DCC-Loco/include/AccessoryOutputs.h Normal file
View File

@@ -0,0 +1,101 @@
/**
* @file AccessoryOutputs.h
* @brief Accessory Output Controller (N-channel MOSFETs)
*
* Controls 2 N-channel MOSFET outputs for accessories like smoke generators,
* sound modules, or other low-side switched loads.
*/
#ifndef ACCESSORY_OUTPUTS_H
#define ACCESSORY_OUTPUTS_H
#include <Arduino.h>
enum AccessoryMode {
ACC_OFF = 0, // Always off
ACC_ON = 1, // Always on
ACC_FUNCTION = 2, // Controlled by DCC function
ACC_PWM = 3, // PWM control
ACC_BLINK = 4, // Blinking mode
ACC_SPEED_DEPENDENT = 5 // Output follows speed
};
class AccessoryOutputs {
public:
AccessoryOutputs();
/**
* @brief Initialize accessory outputs
* @param output1Pin GPIO for accessory output 1 (N-FET gate)
* @param output2Pin GPIO for accessory output 2 (N-FET gate)
* @return true if successful
*/
bool begin(uint8_t output1Pin, uint8_t output2Pin);
/**
* @brief Set output mode
* @param outputNum Output number (1 or 2)
* @param mode Accessory mode
*/
void setMode(uint8_t outputNum, AccessoryMode mode);
/**
* @brief Set PWM duty cycle for output
* @param outputNum Output number (1 or 2)
* @param dutyCycle Duty cycle (0-255)
*/
void setPWM(uint8_t outputNum, uint8_t dutyCycle);
/**
* @brief Map DCC function to output
* @param outputNum Output number (1 or 2)
* @param functionNum DCC function number (0-28)
*/
void mapFunction(uint8_t outputNum, uint8_t functionNum);
/**
* @brief Update function state
* @param functionNum Function number (0-28)
* @param state Function state (true = on)
*/
void setFunctionState(uint8_t functionNum, bool state);
/**
* @brief Set speed for speed-dependent mode
* @param speed Speed value (0-126)
*/
void setSpeed(uint8_t speed);
/**
* @brief Update outputs (call regularly from loop)
*/
void update();
/**
* @brief Direct output control
* @param outputNum Output number (1 or 2)
* @param state Output state (true = on)
*/
void setOutput(uint8_t outputNum, bool state);
private:
uint8_t pins[2];
AccessoryMode modes[2];
uint8_t pwmValues[2];
uint8_t mappedFunctions[2];
bool functionStates[29]; // F0-F28
uint8_t currentSpeed;
// PWM channels
const uint8_t pwmChannels[2] = {2, 3};
const uint32_t pwmFrequency = 1000; // 1 kHz
const uint8_t pwmResolution = 8;
// Blink timing
unsigned long lastBlinkUpdate;
bool blinkState;
void updateOutput(uint8_t outputNum);
};
#endif // ACCESSORY_OUTPUTS_H

100
ESP32/DCC-Loco/include/CVManager.h Normal file
View File

@@ -0,0 +1,100 @@
/**
* @file CVManager.h
* @brief Configuration Variable (CV) Manager
*
* Manages NMRA-compliant Configuration Variables stored in non-volatile memory.
* Supports programming track operations and service mode programming.
*/
#ifndef CV_MANAGER_H
#define CV_MANAGER_H
#include <Arduino.h>
#include <Preferences.h>
// Standard DCC CVs
#define CV_PRIMARY_ADDRESS 1 // Short address (1-127)
#define CV_VSTART 2 // Start voltage
#define CV_ACCEL_RATE 3 // Acceleration rate
#define CV_DECEL_RATE 4 // Deceleration rate
#define CV_VHIGH 5 // Max voltage
#define CV_VMID 6 // Mid voltage
#define CV_VERSION_ID 7 // Manufacturer version
#define CV_MANUFACTURER_ID 8 // Manufacturer ID
#define CV_TOTAL_PWM_PERIOD 9 // PWM period
#define CV_EMF_FEEDBACK_CUTOUT 10 // EMF feedback cutout
#define CV_PACKET_TIMEOUT 11 // Packet timeout
#define CV_EXTENDED_ADDRESS_HIGH 17 // Long address high byte
#define CV_EXTENDED_ADDRESS_LOW 18 // Long address low byte
#define CV_CONSIST_ADDRESS 19 // Consist address
#define CV_CONFIG_DATA_1 29 // Configuration data
// Custom CVs for this decoder
#define CV_MOTOR_KP 50 // Motor PID Kp
#define CV_MOTOR_KI 51 // Motor PID Ki
#define CV_MOTOR_KD 52 // Motor PID Kd
#define CV_RAILCOM_ENABLE 53 // RailCom enable
#define CV_LOAD_COMP_ENABLE 54 // Load compensation enable
#define CV_LED_BRIGHTNESS 55 // LED brightness
#define CV_ACCESSORY_1_MODE 56 // Accessory output 1 mode
#define CV_ACCESSORY_2_MODE 57 // Accessory output 2 mode
#define MAX_CV_NUMBER 1024
class CVManager {
public:
CVManager();
/**
* @brief Initialize CV manager and load from NVS
* @return true if successful
*/
bool begin();
/**
* @brief Read CV value
* @param cvNumber CV number (1-1024)
* @param defaultValue Default value if CV not set
* @return CV value
*/
uint8_t readCV(uint16_t cvNumber, uint8_t defaultValue = 0);
/**
* @brief Write CV value
* @param cvNumber CV number (1-1024)
* @param value Value to write
* @return true if successful
*/
bool writeCV(uint16_t cvNumber, uint8_t value);
/**
* @brief Reset all CVs to factory defaults
*/
void resetToDefaults();
/**
* @brief Get locomotive address from CVs
* @return Locomotive address (1-10239)
*/
uint16_t getLocoAddress();
/**
* @brief Set locomotive address in CVs
* @param address Address to set (1-10239)
*/
void setLocoAddress(uint16_t address);
/**
* @brief Check if using extended (long) address
* @return true if using long address
*/
bool isLongAddress();
private:
Preferences preferences;
void setDefaultCVs();
String getCVKey(uint16_t cvNumber);
};
#endif // CV_MANAGER_H

82
ESP32/DCC-Loco/include/ConfigServer.h Normal file
View File

@@ -0,0 +1,82 @@
/**
* @file ConfigServer.h
* @brief WiFi/Bluetooth Configuration Server
*
* Provides WebSocket-based configuration interface over WiFi or Bluetooth.
* Allows reading/writing CVs, testing outputs, and monitoring decoder status.
*/
#ifndef CONFIG_SERVER_H
#define CONFIG_SERVER_H
#include <Arduino.h>
#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <ArduinoJson.h>
#include "CVManager.h"
class ConfigServer {
public:
ConfigServer(CVManager& cvManager);
/**
* @brief Initialize configuration server
* @param ssid WiFi SSID (nullptr for AP mode with default name)
* @param password WiFi password
* @param useAP true for AP mode, false for station mode
* @return true if successful
*/
bool begin(const char* ssid = nullptr, const char* password = nullptr, bool useAP = true);
/**
* @brief Stop configuration server
*/
void stop();
/**
* @brief Check if configuration mode is active
*/
bool isActive() const { return active; }
/**
* @brief Update server (call from loop)
*/
void update();
/**
* @brief Set decoder status callback
* Function signature: void callback(JsonObject& status)
*/
typedef void (*StatusCallback)(JsonObject& status);
void setStatusCallback(StatusCallback callback);
private:
CVManager& cvMgr;
AsyncWebServer* server;
AsyncWebSocket* ws;
bool active;
StatusCallback statusCallback;
unsigned long lastStatusUpdate;
void setupWebSocket();
void setupHTTPRoutes();
void handleWebSocketMessage(void* arg, uint8_t* data, size_t len);
void handleWebSocketEvent(AsyncWebSocket* server, AsyncWebSocketClient* client,
AwsEventType type, void* arg, uint8_t* data, size_t len);
void handleReadCV(AsyncWebSocketClient* client, JsonObject& json);
void handleWriteCV(AsyncWebSocketClient* client, JsonObject& json);
void handleGetStatus(AsyncWebSocketClient* client);
void handleTestOutput(AsyncWebSocketClient* client, JsonObject& json);
void handleReset(AsyncWebSocketClient* client);
void sendResponse(AsyncWebSocketClient* client, const char* type,
bool success, const char* message = nullptr);
void broadcastStatus();
String getDefaultAPName();
};
#endif // CONFIG_SERVER_H

100
ESP32/DCC-Loco/include/DCCDecoder.h Normal file
View File

@@ -0,0 +1,100 @@
/**
* @file DCCDecoder.h
* @brief DCC Signal Decoder for locomotive control
*
* Decodes DCC packets from the track signal, extracts speed and function commands,
* and manages locomotive addressing (short/long address support).
*/
#ifndef DCC_DECODER_H
#define DCC_DECODER_H
#include <Arduino.h>
// DCC Timing constants (in microseconds)
#define DCC_ONE_BIT_MIN 52
#define DCC_ONE_BIT_MAX 64
#define DCC_ZERO_BIT_MIN 95
#define DCC_ZERO_BIT_MAX 9900
// Maximum packet size
#define MAX_DCC_PACKET_SIZE 6
class DCCDecoder {
public:
DCCDecoder();
/**
* @brief Initialize the DCC decoder
* @param dccPin GPIO pin for DCC signal input
* @return true if initialization successful
*/
bool begin(uint8_t dccPin);
/**
* @brief Process DCC signal (call frequently from loop or ISR)
*/
void process();
/**
* @brief Get current speed value (0-126, 0=stop, 1=emergency stop)
* @return Current speed
*/
uint8_t getSpeed() const { return currentSpeed; }
/**
* @brief Get current direction
* @return true = forward, false = reverse
*/
bool getDirection() const { return direction; }
/**
* @brief Get function state (F0-F28)
* @param functionNum Function number (0-28)
* @return Function state (true = on)
*/
bool getFunction(uint8_t functionNum) const;
/**
* @brief Check if decoder has received valid packets recently
* @return true if signal is valid
*/
bool hasValidSignal() const;
/**
* @brief Set locomotive address
* @param address Locomotive address (1-10239)
*/
void setAddress(uint16_t address);
/**
* @brief Get current locomotive address
*/
uint16_t getAddress() const { return locoAddress; }
private:
static void IRAM_ATTR dccISR();
static DCCDecoder* instance;
void decodeDCCPacket();
void processSpeedPacket(uint8_t* data, uint8_t len);
void processFunctionPacket(uint8_t* data, uint8_t len);
uint8_t dccInputPin;
uint16_t locoAddress;
uint8_t currentSpeed;
bool direction;
uint32_t functions; // Bit field for F0-F28
// Packet assembly
uint8_t packetBuffer[MAX_DCC_PACKET_SIZE];
uint8_t packetIndex;
uint8_t bitCount;
bool assemblingPacket;
// Timing
unsigned long lastBitTime;
unsigned long lastValidPacket;
};
#endif // DCC_DECODER_H

108
ESP32/DCC-Loco/include/LEDController.h Normal file
View File

@@ -0,0 +1,108 @@
/**
* @file LEDController.h
* @brief WS2812 LED Controller for lighting effects
*
* Controls WS2812 addressable LEDs for headlights, taillights, and other effects.
* Supports direction-based lighting and function-controlled effects.
*/
#ifndef LED_CONTROLLER_H
#define LED_CONTROLLER_H
#include <Arduino.h>
#include <FastLED.h>
#define MAX_LEDS 16
#define DEFAULT_BRIGHTNESS 128
enum LightMode {
LIGHT_OFF = 0,
LIGHT_ON = 1,
LIGHT_BLINK = 2,
LIGHT_PULSE = 3,
LIGHT_DIRECTION_FRONT = 4, // On when moving forward
LIGHT_DIRECTION_REAR = 5 // On when moving backward
};
class LEDController {
public:
LEDController();
/**
* @brief Initialize LED controller
* @param ledPin GPIO pin for WS2812 data
* @param numLeds Number of LEDs in the strip
* @return true if successful
*/
bool begin(uint8_t ledPin, uint8_t numLeds);
/**
* @brief Update LED states (call regularly from loop)
*/
void update();
/**
* @brief Set LED mode for a specific LED
* @param ledIndex LED index (0-based)
* @param mode Light mode
*/
void setLEDMode(uint8_t ledIndex, LightMode mode);
/**
* @brief Set LED color
* @param ledIndex LED index
* @param r Red (0-255)
* @param g Green (0-255)
* @param b Blue (0-255)
*/
void setLEDColor(uint8_t ledIndex, uint8_t r, uint8_t g, uint8_t b);
/**
* @brief Set global brightness
* @param brightness Brightness (0-255)
*/
void setBrightness(uint8_t brightness);
/**
* @brief Set direction for directional lights
* @param forward true = forward, false = reverse
*/
void setDirection(bool forward);
/**
* @brief Map function to LED
* @param functionNum Function number (0-28)
* @param ledIndex LED index
* @param mode Light mode when function is active
*/
void mapFunctionToLED(uint8_t functionNum, uint8_t ledIndex, LightMode mode);
/**
* @brief Update function state
* @param functionNum Function number
* @param state Function state (true = on)
*/
void setFunctionState(uint8_t functionNum, bool state);
private:
CRGB leds[MAX_LEDS];
uint8_t numLEDs;
uint8_t dataPin;
bool direction;
struct LEDConfig {
LightMode mode;
CRGB color;
uint8_t mappedFunction; // 255 = no function mapping
};
LEDConfig ledConfig[MAX_LEDS];
bool functionStates[29]; // F0-F28
unsigned long lastUpdate;
uint16_t effectCounter;
void updateLED(uint8_t ledIndex);
};
#endif // LED_CONTROLLER_H

114
ESP32/DCC-Loco/include/MotorDriver.h Normal file
View File

@@ -0,0 +1,114 @@
/**
* @file MotorDriver.h
* @brief TB67H450FNG Motor Driver Controller
*
* Controls the TB67H450FNG H-bridge motor driver with PWM speed control,
* direction control, and optional load compensation/BEMF feedback.
*/
#ifndef MOTOR_DRIVER_H
#define MOTOR_DRIVER_H
#include <Arduino.h>
// TB67H450FNG control pins
// IN1 and IN2 control direction and brake
// PWM controls speed
class MotorDriver {
public:
MotorDriver();
/**
* @brief Initialize motor driver
* @param in1Pin GPIO for IN1 (Motor phase A)
* @param in2Pin GPIO for IN2 (Motor phase B)
* @param pwmPin GPIO for PWM speed control
* @param currentSensePin ADC pin for current sensing (optional, 255 = disabled)
* @return true if successful
*/
bool begin(uint8_t in1Pin, uint8_t in2Pin, uint8_t pwmPin, uint8_t currentSensePin = 255);
/**
* @brief Set motor speed and direction
* @param speed Speed value (0-126, DCC format: 0=stop, 1=emergency stop, 2-127=speed)
* @param forward Direction (true=forward, false=reverse)
*/
void setSpeed(uint8_t speed, bool forward);
/**
* @brief Emergency stop
*/
void emergencyStop();
/**
* @brief Update motor control (call regularly for load compensation)
*/
void update();
/**
* @brief Enable/disable load compensation
* @param enable true to enable
*/
void setLoadCompensation(bool enable);
/**
* @brief Get motor current (if current sensing enabled)
* @return Current in mA
*/
uint16_t getMotorCurrent();
/**
* @brief Set PID parameters for load compensation
* @param kp Proportional gain
* @param ki Integral gain
* @param kd Derivative gain
*/
void setPIDParameters(float kp, float ki, float kd);
/**
* @brief Set acceleration rate
* @param rate Rate value (0-255, higher = faster)
*/
void setAccelRate(uint8_t rate);
/**
* @brief Set deceleration rate
* @param rate Rate value (0-255, higher = faster)
*/
void setDecelRate(uint8_t rate);
private:
uint8_t pinIN1;
uint8_t pinIN2;
uint8_t pinPWM;
uint8_t pinCurrentSense;
uint8_t targetSpeed;
uint8_t currentSpeed;
bool targetDirection;
bool loadCompensationEnabled;
// Acceleration/deceleration
uint8_t accelRate;
uint8_t decelRate;
unsigned long lastSpeedUpdate;
// Load compensation (PID)
float Kp, Ki, Kd;
float integral;
float lastError;
uint16_t targetCurrent;
// PWM settings
const uint8_t pwmChannel = 0;
const uint32_t pwmFrequency = 20000; // 20 kHz
const uint8_t pwmResolution = 8; // 8-bit (0-255)
void applyMotorControl();
void updateAcceleration();
void updateLoadCompensation();
uint16_t readCurrent();
};
#endif // MOTOR_DRIVER_H

93
ESP32/DCC-Loco/include/RailCom.h Normal file
View File

@@ -0,0 +1,93 @@
/**
* @file RailCom.h
* @brief RailCom Feedback Controller
*
* Implements RailCom channel 1 and 2 for bidirectional communication
* with the command station. Sends locomotive address and status information.
*/
#ifndef RAILCOM_H
#define RAILCOM_H
#include <Arduino.h>
// RailCom timing (in microseconds)
#define RAILCOM_CHANNEL1_START 26
#define RAILCOM_CHANNEL1_END 177
#define RAILCOM_CHANNEL2_START 193
#define RAILCOM_CHANNEL2_END 454
// RailCom 4bit to 8bit encoding table
#define RAILCOM_4BIT_TO_8BIT_SIZE 16
class RailCom {
public:
RailCom();
/**
* @brief Initialize RailCom
* @param txPin GPIO for RailCom transmit (UART TX)
* @param cutoutDetectPin GPIO to detect DCC cutout (optional, 255 = disabled)
* @return true if successful
*/
bool begin(uint8_t txPin, uint8_t cutoutDetectPin = 255);
/**
* @brief Enable/disable RailCom
* @param enable true to enable
*/
void setEnabled(bool enable);
/**
* @brief Check if RailCom is enabled
*/
bool isEnabled() const { return enabled; }
/**
* @brief Send RailCom data during cutout window
* This should be called when DCC cutout is detected
*/
void sendRailComData();
/**
* @brief Set locomotive address for RailCom reporting
* @param address Locomotive address
*/
void setAddress(uint16_t address);
/**
* @brief Set decoder state information
* @param speed Current speed
* @param direction Current direction
*/
void setDecoderState(uint8_t speed, bool direction);
/**
* @brief Update RailCom (call regularly from loop)
*/
void update();
private:
uint8_t txPin;
uint8_t cutoutPin;
bool enabled;
uint16_t locoAddress;
uint8_t currentSpeed;
bool currentDirection;
HardwareSerial* railcomSerial;
// RailCom encoding
uint8_t encode4to8(uint8_t data);
void sendChannel1();
void sendChannel2();
// Timing
unsigned long lastCutoutTime;
bool inCutout;
static const uint8_t railcom4to8[16];
};
#endif // RAILCOM_H

43
ESP32/DCC-Loco/platformio.ini Normal file
View File

@@ -0,0 +1,43 @@
; PlatformIO Project Configuration File for DCC Locomotive Decoder
; ESP32-H2 based DCC decoder with RailCom, motor control, and accessories
[env:esp32-h2-devkitm-1]
platform = espressif32
board = esp32-h2-devkitm-1
framework = arduino
; Build flags
build_flags =
-DCORE_DEBUG_LEVEL=3
-DBOARD_HAS_PSRAM
-Os
; Monitor settings
monitor_speed = 115200
monitor_filters = esp32_exception_decoder
; Upload settings
upload_speed = 921600
; Library dependencies
lib_deps =
; FastLED for WS2812 LED control
fastled/FastLED@^3.6.0
; Async Web Server for WiFi configuration
esphome/ESPAsyncWebServer-esphome@^3.1.0
; Async TCP
esphome/AsyncTCP-esphome@^2.1.3
; ArduinoJson for config management
bblanchon/ArduinoJson@^7.0.0
; Preferences/EEPROM for CV storage
; (built-in ESP32 library)
; Filesystem
board_build.filesystem = littlefs
; Partition scheme for OTA updates
board_build.partitions = default.csv

139
ESP32/DCC-Loco/src/AccessoryOutputs.cpp Normal file
View File

@@ -0,0 +1,139 @@
/**
* @file AccessoryOutputs.cpp
* @brief Accessory Output Controller Implementation
*/
#include "AccessoryOutputs.h"
AccessoryOutputs::AccessoryOutputs()
: currentSpeed(0), lastBlinkUpdate(0), blinkState(false) {
pins[0] = 0;
pins[1] = 0;
modes[0] = ACC_OFF;
modes[1] = ACC_OFF;
pwmValues[0] = 0;
pwmValues[1] = 0;
mappedFunctions[0] = 255;
mappedFunctions[1] = 255;
memset(functionStates, 0, sizeof(functionStates));
}
bool AccessoryOutputs::begin(uint8_t output1Pin, uint8_t output2Pin) {
pins[0] = output1Pin;
pins[1] = output2Pin;
// Configure pins
pinMode(pins[0], OUTPUT);
pinMode(pins[1], OUTPUT);
// Setup PWM channels
ledcSetup(pwmChannels[0], pwmFrequency, pwmResolution);
ledcSetup(pwmChannels[1], pwmFrequency, pwmResolution);
ledcAttachPin(pins[0], pwmChannels[0]);
ledcAttachPin(pins[1], pwmChannels[1]);
// Initialize outputs to off
ledcWrite(pwmChannels[0], 0);
ledcWrite(pwmChannels[1], 0);
return true;
}
void AccessoryOutputs::setMode(uint8_t outputNum, AccessoryMode mode) {
if (outputNum >= 1 && outputNum <= 2) {
modes[outputNum - 1] = mode;
}
}
void AccessoryOutputs::setPWM(uint8_t outputNum, uint8_t dutyCycle) {
if (outputNum >= 1 && outputNum <= 2) {
pwmValues[outputNum - 1] = dutyCycle;
}
}
void AccessoryOutputs::mapFunction(uint8_t outputNum, uint8_t functionNum) {
if (outputNum >= 1 && outputNum <= 2 && functionNum <= 28) {
mappedFunctions[outputNum - 1] = functionNum;
}
}
void AccessoryOutputs::setFunctionState(uint8_t functionNum, bool state) {
if (functionNum <= 28) {
functionStates[functionNum] = state;
}
}
void AccessoryOutputs::setSpeed(uint8_t speed) {
currentSpeed = speed;
}
void AccessoryOutputs::update() {
unsigned long currentTime = millis();
// Update blink state (1 Hz)
if (currentTime - lastBlinkUpdate >= 500) {
lastBlinkUpdate = currentTime;
blinkState = !blinkState;
}
// Update each output
updateOutput(0);
updateOutput(1);
}
void AccessoryOutputs::updateOutput(uint8_t outputNum) {
if (outputNum >= 2) return;
bool shouldBeOn = false;
uint8_t pwmValue = 255;
switch (modes[outputNum]) {
case ACC_OFF:
shouldBeOn = false;
break;
case ACC_ON:
shouldBeOn = true;
break;
case ACC_FUNCTION:
if (mappedFunctions[outputNum] != 255) {
shouldBeOn = functionStates[mappedFunctions[outputNum]];
}
break;
case ACC_PWM:
shouldBeOn = true;
pwmValue = pwmValues[outputNum];
break;
case ACC_BLINK:
shouldBeOn = blinkState;
break;
case ACC_SPEED_DEPENDENT:
if (currentSpeed >= 2) {
shouldBeOn = true;
// Map speed (2-127) to PWM (0-255)
pwmValue = map(currentSpeed, 2, 127, 0, 255);
} else {
shouldBeOn = false;
}
break;
}
// Apply output
if (shouldBeOn) {
ledcWrite(pwmChannels[outputNum], pwmValue);
} else {
ledcWrite(pwmChannels[outputNum], 0);
}
}
void AccessoryOutputs::setOutput(uint8_t outputNum, bool state) {
if (outputNum >= 1 && outputNum <= 2) {
uint8_t idx = outputNum - 1;
ledcWrite(pwmChannels[idx], state ? 255 : 0);
}
}

116
ESP32/DCC-Loco/src/CVManager.cpp Normal file
View File

@@ -0,0 +1,116 @@
/**
* @file CVManager.cpp
* @brief Configuration Variable Manager Implementation
*/
#include "CVManager.h"
CVManager::CVManager() {}
bool CVManager::begin() {
if (!preferences.begin("dcc-decoder", false)) {
return false;
}
// Check if this is first boot
if (preferences.getUChar("initialized", 0) == 0) {
setDefaultCVs();
preferences.putUChar("initialized", 1);
}
return true;
}
uint8_t CVManager::readCV(uint16_t cvNumber, uint8_t defaultValue) {
if (cvNumber < 1 || cvNumber > MAX_CV_NUMBER) {
return defaultValue;
}
return preferences.getUChar(getCVKey(cvNumber).c_str(), defaultValue);
}
bool CVManager::writeCV(uint16_t cvNumber, uint8_t value) {
if (cvNumber < 1 || cvNumber > MAX_CV_NUMBER) {
return false;
}
return preferences.putUChar(getCVKey(cvNumber).c_str(), value);
}
void CVManager::resetToDefaults() {
preferences.clear();
setDefaultCVs();
preferences.putUChar("initialized", 1);
}
uint16_t CVManager::getLocoAddress() {
// Check CV29 bit 5 to determine address mode
uint8_t cv29 = readCV(CV_CONFIG_DATA_1, 0x06);
if (cv29 & 0x20) {
// Long address mode
uint8_t highByte = readCV(CV_EXTENDED_ADDRESS_HIGH, 0xC0);
uint8_t lowByte = readCV(CV_EXTENDED_ADDRESS_LOW, 0x03);
return ((highByte & 0x3F) << 8) | lowByte;
} else {
// Short address mode
return readCV(CV_PRIMARY_ADDRESS, 3);
}
}
void CVManager::setLocoAddress(uint16_t address) {
if (address >= 1 && address <= 127) {
// Short address
writeCV(CV_PRIMARY_ADDRESS, address);
// Clear long address bit in CV29
uint8_t cv29 = readCV(CV_CONFIG_DATA_1, 0x06);
cv29 &= ~0x20;
writeCV(CV_CONFIG_DATA_1, cv29);
} else if (address >= 128 && address <= 10239) {
// Long address
uint8_t highByte = 0xC0 | ((address >> 8) & 0x3F);
uint8_t lowByte = address & 0xFF;
writeCV(CV_EXTENDED_ADDRESS_HIGH, highByte);
writeCV(CV_EXTENDED_ADDRESS_LOW, lowByte);
// Set long address bit in CV29
uint8_t cv29 = readCV(CV_CONFIG_DATA_1, 0x06);
cv29 |= 0x20;
writeCV(CV_CONFIG_DATA_1, cv29);
}
}
bool CVManager::isLongAddress() {
uint8_t cv29 = readCV(CV_CONFIG_DATA_1, 0x06);
return (cv29 & 0x20) != 0;
}
void CVManager::setDefaultCVs() {
// Standard CVs
writeCV(CV_PRIMARY_ADDRESS, 3); // Default address 3
writeCV(CV_VSTART, 1); // Start voltage
writeCV(CV_ACCEL_RATE, 10); // Acceleration rate
writeCV(CV_DECEL_RATE, 10); // Deceleration rate
writeCV(CV_VHIGH, 255); // Max voltage
writeCV(CV_VMID, 128); // Mid voltage
writeCV(CV_VERSION_ID, 1); // Version 1
writeCV(CV_MANUFACTURER_ID, 13); // DIY decoder
writeCV(CV_TOTAL_PWM_PERIOD, 20); // 20ms PWM period
writeCV(CV_CONFIG_DATA_1, 0x06); // 128 speed steps, short address
// Custom CVs
writeCV(CV_MOTOR_KP, 50); // PID Kp = 5.0
writeCV(CV_MOTOR_KI, 5); // PID Ki = 0.5
writeCV(CV_MOTOR_KD, 10); // PID Kd = 1.0
writeCV(CV_RAILCOM_ENABLE, 1); // RailCom enabled
writeCV(CV_LOAD_COMP_ENABLE, 1); // Load compensation enabled
writeCV(CV_LED_BRIGHTNESS, 128); // 50% brightness
writeCV(CV_ACCESSORY_1_MODE, ACC_FUNCTION); // Function controlled
writeCV(CV_ACCESSORY_2_MODE, ACC_FUNCTION); // Function controlled
}
String CVManager::getCVKey(uint16_t cvNumber) {
return "cv" + String(cvNumber);
}

309
ESP32/DCC-Loco/src/ConfigServer.cpp Normal file
View File

@@ -0,0 +1,309 @@
/**
* @file ConfigServer.cpp
* @brief WiFi/Bluetooth Configuration Server Implementation
*/
#include "ConfigServer.h"
ConfigServer::ConfigServer(CVManager& cvManager)
: cvMgr(cvManager), server(nullptr), ws(nullptr),
active(false), statusCallback(nullptr), lastStatusUpdate(0) {}
bool ConfigServer::begin(const char* ssid, const char* password, bool useAP) {
// Initialize WiFi
if (useAP) {
// Access Point mode
String apName = ssid ? String(ssid) : getDefaultAPName();
String apPass = password ? String(password) : "dcc12345";
WiFi.softAP(apName.c_str(), apPass.c_str());
Serial.println("WiFi AP started");
Serial.print("AP Name: ");
Serial.println(apName);
Serial.print("IP Address: ");
Serial.println(WiFi.softAPIP());
} else {
// Station mode
if (!ssid) return false;
WiFi.begin(ssid, password);
int attempts = 0;
while (WiFi.status() != WL_CONNECTED && attempts < 20) {
delay(500);
Serial.print(".");
attempts++;
}
if (WiFi.status() != WL_CONNECTED) {
Serial.println("\nWiFi connection failed");
return false;
}
Serial.println("\nWiFi connected");
Serial.print("IP Address: ");
Serial.println(WiFi.localIP());
}
// Create web server
server = new AsyncWebServer(80);
ws = new AsyncWebSocket("/ws");
setupWebSocket();
setupHTTPRoutes();
server->begin();
active = true;
return true;
}
void ConfigServer::stop() {
if (server) {
server->end();
delete server;
server = nullptr;
}
if (ws) {
delete ws;
ws = nullptr;
}
WiFi.disconnect();
active = false;
}
void ConfigServer::update() {
if (!active) return;
// Send periodic status updates
unsigned long currentTime = millis();
if (currentTime - lastStatusUpdate >= 1000) { // Every second
lastStatusUpdate = currentTime;
broadcastStatus();
}
}
void ConfigServer::setupWebSocket() {
ws->onEvent([this](AsyncWebSocket* server, AsyncWebSocketClient* client,
AwsEventType type, void* arg, uint8_t* data, size_t len) {
handleWebSocketEvent(server, client, type, arg, data, len);
});
server->addHandler(ws);
}
void ConfigServer::setupHTTPRoutes() {
// Serve basic HTML page
server->on("/", HTTP_GET, [](AsyncWebServerRequest* request) {
String html = R"html(
<!DOCTYPE html>
<html>
<head>
<title>DCC Loco Decoder Config</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
body { font-family: Arial; margin: 20px; }
.container { max-width: 600px; margin: 0 auto; }
button { padding: 10px 20px; margin: 5px; }
input { padding: 5px; margin: 5px; }
.status { background: #f0f0f0; padding: 10px; margin: 10px 0; }
</style>
</head>
<body>
<div class="container">
<h1>DCC Locomotive Decoder</h1>
<div class="status" id="status">Connecting...</div>
<h2>Configuration Variables</h2>
<div>
<label>CV Number: <input type="number" id="cvNum" min="1" max="1024" value="1"></label>
<button onclick="readCV()">Read CV</button>
</div>
<div>
<label>CV Value: <input type="number" id="cvVal" min="0" max="255" value="0"></label>
<button onclick="writeCV()">Write CV</button>
</div>
<div id="cvResult"></div>
<h2>Actions</h2>
<button onclick="resetDecoder()">Reset to Defaults</button>
</div>
<script>
const ws = new WebSocket('ws://' + location.host + '/ws');
ws.onmessage = (event) => {
const msg = JSON.parse(event.data);
console.log('Received:', msg);
if (msg.type === 'status') {
document.getElementById('status').innerHTML =
'Address: ' + msg.address + '<br>' +
'Speed: ' + msg.speed + '<br>' +
'Direction: ' + (msg.direction ? 'Forward' : 'Reverse');
} else if (msg.type === 'cv_read') {
document.getElementById('cvResult').innerHTML =
'CV' + msg.cv + ' = ' + msg.value;
} else if (msg.type === 'cv_write') {
document.getElementById('cvResult').innerHTML =
msg.success ? 'CV written successfully' : 'Write failed';
}
};
function readCV() {
const cv = parseInt(document.getElementById('cvNum').value);
ws.send(JSON.stringify({command: 'read_cv', cv: cv}));
}
function writeCV() {
const cv = parseInt(document.getElementById('cvNum').value);
const value = parseInt(document.getElementById('cvVal').value);
ws.send(JSON.stringify({command: 'write_cv', cv: cv, value: value}));
}
function resetDecoder() {
if (confirm('Reset all CVs to defaults?')) {
ws.send(JSON.stringify({command: 'reset'}));
}
}
</script>
</body>
</html>
)html";
request->send(200, "text/html", html);
});
}
void ConfigServer::handleWebSocketEvent(AsyncWebSocket* server, AsyncWebSocketClient* client,
AwsEventType type, void* arg, uint8_t* data, size_t len) {
if (type == WS_EVT_CONNECT) {
Serial.printf("WebSocket client #%u connected\n", client->id());
handleGetStatus(client);
} else if (type == WS_EVT_DISCONNECT) {
Serial.printf("WebSocket client #%u disconnected\n", client->id());
} else if (type == WS_EVT_DATA) {
AwsFrameInfo* info = (AwsFrameInfo*)arg;
if (info->final && info->index == 0 && info->len == len && info->opcode == WS_TEXT) {
data[len] = 0;
handleWebSocketMessage(client, data, len);
}
}
}
void ConfigServer::handleWebSocketMessage(void* clientPtr, uint8_t* data, size_t len) {
AsyncWebSocketClient* client = (AsyncWebSocketClient*)clientPtr;
StaticJsonDocument<256> doc;
DeserializationError error = deserializeJson(doc, data, len);
if (error) {
Serial.println("JSON parse error");
return;
}
const char* command = doc["command"];
if (strcmp(command, "read_cv") == 0) {
handleReadCV(client, doc.as<JsonObject>());
} else if (strcmp(command, "write_cv") == 0) {
handleWriteCV(client, doc.as<JsonObject>());
} else if (strcmp(command, "get_status") == 0) {
handleGetStatus(client);
} else if (strcmp(command, "reset") == 0) {
handleReset(client);
}
}
void ConfigServer::handleReadCV(AsyncWebSocketClient* client, JsonObject& json) {
uint16_t cvNum = json["cv"];
uint8_t value = cvMgr.readCV(cvNum, 0);
StaticJsonDocument<128> response;
response["type"] = "cv_read";
response["cv"] = cvNum;
response["value"] = value;
String output;
serializeJson(response, output);
client->text(output);
}
void ConfigServer::handleWriteCV(AsyncWebSocketClient* client, JsonObject& json) {
uint16_t cvNum = json["cv"];
uint8_t value = json["value"];
bool success = cvMgr.writeCV(cvNum, value);
StaticJsonDocument<128> response;
response["type"] = "cv_write";
response["success"] = success;
String output;
serializeJson(response, output);
client->text(output);
}
void ConfigServer::handleGetStatus(AsyncWebSocketClient* client) {
StaticJsonDocument<256> response;
JsonObject status = response.to<JsonObject>();
status["type"] = "status";
if (statusCallback) {
statusCallback(status);
} else {
status["address"] = cvMgr.getLocoAddress();
status["speed"] = 0;
status["direction"] = true;
}
String output;
serializeJson(response, output);
client->text(output);
}
void ConfigServer::handleReset(AsyncWebSocketClient* client) {
cvMgr.resetToDefaults();
sendResponse(client, "reset", true, "Decoder reset to defaults");
}
void ConfigServer::sendResponse(AsyncWebSocketClient* client, const char* type,
bool success, const char* message) {
StaticJsonDocument<128> response;
response["type"] = type;
response["success"] = success;
if (message) {
response["message"] = message;
}
String output;
serializeJson(response, output);
client->text(output);
}
void ConfigServer::broadcastStatus() {
if (!ws || ws->count() == 0) return;
StaticJsonDocument<256> response;
JsonObject status = response.to<JsonObject>();
status["type"] = "status";
if (statusCallback) {
statusCallback(status);
} else {
status["address"] = cvMgr.getLocoAddress();
}
String output;
serializeJson(response, output);
ws->textAll(output);
}
void ConfigServer::setStatusCallback(StatusCallback callback) {
statusCallback = callback;
}
String ConfigServer::getDefaultAPName() {
uint64_t chipid = ESP.getEfuseMac();
return "DCC-Loco-" + String((uint32_t)(chipid >> 32), HEX);
}

232
ESP32/DCC-Loco/src/DCCDecoder.cpp Normal file
View File

@@ -0,0 +1,232 @@
/**
* @file DCCDecoder.cpp
* @brief DCC Signal Decoder Implementation
*/
#include "DCCDecoder.h"
DCCDecoder* DCCDecoder::instance = nullptr;
DCCDecoder::DCCDecoder()
: dccInputPin(0), locoAddress(3), currentSpeed(0), direction(true),
functions(0), packetIndex(0), bitCount(0), assemblingPacket(false),
lastBitTime(0), lastValidPacket(0) {
instance = this;
}
bool DCCDecoder::begin(uint8_t dccPin) {
dccInputPin = dccPin;
pinMode(dccInputPin, INPUT);
// Attach interrupt for DCC signal
attachInterrupt(digitalPinToInterrupt(dccInputPin), dccISR, CHANGE);
return true;
}
void IRAM_ATTR DCCDecoder::dccISR() {
if (instance) {
instance->process();
}
}
void DCCDecoder::process() {
unsigned long currentTime = micros();
unsigned long pulseDuration = currentTime - lastBitTime;
lastBitTime = currentTime;
// Check for DCC ONE bit (52-64 µs)
if (pulseDuration >= DCC_ONE_BIT_MIN && pulseDuration <= DCC_ONE_BIT_MAX) {
if (assemblingPacket) {
// Shift in a '1' bit
packetBuffer[packetIndex] = (packetBuffer[packetIndex] << 1) | 1;
bitCount++;
if (bitCount >= 8) {
packetIndex++;
bitCount = 0;
if (packetIndex >= MAX_DCC_PACKET_SIZE) {
assemblingPacket = false;
}
}
} else {
// Preamble bit
if (pulseDuration >= DCC_ONE_BIT_MIN) {
// Start of new packet after preamble
packetIndex = 0;
bitCount = 0;
assemblingPacket = true;
memset(packetBuffer, 0, sizeof(packetBuffer));
}
}
}
// Check for DCC ZERO bit (95-9900 µs)
else if (pulseDuration >= DCC_ZERO_BIT_MIN && pulseDuration <= DCC_ZERO_BIT_MAX) {
if (assemblingPacket) {
// Shift in a '0' bit
packetBuffer[packetIndex] = (packetBuffer[packetIndex] << 1);
bitCount++;
if (bitCount >= 8) {
packetIndex++;
bitCount = 0;
// Check for end of packet (more than 3 bytes minimum)
if (packetIndex >= 3) {
decodeDCCPacket();
assemblingPacket = false;
}
if (packetIndex >= MAX_DCC_PACKET_SIZE) {
assemblingPacket = false;
}
}
}
}
}
void DCCDecoder::decodeDCCPacket() {
// Validate checksum
uint8_t checksum = 0;
for (uint8_t i = 0; i < packetIndex - 1; i++) {
checksum ^= packetBuffer[i];
}
if (checksum != packetBuffer[packetIndex - 1]) {
return; // Invalid packet
}
lastValidPacket = millis();
// Check address
uint16_t packetAddress;
uint8_t dataStart;
if (packetBuffer[0] == 0xFF) {
// Idle packet
return;
} else if (packetBuffer[0] >= 0xC0) {
// Long address (14-bit)
packetAddress = ((packetBuffer[0] & 0x3F) << 8) | packetBuffer[1];
dataStart = 2;
} else if (packetBuffer[0] >= 1 && packetBuffer[0] <= 127) {
// Short address (7-bit)
packetAddress = packetBuffer[0];
dataStart = 1;
} else {
return; // Invalid address
}
// Check if packet is for this decoder
if (packetAddress != locoAddress && packetAddress != 0) {
return; // Not for us (0 = broadcast)
}
// Process instruction byte
uint8_t instruction = packetBuffer[dataStart];
if ((instruction & 0xC0) == 0x40) {
// Speed and direction (01DCSSSS or 001DSSSS for 14/28 step)
processSpeedPacket(&packetBuffer[dataStart], packetIndex - dataStart - 1);
} else if ((instruction & 0xE0) == 0x80) {
// Function group (100XXXXX)
processFunctionPacket(&packetBuffer[dataStart], packetIndex - dataStart - 1);
} else if ((instruction & 0xF0) == 0xA0) {
// Function group (1011XXXX)
processFunctionPacket(&packetBuffer[dataStart], packetIndex - dataStart - 1);
} else if ((instruction & 0xE0) == 0xC0) {
// Feature expansion
processFunctionPacket(&packetBuffer[dataStart], packetIndex - dataStart - 1);
}
}
void DCCDecoder::processSpeedPacket(uint8_t* data, uint8_t len) {
if (len < 1) return;
uint8_t instruction = data[0];
// Check for 128-step speed (0x3F = 00111111)
if ((instruction & 0xC0) == 0x40) {
// 01DCSSSS (14/28 step mode)
direction = (instruction & 0x20) ? true : false;
uint8_t speedBits = instruction & 0x0F;
if (len >= 2) {
// 128 step mode: second byte contains speed
currentSpeed = data[1] & 0x7F;
} else {
// 14/28 step mode
currentSpeed = speedBits * 9; // Approximate scaling
}
} else if ((instruction & 0xE0) == 0x20) {
// 001DSSSS (reverse operation control)
direction = (instruction & 0x10) ? true : false;
}
}
void DCCDecoder::processFunctionPacket(uint8_t* data, uint8_t len) {
if (len < 1) return;
uint8_t instruction = data[0];
if ((instruction & 0xF0) == 0x80) {
// 100DDDDD - Function group 1 (F0-F4)
if (instruction & 0x10) functions |= (1 << 0); else functions &= ~(1 << 0); // F0
if (instruction & 0x01) functions |= (1 << 1); else functions &= ~(1 << 1); // F1
if (instruction & 0x02) functions |= (1 << 2); else functions &= ~(1 << 2); // F2
if (instruction & 0x04) functions |= (1 << 3); else functions &= ~(1 << 3); // F3
if (instruction & 0x08) functions |= (1 << 4); else functions &= ~(1 << 4); // F4
} else if ((instruction & 0xF0) == 0xB0) {
// 1011DDDD - Function group 2 (F5-F8)
if (instruction & 0x01) functions |= (1 << 5); else functions &= ~(1 << 5); // F5
if (instruction & 0x02) functions |= (1 << 6); else functions &= ~(1 << 6); // F6
if (instruction & 0x04) functions |= (1 << 7); else functions &= ~(1 << 7); // F7
if (instruction & 0x08) functions |= (1 << 8); else functions &= ~(1 << 8); // F8
} else if ((instruction & 0xF0) == 0xA0) {
// 1010DDDD - Function group 3 (F9-F12)
if (instruction & 0x01) functions |= (1 << 9); else functions &= ~(1 << 9); // F9
if (instruction & 0x02) functions |= (1 << 10); else functions &= ~(1 << 10); // F10
if (instruction & 0x04) functions |= (1 << 11); else functions &= ~(1 << 11); // F11
if (instruction & 0x08) functions |= (1 << 12); else functions &= ~(1 << 12); // F12
} else if (instruction == 0xDE) {
// F13-F20
if (len >= 2) {
uint8_t funcByte = data[1];
for (uint8_t i = 0; i < 8; i++) {
if (funcByte & (1 << i)) {
functions |= (1 << (13 + i));
} else {
functions &= ~(1 << (13 + i));
}
}
}
} else if (instruction == 0xDF) {
// F21-F28
if (len >= 2) {
uint8_t funcByte = data[1];
for (uint8_t i = 0; i < 8; i++) {
if (funcByte & (1 << i)) {
functions |= (1 << (21 + i));
} else {
functions &= ~(1 << (21 + i));
}
}
}
}
}
bool DCCDecoder::getFunction(uint8_t functionNum) const {
if (functionNum > 28) return false;
return (functions & (1 << functionNum)) != 0;
}
bool DCCDecoder::hasValidSignal() const {
return (millis() - lastValidPacket) < 1000; // Valid if packet within last second
}
void DCCDecoder::setAddress(uint16_t address) {
if (address >= 1 && address <= 10239) {
locoAddress = address;
}
}

132
ESP32/DCC-Loco/src/LEDController.cpp Normal file
View File

@@ -0,0 +1,132 @@
/**
* @file LEDController.cpp
* @brief WS2812 LED Controller Implementation
*/
#include "LEDController.h"
LEDController::LEDController()
: numLEDs(0), dataPin(0), direction(true), lastUpdate(0), effectCounter(0) {
memset(functionStates, 0, sizeof(functionStates));
for (uint8_t i = 0; i < MAX_LEDS; i++) {
ledConfig[i].mode = LIGHT_OFF;
ledConfig[i].color = CRGB::White;
ledConfig[i].mappedFunction = 255;
}
}
bool LEDController::begin(uint8_t ledPin, uint8_t numLeds) {
if (numLeds > MAX_LEDS) {
numLeds = MAX_LEDS;
}
dataPin = ledPin;
numLEDs = numLeds;
// Initialize FastLED
FastLED.addLeds<WS2812, dataPin, GRB>(leds, numLEDs);
FastLED.setBrightness(DEFAULT_BRIGHTNESS);
FastLED.clear();
FastLED.show();
return true;
}
void LEDController::update() {
unsigned long currentTime = millis();
if (currentTime - lastUpdate >= 20) { // Update at ~50 Hz
lastUpdate = currentTime;
effectCounter++;
for (uint8_t i = 0; i < numLEDs; i++) {
updateLED(i);
}
FastLED.show();
}
}
void LEDController::updateLED(uint8_t ledIndex) {
if (ledIndex >= numLEDs) return;
LEDConfig& config = ledConfig[ledIndex];
bool shouldBeOn = false;
// Determine if LED should be on based on mode
switch (config.mode) {
case LIGHT_OFF:
shouldBeOn = false;
break;
case LIGHT_ON:
shouldBeOn = true;
break;
case LIGHT_BLINK:
shouldBeOn = (effectCounter % 50) < 25; // ~1 Hz blink
break;
case LIGHT_PULSE:
{
uint8_t brightness = (sin8(effectCounter * 5) >> 1) + 128;
leds[ledIndex] = config.color;
leds[ledIndex].fadeToBlackBy(255 - brightness);
return;
}
case LIGHT_DIRECTION_FRONT:
shouldBeOn = direction;
break;
case LIGHT_DIRECTION_REAR:
shouldBeOn = !direction;
break;
}
// Check function mapping
if (config.mappedFunction != 255) {
shouldBeOn = shouldBeOn && functionStates[config.mappedFunction];
}
// Set LED color
if (shouldBeOn) {
leds[ledIndex] = config.color;
} else {
leds[ledIndex] = CRGB::Black;
}
}
void LEDController::setLEDMode(uint8_t ledIndex, LightMode mode) {
if (ledIndex < MAX_LEDS) {
ledConfig[ledIndex].mode = mode;
}
}
void LEDController::setLEDColor(uint8_t ledIndex, uint8_t r, uint8_t g, uint8_t b) {
if (ledIndex < MAX_LEDS) {
ledConfig[ledIndex].color = CRGB(r, g, b);
}
}
void LEDController::setBrightness(uint8_t brightness) {
FastLED.setBrightness(brightness);
}
void LEDController::setDirection(bool forward) {
direction = forward;
}
void LEDController::mapFunctionToLED(uint8_t functionNum, uint8_t ledIndex, LightMode mode) {
if (ledIndex < MAX_LEDS && functionNum <= 28) {
ledConfig[ledIndex].mappedFunction = functionNum;
ledConfig[ledIndex].mode = mode;
}
}
void LEDController::setFunctionState(uint8_t functionNum, bool state) {
if (functionNum <= 28) {
functionStates[functionNum] = state;
}
}

213
ESP32/DCC-Loco/src/MotorDriver.cpp Normal file
View File

@@ -0,0 +1,213 @@
/**
* @file MotorDriver.cpp
* @brief TB67H450FNG Motor Driver Implementation
*/
#include "MotorDriver.h"
MotorDriver::MotorDriver()
: pinIN1(0), pinIN2(0), pinPWM(0), pinCurrentSense(255),
targetSpeed(0), currentSpeed(0), targetDirection(true),
loadCompensationEnabled(false), accelRate(10), decelRate(10),
lastSpeedUpdate(0), Kp(1.0), Ki(0.1), Kd(0.5),
integral(0), lastError(0), targetCurrent(0) {}
bool MotorDriver::begin(uint8_t in1Pin, uint8_t in2Pin, uint8_t pwmPin, uint8_t currentSensePin) {
pinIN1 = in1Pin;
pinIN2 = in2Pin;
pinPWM = pwmPin;
pinCurrentSense = currentSensePin;
// Configure pins
pinMode(pinIN1, OUTPUT);
pinMode(pinIN2, OUTPUT);
pinMode(pinPWM, OUTPUT);
if (pinCurrentSense != 255) {
pinMode(pinCurrentSense, INPUT);
}
// Setup PWM
ledcSetup(pwmChannel, pwmFrequency, pwmResolution);
ledcAttachPin(pinPWM, pwmChannel);
ledcWrite(pwmChannel, 0);
// Set initial state (brake)
digitalWrite(pinIN1, LOW);
digitalWrite(pinIN2, LOW);
return true;
}
void MotorDriver::setSpeed(uint8_t speed, bool forward) {
targetSpeed = speed;
targetDirection = forward;
}
void MotorDriver::emergencyStop() {
targetSpeed = 0;
currentSpeed = 0;
// Apply brake
digitalWrite(pinIN1, HIGH);
digitalWrite(pinIN2, HIGH);
ledcWrite(pwmChannel, 0);
}
void MotorDriver::update() {
updateAcceleration();
if (loadCompensationEnabled && pinCurrentSense != 255) {
updateLoadCompensation();
} else {
applyMotorControl();
}
}
void MotorDriver::updateAcceleration() {
unsigned long currentTime = millis();
if (currentTime - lastSpeedUpdate < 50) {
return; // Update every 50ms
}
lastSpeedUpdate = currentTime;
if (currentSpeed < targetSpeed) {
// Accelerate
uint8_t delta = (accelRate > 0) ? (255 / accelRate) : 1;
if (currentSpeed + delta >= targetSpeed) {
currentSpeed = targetSpeed;
} else {
currentSpeed += delta;
}
} else if (currentSpeed > targetSpeed) {
// Decelerate
uint8_t delta = (decelRate > 0) ? (255 / decelRate) : 1;
if (currentSpeed <= delta || currentSpeed - delta <= targetSpeed) {
currentSpeed = targetSpeed;
} else {
currentSpeed -= delta;
}
}
}
void MotorDriver::applyMotorControl() {
if (currentSpeed == 0) {
// Stop/brake
digitalWrite(pinIN1, LOW);
digitalWrite(pinIN2, LOW);
ledcWrite(pwmChannel, 0);
return;
}
if (currentSpeed == 1) {
// Emergency stop (brake)
digitalWrite(pinIN1, HIGH);
digitalWrite(pinIN2, HIGH);
ledcWrite(pwmChannel, 0);
return;
}
// Map DCC speed (2-127) to PWM (0-255)
uint16_t pwmValue = map(currentSpeed, 2, 127, 0, 255);
// Set direction
if (targetDirection) {
// Forward
digitalWrite(pinIN1, HIGH);
digitalWrite(pinIN2, LOW);
} else {
// Reverse
digitalWrite(pinIN1, LOW);
digitalWrite(pinIN2, HIGH);
}
// Set PWM
ledcWrite(pwmChannel, pwmValue);
}
void MotorDriver::updateLoadCompensation() {
// Read current
uint16_t currentMa = readCurrent();
// PID control
float error = targetCurrent - currentMa;
integral += error;
// Anti-windup
if (integral > 1000) integral = 1000;
if (integral < -1000) integral = -1000;
float derivative = error - lastError;
lastError = error;
float correction = (Kp * error) + (Ki * integral) + (Kd * derivative);
// Apply correction to PWM
if (currentSpeed == 0 || currentSpeed == 1) {
applyMotorControl();
return;
}
uint16_t basePwm = map(currentSpeed, 2, 127, 0, 255);
int16_t adjustedPwm = basePwm + (int16_t)correction;
// Clamp PWM
if (adjustedPwm < 0) adjustedPwm = 0;
if (adjustedPwm > 255) adjustedPwm = 255;
// Set direction
if (targetDirection) {
digitalWrite(pinIN1, HIGH);
digitalWrite(pinIN2, LOW);
} else {
digitalWrite(pinIN1, LOW);
digitalWrite(pinIN2, HIGH);
}
ledcWrite(pwmChannel, adjustedPwm);
}
uint16_t MotorDriver::readCurrent() {
if (pinCurrentSense == 255) {
return 0;
}
// Read ADC value
uint16_t adcValue = analogRead(pinCurrentSense);
// Convert to milliamps (this is hardware dependent)
// Assuming 3.3V reference, 12-bit ADC, and current sense amplifier
// Adjust this based on your actual hardware
uint16_t currentMa = (adcValue * 3300) / 4096; // Simplified conversion
return currentMa;
}
uint16_t MotorDriver::getMotorCurrent() {
return readCurrent();
}
void MotorDriver::setLoadCompensation(bool enable) {
loadCompensationEnabled = enable;
if (enable) {
integral = 0;
lastError = 0;
}
}
void MotorDriver::setPIDParameters(float kp, float ki, float kd) {
Kp = kp;
Ki = ki;
Kd = kd;
}
void MotorDriver::setAccelRate(uint8_t rate) {
accelRate = rate;
}
void MotorDriver::setDecelRate(uint8_t rate) {
decelRate = rate;
}

127
ESP32/DCC-Loco/src/RailCom.cpp Normal file
View File

@@ -0,0 +1,127 @@
/**
* @file RailCom.cpp
* @brief RailCom Feedback Implementation
*/
#include "RailCom.h"
// RailCom 4-to-8 bit encoding table
const uint8_t RailCom::railcom4to8[16] = {
0xAC, 0xE5, 0xD3, 0xF0,
0x99, 0xCC, 0xB4, 0x78,
0xA3, 0xE1, 0xD5, 0xF2,
0x9A, 0xCA, 0xB8, 0x71
};
RailCom::RailCom()
: txPin(0), cutoutPin(255), enabled(false), locoAddress(3),
currentSpeed(0), currentDirection(true), railcomSerial(nullptr),
lastCutoutTime(0), inCutout(false) {}
bool RailCom::begin(uint8_t txPinNum, uint8_t cutoutDetectPin) {
txPin = txPinNum;
cutoutPin = cutoutDetectPin;
// Initialize UART for RailCom
// RailCom uses 250kbaud, 8N1
railcomSerial = &Serial1;
railcomSerial->begin(250000, SERIAL_8N1, -1, txPin); // RX not used
if (cutoutPin != 255) {
pinMode(cutoutPin, INPUT);
}
enabled = true;
return true;
}
void RailCom::setEnabled(bool enable) {
enabled = enable;
}
void RailCom::setAddress(uint16_t address) {
locoAddress = address;
}
void RailCom::setDecoderState(uint8_t speed, bool direction) {
currentSpeed = speed;
currentDirection = direction;
}
void RailCom::update() {
if (!enabled) return;
// Check for cutout signal if pin is configured
if (cutoutPin != 255) {
bool cutoutDetected = digitalRead(cutoutPin) == LOW;
if (cutoutDetected && !inCutout) {
// Rising edge of cutout
inCutout = true;
lastCutoutTime = micros();
sendRailComData();
} else if (!cutoutDetected && inCutout) {
// Falling edge of cutout
inCutout = false;
}
}
}
void RailCom::sendRailComData() {
if (!enabled || !railcomSerial) return;
// Wait for Channel 1 window (26-177 µs)
delayMicroseconds(RAILCOM_CHANNEL1_START);
sendChannel1();
// Wait for Channel 2 window (193-454 µs)
unsigned long elapsed = micros() - lastCutoutTime;
if (elapsed < RAILCOM_CHANNEL2_START) {
delayMicroseconds(RAILCOM_CHANNEL2_START - elapsed);
}
sendChannel2();
}
void RailCom::sendChannel1() {
// Channel 1: Send locomotive address (ID)
// Format: 2 bytes encoded with 4-to-8 encoding
uint8_t addrLow = locoAddress & 0x0F;
uint8_t addrHigh = (locoAddress >> 4) & 0x0F;
uint8_t byte1 = encode4to8(addrHigh);
uint8_t byte2 = encode4to8(addrLow);
railcomSerial->write(byte1);
railcomSerial->write(byte2);
railcomSerial->flush();
}
void RailCom::sendChannel2() {
// Channel 2: Send status/data
// We can send speed, function states, etc.
// For simplicity, send basic status
// Bit 0-6: Speed (0-127)
// Bit 7: Direction
uint8_t statusByte = currentSpeed & 0x7F;
if (currentDirection) {
statusByte |= 0x80;
}
uint8_t dataLow = statusByte & 0x0F;
uint8_t dataHigh = (statusByte >> 4) & 0x0F;
uint8_t byte1 = encode4to8(dataHigh);
uint8_t byte2 = encode4to8(dataLow);
railcomSerial->write(byte1);
railcomSerial->write(byte2);
railcomSerial->flush();
}
uint8_t RailCom::encode4to8(uint8_t data) {
if (data >= 16) return 0xAC; // Invalid, return first code
return railcom4to8[data];
}

344
ESP32/DCC-Loco/src/main.cpp Normal file
View File

@@ -0,0 +1,344 @@
/**
* @file main.cpp
* @brief DCC Locomotive Decoder - Main Entry Point
*
* ESP32-H2 based DCC decoder with:
* - DCC signal decoding
* - TB67H450FNG motor control with load compensation
* - WS2812 LED control
* - RailCom feedback
* - 2x N-FET accessory outputs
* - WiFi/Bluetooth configuration via WebSocket
*/
#include <Arduino.h>
#include "DCCDecoder.h"
#include "CVManager.h"
#include "LEDController.h"
#include "MotorDriver.h"
#include "RailCom.h"
#include "AccessoryOutputs.h"
#include "ConfigServer.h"
// ==================== PIN DEFINITIONS ====================
// Adjust these based on your hardware wiring
// DCC Input
#define PIN_DCC_INPUT 4 // DCC signal input (with optocoupler)
// Motor Driver (TB67H450FNG)
#define PIN_MOTOR_IN1 5 // Motor phase A
#define PIN_MOTOR_IN2 6 // Motor phase B
#define PIN_MOTOR_PWM 7 // PWM speed control
#define PIN_MOTOR_CURRENT 8 // Current sense (ADC)
// WS2812 LEDs
#define PIN_LED_DATA 9 // WS2812 data line
#define NUM_LEDS 4 // Number of LEDs in strip
// RailCom
#define PIN_RAILCOM_TX 10 // RailCom transmit (UART1 TX)
#define PIN_RAILCOM_CUTOUT 11 // DCC cutout detection (optional)
// Accessory Outputs (N-FETs)
#define PIN_ACCESSORY_1 12 // Accessory output 1
#define PIN_ACCESSORY_2 13 // Accessory output 2
// Configuration Button
#define PIN_CONFIG_BUTTON 14 // Hold to enter config mode
// ==================== GLOBAL OBJECTS ====================
DCCDecoder dccDecoder;
CVManager cvManager;
LEDController ledController;
MotorDriver motorDriver;
RailCom railCom;
AccessoryOutputs accessories;
ConfigServer* configServer = nullptr;
// ==================== STATE VARIABLES ====================
bool configMode = false;
unsigned long configButtonPressTime = 0;
const unsigned long CONFIG_HOLD_TIME = 3000; // 3 seconds to enter config mode
// ==================== FUNCTION DECLARATIONS ====================
void checkConfigButton();
void enterConfigMode();
void exitConfigMode();
void updateDecoderStatus(JsonObject& status);
void syncStatesFromDecoder();
// ==================== SETUP ====================
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("\n\n======================================");
Serial.println("DCC Locomotive Decoder");
Serial.println("ESP32-H2 Version 1.0");
Serial.println("======================================\n");
// Initialize configuration button
pinMode(PIN_CONFIG_BUTTON, INPUT_PULLUP);
// Initialize CV Manager
Serial.print("Initializing CV Manager... ");
if (cvManager.begin()) {
Serial.println("OK");
} else {
Serial.println("FAILED");
}
// Load configuration from CVs
uint16_t locoAddress = cvManager.getLocoAddress();
uint8_t accelRate = cvManager.readCV(CV_ACCEL_RATE, 10);
uint8_t decelRate = cvManager.readCV(CV_DECEL_RATE, 10);
uint8_t ledBrightness = cvManager.readCV(CV_LED_BRIGHTNESS, 128);
bool railComEnabled = cvManager.readCV(CV_RAILCOM_ENABLE, 1) != 0;
bool loadCompEnabled = cvManager.readCV(CV_LOAD_COMP_ENABLE, 1) != 0;
Serial.println("\nConfiguration:");
Serial.printf(" Locomotive Address: %d %s\n", locoAddress,
cvManager.isLongAddress() ? "(Long)" : "(Short)");
Serial.printf(" Accel Rate: %d\n", accelRate);
Serial.printf(" Decel Rate: %d\n", decelRate);
Serial.printf(" RailCom: %s\n", railComEnabled ? "Enabled" : "Disabled");
Serial.printf(" Load Compensation: %s\n", loadCompEnabled ? "Enabled" : "Disabled");
// Initialize DCC Decoder
Serial.print("\nInitializing DCC Decoder... ");
if (dccDecoder.begin(PIN_DCC_INPUT)) {
dccDecoder.setAddress(locoAddress);
Serial.println("OK");
} else {
Serial.println("FAILED");
}
// Initialize Motor Driver
Serial.print("Initializing Motor Driver... ");
if (motorDriver.begin(PIN_MOTOR_IN1, PIN_MOTOR_IN2, PIN_MOTOR_PWM, PIN_MOTOR_CURRENT)) {
motorDriver.setAccelRate(accelRate);
motorDriver.setDecelRate(decelRate);
motorDriver.setLoadCompensation(loadCompEnabled);
// Load PID parameters from CVs
float kp = cvManager.readCV(CV_MOTOR_KP, 50) / 10.0;
float ki = cvManager.readCV(CV_MOTOR_KI, 5) / 10.0;
float kd = cvManager.readCV(CV_MOTOR_KD, 10) / 10.0;
motorDriver.setPIDParameters(kp, ki, kd);
Serial.println("OK");
} else {
Serial.println("FAILED");
}
// Initialize LED Controller
Serial.print("Initializing LED Controller... ");
if (ledController.begin(PIN_LED_DATA, NUM_LEDS)) {
ledController.setBrightness(ledBrightness);
// Configure default LED mappings
ledController.setLEDMode(0, LIGHT_DIRECTION_FRONT); // Front headlight
ledController.setLEDColor(0, 255, 255, 200); // Warm white
ledController.setLEDMode(1, LIGHT_DIRECTION_REAR); // Rear headlight
ledController.setLEDColor(1, 255, 0, 0); // Red
ledController.mapFunctionToLED(1, 2, LIGHT_ON); // F1 -> LED 2
ledController.mapFunctionToLED(2, 3, LIGHT_BLINK); // F2 -> LED 3 (blink)
Serial.println("OK");
} else {
Serial.println("FAILED");
}
// Initialize RailCom
if (railComEnabled) {
Serial.print("Initializing RailCom... ");
if (railCom.begin(PIN_RAILCOM_TX, PIN_RAILCOM_CUTOUT)) {
railCom.setAddress(locoAddress);
Serial.println("OK");
} else {
Serial.println("FAILED");
}
} else {
Serial.println("RailCom disabled");
}
// Initialize Accessory Outputs
Serial.print("Initializing Accessory Outputs... ");
if (accessories.begin(PIN_ACCESSORY_1, PIN_ACCESSORY_2)) {
// Load modes from CVs
AccessoryMode mode1 = (AccessoryMode)cvManager.readCV(CV_ACCESSORY_1_MODE, ACC_FUNCTION);
AccessoryMode mode2 = (AccessoryMode)cvManager.readCV(CV_ACCESSORY_2_MODE, ACC_FUNCTION);
accessories.setMode(1, mode1);
accessories.setMode(2, mode2);
// Map to functions F3 and F4 by default
accessories.mapFunction(1, 3); // F3 -> Output 1
accessories.mapFunction(2, 4); // F4 -> Output 2
Serial.println("OK");
} else {
Serial.println("FAILED");
}
Serial.println("\n======================================");
Serial.println("Decoder Ready!");
Serial.println("Waiting for DCC signal...");
Serial.println("Hold CONFIG button for 3s to enter");
Serial.println("configuration mode.");
Serial.println("======================================\n");
}
// ==================== MAIN LOOP ====================
void loop() {
// Check for configuration mode entry
checkConfigButton();
if (configMode) {
// Configuration mode - just update the config server
if (configServer) {
configServer->update();
}
delay(10);
return;
}
// ==================== NORMAL OPERATION MODE ====================
// Sync decoder states
syncStatesFromDecoder();
// Update all modules
motorDriver.update();
ledController.update();
railCom.update();
accessories.update();
// Periodic status output (every 5 seconds)
static unsigned long lastStatusPrint = 0;
if (millis() - lastStatusPrint >= 5000) {
lastStatusPrint = millis();
if (dccDecoder.hasValidSignal()) {
Serial.printf("DCC OK | Addr:%d | Speed:%d | Dir:%s | Current:%dmA\n",
dccDecoder.getAddress(),
dccDecoder.getSpeed(),
dccDecoder.getDirection() ? "FWD" : "REV",
motorDriver.getMotorCurrent());
} else {
Serial.println("No DCC signal detected");
}
}
delay(1); // Small delay to prevent watchdog issues
}
// ==================== HELPER FUNCTIONS ====================
void checkConfigButton() {
bool buttonPressed = (digitalRead(PIN_CONFIG_BUTTON) == LOW);
if (buttonPressed) {
if (configButtonPressTime == 0) {
configButtonPressTime = millis();
} else if (!configMode && (millis() - configButtonPressTime >= CONFIG_HOLD_TIME)) {
enterConfigMode();
}
} else {
// Button released
if (configMode && configButtonPressTime > 0) {
// Short press in config mode = exit
exitConfigMode();
}
configButtonPressTime = 0;
}
}
void enterConfigMode() {
configMode = true;
Serial.println("\n======================================");
Serial.println("ENTERING CONFIGURATION MODE");
Serial.println("======================================");
// Stop motor
motorDriver.emergencyStop();
// Create and start configuration server
configServer = new ConfigServer(cvManager);
configServer->setStatusCallback(updateDecoderStatus);
// Start in AP mode with default name
if (configServer->begin(nullptr, nullptr, true)) {
Serial.println("Configuration server started");
Serial.println("Connect to WiFi AP to configure");
Serial.println("Press CONFIG button again to exit");
} else {
Serial.println("Failed to start configuration server");
delete configServer;
configServer = nullptr;
configMode = false;
}
}
void exitConfigMode() {
Serial.println("\n======================================");
Serial.println("EXITING CONFIGURATION MODE");
Serial.println("======================================\n");
if (configServer) {
configServer->stop();
delete configServer;
configServer = nullptr;
}
// Reload configuration
uint16_t newAddress = cvManager.getLocoAddress();
dccDecoder.setAddress(newAddress);
railCom.setAddress(newAddress);
uint8_t newBrightness = cvManager.readCV(CV_LED_BRIGHTNESS, 128);
ledController.setBrightness(newBrightness);
configMode = false;
Serial.println("Decoder ready - waiting for DCC signal");
}
void updateDecoderStatus(JsonObject& status) {
status["address"] = dccDecoder.getAddress();
status["speed"] = dccDecoder.getSpeed();
status["direction"] = dccDecoder.getDirection();
status["signal"] = dccDecoder.hasValidSignal();
status["current"] = motorDriver.getMotorCurrent();
// Add function states
JsonArray functions = status.createNestedArray("functions");
for (uint8_t i = 0; i <= 12; i++) {
functions.add(dccDecoder.getFunction(i));
}
}
void syncStatesFromDecoder() {
// Get current state from DCC decoder
uint8_t speed = dccDecoder.getSpeed();
bool direction = dccDecoder.getDirection();
// Update motor
motorDriver.setSpeed(speed, direction);
// Update LEDs
ledController.setDirection(direction);
for (uint8_t i = 0; i <= 28; i++) {
bool funcState = dccDecoder.getFunction(i);
ledController.setFunctionState(i, funcState);
accessories.setFunctionState(i, funcState);
}
// Update accessories
accessories.setSpeed(speed);
// Update RailCom
railCom.setDecoderState(speed, direction);
}

369
ESP32/ESP-Home/README.md Normal file
View File

@@ -0,0 +1,369 @@
- platform: template
name: "Boost Duration (min)"
id: boost_duration
min_value: 5
max_value: 120
step: 1
initial_value: 30
optimistic: true
---
## Example: Dynamic Setpoints from Home Assistant
You can allow Home Assistant to set the Eco, Confort, and Boost temperatures by exposing them as number entities in ESPHome. Home Assistant can then adjust these values, and ESPHome will use them for the setpoints.
```yaml
number:
- platform: template
name: "Hors gel Temperature"
id: hors_gel_temp
min_value: 5
max_value: 10
step: 0.5
initial_value: 7
optimistic: true
- platform: template
name: "Eco Temperature"
id: eco_temp
min_value: 10
max_value: 25
step: 0.5
initial_value: 18
optimistic: true
- platform: template
name: "Confort Temperature"
id: confort_temp
min_value: 15
max_value: 25
step: 0.5
initial_value: 21
optimistic: true
- platform: template
name: "Boost Temperature"
id: boost_temp
min_value: 18
max_value: 28
step: 0.5
initial_value: 23
optimistic: true
interval:
- interval: 1s
then:
- lambda: |-
static unsigned long boost_start = 0;
static bool boost_active = false;
if (id(thermostat_mode).state == "Boost") {
if (!boost_active) {
boost_start = millis();
boost_active = true;
}
id(heater_thermostat).set_target_temperature(id(boost_temp).state);
id(heater_thermostat).turn_on();
unsigned long boost_duration_ms = (unsigned long)(id(boost_duration).state * 60 * 1000);
if (millis() - boost_start > boost_duration_ms) {
// End boost, switch to previous mode or Eco by default
id(thermostat_mode).publish_state("Eco");
boost_active = false;
}
} else {
boost_active = false;
if (id(thermostat_mode).state == "Hors gel") {
id(heater_thermostat).set_target_temperature(id(hors_gel_temp).state);
id(heater_thermostat).turn_on();
} else if (id(thermostat_mode).state == "Eco") {
id(heater_thermostat).set_target_temperature(id(eco_temp).state);
id(heater_thermostat).turn_on();
} else if (id(thermostat_mode).state == "Confort") {
id(heater_thermostat).set_target_temperature(id(confort_temp).state);
id(heater_thermostat).turn_on();
} else {
id(heater_thermostat).turn_off();
}
}
```
**How it works:**
- Home Assistant can change the Eco, Confort, and Boost temperatures from the UI or automations.
- ESPHome uses the current value of each number entity as the setpoint for the selected mode.
---
---
## Full Example: ESPHome YAML for Sonoff R2 Thermostat with Modes
Below is a complete ESPHome YAML configuration for a Sonoff R2 acting as a thermostat, using a Xiaomi temperature sensor via MQTT, and supporting remote mode selection (Off, Eco, Confort, Boost) from Home Assistant. All logic runs on the Sonoff R2.
```yaml
esphome:
name: sonoff_thermostat
platform: ESP8266
board: esp01_1m
wifi:
ssid: "YOUR_WIFI_SSID"
password: "YOUR_WIFI_PASSWORD"
logger:
api:
ota:
mqtt:
broker: 192.168.1.100
username: your_mqtt_user
password: your_mqtt_password
sensor:
- platform: mqtt_subscribe
name: "Room Temperature"
id: room_temp
topic: "zigbee2mqtt/your_sensor"
unit_of_measurement: "°C"
value_template: "{{ value_json.temperature }}"
switch:
- platform: gpio
pin: 12
id: relay
name: "Heater Relay"
select:
- platform: template
name: "Thermostat Mode"
id: thermostat_mode
options:
- "Off"
- "Hors gel"
- "Eco"
- "Confort"
- "Boost"
initial_option: "Eco"
optimistic: true
climate:
- platform: thermostat
name: "Heater Thermostat"
id: heater_thermostat
sensor: room_temp
min_temperature: 5
max_temperature: 30
heat_action:
- switch.turn_on: relay
idle_action:
- switch.turn_off: relay
interval:
- interval: 1s
then:
- lambda: |-
// Setpoint logic based on mode
if (id(thermostat_mode).state == "Eco") {
id(heater_thermostat).set_target_temperature(18);
id(heater_thermostat).turn_on();
} else if (id(thermostat_mode).state == "Confort") {
id(heater_thermostat).set_target_temperature(21);
id(heater_thermostat).turn_on();
} else if (id(thermostat_mode).state == "Boost") {
id(heater_thermostat).set_target_temperature(23);
id(heater_thermostat).turn_on();
// Optionally, add a timer for boost mode
} else {
id(heater_thermostat).turn_off();
}
# Optionally, add a timer for Boost mode (example: 30 minutes)
# See ESPHome docs for advanced timer logic if needed
```
**How it works:**
- The Sonoff R2 subscribes to the Xiaomi sensor temperature via MQTT.
- The relay controls the heater.
- The `select` exposes the mode (Off/Eco/Confort/Boost) to Home Assistant.
- The `interval` automation updates the thermostat setpoint and state based on the selected mode.
- All logic is local to the Sonoff R2; Home Assistant only changes the mode.
---
# ESP-Home Sonoff R2 Thermostat with MQTT Temperature Sensor
---
## Advanced: Control Modes (Off / Eco / Confort / Boost) from Home Assistant
If you want the thermostat logic (when to turn the heater ON/OFF) to run inside the Sonoff R2 (ESPHome), but still be able to set the mode (Off, Eco, Confort, Boost) remotely from Home Assistant, follow these guidelines:
### 1. Add a Select or Input Mode in ESPHome
- Use the `select` or `template` component in ESPHome to define the current mode (Off, Eco, Confort, Boost).
- Expose this as a selectable entity to Home Assistant.
### 2. Use Automations in ESPHome
- In your ESPHome YAML, use automations to set the target temperature or behavior based on the selected mode.
- Example: Eco = 18°C, Confort = 21°C, Boost = 23°C for 30 minutes, Off = always off.
### 3. Home Assistant Integration
- In Home Assistant, you will see the mode selector as an entity. You can change the mode from the UI or automations.
- No need for Versatile Thermostat in Home Assistant; all logic is in ESPHome.
### 4. Example ESPHome YAML Snippet
```yaml
select:
- platform: template
name: "Thermostat Mode"
id: thermostat_mode
options:
- "Off"
- "Eco"
- "Confort"
- "Boost"
initial_option: "Eco"
optimistic: true
climate:
- platform: thermostat
name: "Heater Thermostat"
sensor: room_temp
min_temperature: 5
max_temperature: 30
heat_action:
- switch.turn_on: relay
idle_action:
- switch.turn_off: relay
on_boot:
- lambda: |-
if (id(thermostat_mode).state == "Eco") {
id(heater_thermostat).set_target_temperature(18);
} else if (id(thermostat_mode).state == "Confort") {
id(heater_thermostat).set_target_temperature(21);
} else if (id(thermostat_mode).state == "Boost") {
id(heater_thermostat).set_target_temperature(23);
// Add timer logic for boost if needed
} else {
id(heater_thermostat).turn_off();
}
automation:
- alias: Set Thermostat Mode
trigger:
- platform: state
entity_id: select.thermostat_mode
action:
- lambda: |-
if (id(thermostat_mode).state == "Eco") {
id(heater_thermostat).set_target_temperature(18);
id(heater_thermostat).turn_on();
} else if (id(thermostat_mode).state == "Confort") {
id(heater_thermostat).set_target_temperature(21);
id(heater_thermostat).turn_on();
} else if (id(thermostat_mode).state == "Boost") {
id(heater_thermostat).set_target_temperature(23);
id(heater_thermostat).turn_on();
// Add timer logic for boost if needed
} else {
id(heater_thermostat).turn_off();
}
```
### 5. Remarks
- All logic (when to turn ON/OFF, setpoints, boost timer) is handled by ESPHome on the Sonoff R2.
- Home Assistant only sends the desired mode (Off/Eco/Confort/Boost) to ESPHome.
- This approach is robust: the heater will continue to operate as expected even if Home Assistant is offline.
---
This guide explains how to use a Sonoff R2 switch with ESPHome to control a heater as a thermostat, using a Xiaomi temperature sensor available via an MQTT broker.
## Overview
- **Device:** Sonoff R2 (relay switch)
- **Heater:** Controlled via Sonoff relay (ON/OFF)
- **Temperature Sensor:** Xiaomi (publishing to MQTT broker)
- **Goal:** Use ESPHome to turn the heater ON/OFF based on the temperature received from MQTT.
---
## Steps
### 1. Flash Sonoff R2 with ESPHome
- Install ESPHome on your computer.
- Create a new ESPHome configuration for the Sonoff R2.
- Flash the Sonoff R2 with the ESPHome firmware.
### 2. Configure MQTT in ESPHome
- Enable the MQTT component in your ESPHome YAML config.
- Set the MQTT broker address, username, and password.
### 3. Subscribe to Xiaomi Sensor via MQTT
- Identify the MQTT topic where the Xiaomi sensor publishes temperature (e.g., `zigbee2mqtt/your_sensor` or similar).
- Use the `mqtt_subscribe` or `mqtt` sensor in ESPHome to read the temperature value.
### 4. Create a Thermostat Logic in ESPHome
- Use the `climate` component with a `generic` platform, or use a template switch with automation.
- Set the relay (switch) as the output to control the heater.
- Use the MQTT temperature sensor as the input for the thermostat.
### 5. Example ESPHome YAML Snippet
```yaml
esphome:
name: sonoff_thermostat
mqtt:
broker: 192.168.1.100
username: your_mqtt_user
password: your_mqtt_password
sensor:
- platform: mqtt_subscribe
name: "Room Temperature"
id: room_temp
topic: "zigbee2mqtt/your_sensor"
unit_of_measurement: "°C"
value_template: "{{ value_json.temperature }}"
switch:
- platform: gpio
pin: 12
id: relay
name: "Heater Relay"
climate:
- platform: thermostat
name: "Heater Thermostat"
sensor: room_temp
default_target_temperature_low: 19
default_target_temperature_high: 21
heat_action:
- switch.turn_on: relay
idle_action:
- switch.turn_off: relay
```
### 6. Upload and Test
- Upload the configuration to the Sonoff R2.
- Monitor the logs to ensure the temperature is received and the relay switches as expected.
### 7. Integrate with Home Assistant (Optional)
- Add the ESPHome device to Home Assistant for remote control and monitoring.
---
## Troubleshooting
- Ensure the MQTT broker is accessible from the Sonoff R2.
- Verify the correct MQTT topic and payload format for the Xiaomi sensor.
- Check ESPHome logs for errors.
---
## References
- [ESPHome MQTT Sensor](https://esphome.io/components/sensor/mqtt.html)
- [ESPHome Thermostat Climate](https://esphome.io/components/climate/thermostat.html)
- [Sonoff Basic with ESPHome](https://esphome.io/cookbook/sonoff_basic.html)
- [Xiaomi Zigbee2MQTT](https://www.zigbee2mqtt.io/)
---
**You now have a Sonoff R2 acting as a thermostat, using a Xiaomi temperature sensor via MQTT!**
---
**To control modes from Home Assistant, expose a select entity in ESPHome and use automations in ESPHome to change setpoints or behavior based on the selected mode.**

148
ESP32/ESP-Home/THERMO_BUREAU.yaml Normal file
View File

@@ -0,0 +1,148 @@
esphome:
name: thermobureau
esp8266:
board: esp8285
# Enable Home Assistant API
api:
encryption:
key: "K61VpR3UU3CTtHaOZcHROEdk7rtB2HWbMJ5VHcJLhEU="
ota:
- platform: esphome
password: "315848030ef60c32adaba1857437a2ae"
wifi:
ssid: "Freebox-789E5E"
password: "sftbdqn5nnqwn6x4q2sxvc"
min_auth_mode: WPA2
# Enable fallback hotspot (captive portal) in case wifi connection fails
ap:
ssid: "Sonoff Fallback Hotspot"
password: "v0xOuZTqfR75"
captive_portal:
logger:
mqtt:
broker: 192.168.1.53
username: mqtt
password: Secr3t
sensor:
- platform: mqtt_subscribe
name: "Room Temperature"
id: room_temp
topic: "zigbee2mqtt/your_sensor" # Change to your sensor topic
unit_of_measurement: "°C"
value_template: "{{ value_json.temperature }}"
switch:
- platform: gpio
pin: 12
id: relay
name: "Heater Relay"
select:
- platform: template
name: "Thermostat Mode"
id: thermostat_mode
options:
- "Off"
- "Hors gel"
- "Eco"
- "Confort"
- "Boost"
initial_option: "Eco"
optimistic: true
climate:
- platform: thermostat
name: "Heater Thermostat"
id: heater_thermostat
sensor: room_temp
min_temperature: 5
max_temperature: 30
heat_action:
- switch.turn_on: relay
idle_action:
- switch.turn_off: relay
number:
- platform: template
name: "Hors gel Temperature"
id: hors_gel_temp
min_value: 5
max_value: 10
step: 0.5
initial_value: 7
optimistic: true
- platform: template
name: "Eco Temperature"
id: eco_temp
min_value: 10
max_value: 25
step: 0.5
initial_value: 18
optimistic: true
- platform: template
name: "Confort Temperature"
id: confort_temp
min_value: 15
max_value: 25
step: 0.5
initial_value: 21
optimistic: true
- platform: template
name: "Boost Temperature"
id: boost_temp
min_value: 18
max_value: 28
step: 0.5
initial_value: 23
optimistic: true
- platform: template
name: "Boost Duration (min)"
id: boost_duration
min_value: 5
max_value: 120
step: 1
initial_value: 30
optimistic: true
interval:
- interval: 1s
then:
- lambda: |-
static unsigned long boost_start = 0;
static bool boost_active = false;
if (id(thermostat_mode).state == "Boost") {
if (!boost_active) {
boost_start = millis();
boost_active = true;
}
id(heater_thermostat).set_target_temperature(id(boost_temp).state);
id(heater_thermostat).turn_on();
unsigned long boost_duration_ms = (unsigned long)(id(boost_duration).state * 60 * 1000);
if (millis() - boost_start > boost_duration_ms) {
id(thermostat_mode).publish_state("Eco");
boost_active = false;
}
} else {
boost_active = false;
if (id(thermostat_mode).state == "Hors gel") {
id(heater_thermostat).set_target_temperature(id(hors_gel_temp).state);
id(heater_thermostat).turn_on();
} else if (id(thermostat_mode).state == "Eco") {
id(heater_thermostat).set_target_temperature(id(eco_temp).state);
id(heater_thermostat).turn_on();
} else if (id(thermostat_mode).state == "Confort") {
id(heater_thermostat).set_target_temperature(id(confort_temp).state);
id(heater_thermostat).turn_on();
} else {
id(heater_thermostat).turn_off();
}
}