Move folder.
This commit is contained in:
mattbk
2
src/config.h.default
Normal file
2
src/config.h.default
Normal file
@ -0,0 +1,2 @@
|
||||
#define WIFI_SSID "wifi_name"
|
||||
#define WIFI_PASSWORD "wifi_pass"
|
||||
609
src/main.cpp
Normal file
609
src/main.cpp
Normal file
@ -0,0 +1,609 @@
|
||||
/*********
|
||||
Rui Santos
|
||||
Complete project details at https://RandomNerdTutorials.com/esp32-esp8266-input-data-html-form/
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
*********/
|
||||
|
||||
// include wifi password
|
||||
#include "config.h"
|
||||
#include <Arduino.h>
|
||||
#include <WiFi.h>
|
||||
#include <AsyncTCP.h>
|
||||
#include <SPIFFS.h>
|
||||
#include <Preferences.h>
|
||||
#include "morse.h"
|
||||
#include <Adafruit_BusIO_Register.h> // for DS3231
|
||||
#include <RTClib.h> // for DS3231
|
||||
#include <string>
|
||||
|
||||
// download zip from https://github.com/me-no-dev/ESPAsyncWebServer and install.
|
||||
#include <ESPAsyncWebServer.h>
|
||||
|
||||
AsyncWebServer server(80);
|
||||
|
||||
// Assign output variables to GPIO pins
|
||||
//LED_BUILTIN for ESP32 onboard LED, 32 for transmitter keyer
|
||||
const int keyer = 32;
|
||||
const int blinker = LED_BUILTIN;
|
||||
|
||||
RTC_DS3231 rtc; // set up RTC
|
||||
const int alarmPin = 4; // pin to monitor for RTC alarms
|
||||
|
||||
// Network options: "0" for existing netowrk, "1" to be an access point
|
||||
const int network = 1;
|
||||
// Connect to existing network
|
||||
// Read from config.h
|
||||
const char* ssid = WIFI_SSID;
|
||||
const char* password = WIFI_PASSWORD;
|
||||
// Create a new access point
|
||||
// Replace with your desired network credentials
|
||||
const char* ssid_ap = "vulpes";
|
||||
const char* password_ap = NULL; //"123456789"; //NULL is empty
|
||||
IPAddress local_ip(192,168,0,1);
|
||||
IPAddress gateway(192,168,0,1);
|
||||
IPAddress subnet(255,255,255,0);
|
||||
|
||||
const char* PARAM_SEND = "inputSend";
|
||||
const char* PARAM_WPM = "inputWPM";
|
||||
const char* PARAM_MSG = "inputMsg";
|
||||
const char* PARAM_CMSG = "inputCustomMsg";
|
||||
const char* PARAM_FLOAT = "inputFloat";
|
||||
const char* PARAM_TIME = "inputTimeUnix";
|
||||
const char* PARAM_START = "inputStartTimeUnix";
|
||||
const char* PARAM_RUNNING = "programRunning";
|
||||
const char* PARAM_STEPLENGTH = "inputStepLength";
|
||||
const char* PARAM_CYCLEID = "inputCycleID";
|
||||
const char* PARAM_NTRANS = "inputNtransmitters";
|
||||
|
||||
// Global variables
|
||||
int yourInputSend;
|
||||
int yourInputWPM;
|
||||
int yourInputMsg;
|
||||
int yourInputMsg_old; // to save previous state and check changes
|
||||
String yourInputCustomMsg;
|
||||
float yourInputFloat;
|
||||
uint32_t yourInputTime; //to keep time
|
||||
uint32_t yourInputStartTimeUnix;
|
||||
bool startProgram;
|
||||
bool programRunning;
|
||||
int yourInputStepLength;
|
||||
int yourInputCycleID;
|
||||
int yourInputNtransmitters;
|
||||
long start_millis = 0;
|
||||
long stop_millis = 0;
|
||||
long pause_until_millis = 0;
|
||||
|
||||
// HTML web page to handle input fields
|
||||
const char index_html[] PROGMEM = R"rawliteral(
|
||||
<!DOCTYPE HTML><html><head>
|
||||
<link rel="icon" href="data:,">
|
||||
<title>ESP Input Form</title>
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<script type="text/javascript">
|
||||
// Utility from https://webreflection.medium.com/using-the-input-datetime-local-9503e7efdce
|
||||
Date.prototype.toDatetimeLocal = function toDatetimeLocal() {
|
||||
var
|
||||
date = this,
|
||||
ten = function (i) {
|
||||
return (i < 10 ? '0' : '') + i;
|
||||
},
|
||||
YYYY = date.getFullYear(),
|
||||
MM = ten(date.getMonth() + 1),
|
||||
DD = ten(date.getDate()),
|
||||
HH = ten(date.getHours()),
|
||||
II = ten(date.getMinutes()),
|
||||
SS = ten(date.getSeconds())
|
||||
;
|
||||
return YYYY + '-' + MM + '-' + DD + 'T' +
|
||||
HH + ':' + II + ':' + SS;
|
||||
}
|
||||
|
||||
// Submit timestamps as unix seconds when form is submitted
|
||||
var putDate = function(form) {
|
||||
form.inputTimeUnix.value = Math.floor(Date.now() / 1000);// - new Date().getTimezoneOffset()*60;
|
||||
form.inputStartTimeUnix.value = ((Date.parse(js_start_time_unix_entry.value))/1000);
|
||||
//document.getElementById("js_start_time_unix").value = ((Date.parse(js_start_time_unix_entry.value))/1000);
|
||||
}
|
||||
// Fill in page values
|
||||
window.onload = function() {
|
||||
s = %inputStartTimeUnix%;
|
||||
current_start = new Date(s * 1000);
|
||||
document.getElementById('current-start').innerHTML = current_start.toLocaleString();
|
||||
// Show the local time as a string
|
||||
local_time_unix = new Date().toLocaleString();//toUTCString();
|
||||
document.getElementById('local-time-unix').innerHTML = local_time_unix.toString();
|
||||
// Fill in the start time field as local time
|
||||
document.getElementById('js_start_time_unix_entry').value = current_start.toDatetimeLocal();
|
||||
|
||||
// Fill in the other form fields
|
||||
document.getElementById("send-program").value = %inputSend%;
|
||||
document.getElementById("message").value = %inputMsg%;
|
||||
}
|
||||
|
||||
</script></head><body>
|
||||
<h1>Vulpes Radio Orienteering Controller</h1>
|
||||
<p>Local time: <b><span id=local-time-unix></span></b></p>
|
||||
|
||||
<form action="/get" onsubmit="putDate(this);" accept-charset=utf-8>
|
||||
<h2>General Settings</h2>
|
||||
<p>Sending program:
|
||||
<select name="inputSend" id="send-program">
|
||||
<option value="0" >0 - Off</option>
|
||||
<option value="1">1 - Continuous</option>
|
||||
<option value="2">2 - Cycle</option>
|
||||
</select><br>
|
||||
|
||||
Message:
|
||||
<select name="inputMsg" id="message">
|
||||
<option value="0">0 - Custom Message</option>
|
||||
<option value="1">1 - MOE</option>
|
||||
<option value="2">2 - MOI</option>
|
||||
<option value="3">3 - MOS</option>
|
||||
<option value="4">4 - MOH</option>
|
||||
<option value="5">5 - MO5</option>
|
||||
</select><br>
|
||||
|
||||
Custom message: <input type="text" name="inputCustomMsg" value = "%inputCustomMsg%"><br>
|
||||
|
||||
Speed: <input type="number" name="inputWPM" value = %inputWPM%> WPM
|
||||
</p>
|
||||
|
||||
<h2>Cycle Settings</h2>
|
||||
<p>Only applies when <em>Sending Program</em> is set to "2 - Cycle". You cannot set a cycle start date more than a month in advance.</p>
|
||||
<p>Cycle start time <input type="datetime-local" id="js_start_time_unix_entry" /><br>
|
||||
Current value: <b><span id=current-start></span></b>
|
||||
|
||||
<!-- JS converts the entered start time to a unix timestamp, and copies that value
|
||||
to this hidden field so the user doesn't have to see it. -->
|
||||
<input type="hidden" name="inputStartTimeUnix" id="js_start_time_unix" /></p>
|
||||
<p>
|
||||
Step length: <input type="number" name="inputStepLength" min=1000 step=1000 value = %inputStepLength%> milliseconds <br>
|
||||
Cycle ID: <input type="number" name="inputCycleID" min=1 value = %inputCycleID%><br>
|
||||
Number of transmitters: <input type="number" name="inputNtransmitters" min=1 value = %inputNtransmitters%><br>
|
||||
</p>
|
||||
|
||||
<!-- This field is hidden so people don't change the submit time (it will be wrong).
|
||||
The value is automatically filled in with JS. -->
|
||||
<input type="hidden" name="inputTimeUnix" id="js_time_unix">
|
||||
|
||||
<!-- Extra fields just in case I need them -->
|
||||
<input type="hidden" name="inputFloat" value = %inputFloat%>
|
||||
|
||||
<input type="submit" value="Submit"">
|
||||
</form>
|
||||
<iframe style="display:none" name="hidden-form" id="hidden-form"></iframe>
|
||||
<script type="text/javascript">
|
||||
|
||||
</script>
|
||||
</body></html>)rawliteral";
|
||||
|
||||
|
||||
void notFound(AsyncWebServerRequest *request) {
|
||||
request->send(404, "text/plain", "Not found");
|
||||
}
|
||||
|
||||
String readFile(fs::FS &fs, const char * path){
|
||||
//Serial.printf("Reading file: %s\r\n", path);
|
||||
File file = fs.open(path, "r");
|
||||
if(!file || file.isDirectory()){
|
||||
Serial.println("- empty file or failed to open file");
|
||||
return String();
|
||||
}
|
||||
//Serial.println("- read from file:");
|
||||
String fileContent;
|
||||
while(file.available()){
|
||||
fileContent+=String((char)file.read());
|
||||
}
|
||||
file.close();
|
||||
//Serial.println(fileContent);
|
||||
return fileContent;
|
||||
}
|
||||
|
||||
void writeFile(fs::FS &fs, const char * path, const char * message){
|
||||
Serial.printf("Writing file: %s\r\n", path);
|
||||
File file = fs.open(path, "w");
|
||||
if(!file){
|
||||
Serial.println("- failed to open file for writing");
|
||||
return;
|
||||
}
|
||||
if(file.print(message)){
|
||||
Serial.println("- file written");
|
||||
} else {
|
||||
Serial.println("- write failed");
|
||||
}
|
||||
file.close();
|
||||
}
|
||||
|
||||
// Replaces placeholder in web UI with stored values
|
||||
String processor(const String& var){
|
||||
//Serial.println(var);
|
||||
if(var == "inputCustomMsg"){
|
||||
return readFile(SPIFFS, "/inputCustomMsg.txt");
|
||||
}
|
||||
else if(var == "inputSend"){
|
||||
return readFile(SPIFFS, "/inputSend.txt");
|
||||
}
|
||||
else if(var == "inputWPM"){
|
||||
return readFile(SPIFFS, "/inputWPM.txt");
|
||||
}
|
||||
else if(var == "inputMsg"){
|
||||
return readFile(SPIFFS, "/inputMsg.txt");
|
||||
}
|
||||
else if(var == "inputStepLength"){
|
||||
return readFile(SPIFFS, "/inputStepLength.txt");
|
||||
}
|
||||
else if(var == "inputCycleID"){
|
||||
return readFile(SPIFFS, "/inputCycleID.txt");
|
||||
}
|
||||
else if(var == "inputNtransmitters"){
|
||||
return readFile(SPIFFS, "/inputNtransmitters.txt");
|
||||
}
|
||||
else if(var == "inputFloat"){
|
||||
return readFile(SPIFFS, "/inputFloat.txt");
|
||||
} else if(var == "inputStartTimeUnix"){
|
||||
// Webform breaks if this value is empty.
|
||||
String temp = readFile(SPIFFS, "/inputStartTimeUnix.txt");
|
||||
if(temp == ""){
|
||||
temp = "0";
|
||||
}
|
||||
return temp;
|
||||
}
|
||||
return String();
|
||||
}
|
||||
|
||||
|
||||
// Set up arduinomorse pin and default WPM
|
||||
LEDMorseSender sender_blink(blinker, 10.0f); //f makes it a float
|
||||
LEDMorseSender sender_key(keyer, 10.0f);
|
||||
|
||||
//================================================================================
|
||||
// setup(): stuff that only gets done once, after power up (KB1OIQ's description)
|
||||
//================================================================================
|
||||
void setup() {
|
||||
Serial.begin(115200);
|
||||
|
||||
// Get arduinomorse ready to go
|
||||
sender_blink.setup();
|
||||
sender_key.setup();
|
||||
|
||||
pinMode(alarmPin, INPUT_PULLUP); // Set alarm pin as pullup
|
||||
|
||||
if (! rtc.begin()) {
|
||||
Serial.println("Couldn't find RTC");
|
||||
Serial.flush();
|
||||
while (1) delay(10);
|
||||
}
|
||||
|
||||
if (rtc.lostPower()) {
|
||||
Serial.println("RTC lost power, let's set the time!");
|
||||
// When time needs to be set on a new device, or after a power loss, the
|
||||
// following line sets the RTC to the date & time this sketch was compiled
|
||||
rtc.adjust(DateTime(__DATE__, __TIME__));
|
||||
// This line sets the RTC with an explicit date & time, for example to set
|
||||
// January 21, 2014 at 3am you would call:
|
||||
//rtc.adjust(DateTime(2023, 9, 2, 17, 32, 0));
|
||||
}
|
||||
|
||||
// Report the RTC time after waiting two seconds
|
||||
// https://amiok.net/gitea/W1CDN/vulpes/issues/50#issuecomment-1376
|
||||
Serial.println("Wait 2s for RTC");
|
||||
delay(2000);
|
||||
Serial.println("RTC time on startup: ");
|
||||
Serial.println(rtc.now().unixtime());
|
||||
Serial.println(rtc.now().timestamp());
|
||||
|
||||
// Are there any RTC alarms set?
|
||||
DateTime alarm_one = rtc.getAlarm1(); // Get the current time
|
||||
char buff[] = "Alarm 1 set for at hh:mm:ss DDD, DD MMM YYYY";
|
||||
Serial.print(alarm_one.toString(buff));
|
||||
Serial.println(" (only HH:MM:SS day-of-month are accurate)");
|
||||
|
||||
// Initialize the output variables as outputs
|
||||
pinMode(keyer, OUTPUT);
|
||||
pinMode(blinker, OUTPUT);
|
||||
// Set outputs to LOW
|
||||
digitalWrite(keyer, LOW);
|
||||
digitalWrite(blinker, LOW);
|
||||
|
||||
// Initialize SPIFFS
|
||||
SPIFFS.begin(true);
|
||||
if(!SPIFFS.begin(true)){
|
||||
Serial.println("An Error has occurred while mounting SPIFFS");
|
||||
return;
|
||||
}
|
||||
if(!SPIFFS.begin()){
|
||||
Serial.println("An Error has occurred while mounting SPIFFS");
|
||||
return;
|
||||
}
|
||||
|
||||
// Read in existing data
|
||||
yourInputCustomMsg = readFile(SPIFFS, "/inputCustomMsg.txt");
|
||||
yourInputSend = readFile(SPIFFS, "/inputSend.txt").toInt();
|
||||
yourInputWPM = readFile(SPIFFS, "/inputWPM.txt").toFloat();
|
||||
yourInputMsg = readFile(SPIFFS, "/inputMsg.txt").toInt();
|
||||
yourInputFloat = readFile(SPIFFS, "/inputFloat.txt").toFloat();
|
||||
yourInputStartTimeUnix = readFile(SPIFFS, "/inputStartTimeUnix.txt").toInt();
|
||||
yourInputStepLength = readFile(SPIFFS, "/inputStepLength.txt").toInt();
|
||||
yourInputCycleID = readFile(SPIFFS, "/inputCycleID.txt").toInt();
|
||||
yourInputNtransmitters = readFile(SPIFFS, "/inputNtransmitters.txt").toInt();
|
||||
// Set WPM from saved value
|
||||
sender_blink.setWPM(yourInputWPM);
|
||||
sender_key.setWPM(yourInputWPM);
|
||||
|
||||
// On restart, keep doing what you were doing before
|
||||
yourInputMsg_old = yourInputMsg;
|
||||
if(yourInputMsg == 0){
|
||||
sender_blink.setMessage(yourInputCustomMsg);
|
||||
sender_key.setMessage(yourInputCustomMsg);
|
||||
} else if(yourInputMsg == 1){
|
||||
sender_blink.setMessage(String("moe "));
|
||||
sender_key.setMessage(String("moe "));
|
||||
} else if(yourInputMsg == 2){
|
||||
sender_blink.setMessage(String("moi "));
|
||||
sender_key.setMessage(String("moi "));
|
||||
} else if(yourInputMsg == 3){
|
||||
sender_blink.setMessage(String("mos "));
|
||||
sender_key.setMessage(String("mos "));
|
||||
} else if(yourInputMsg == 4){
|
||||
sender_blink.setMessage(String("moh "));
|
||||
sender_key.setMessage(String("moh "));
|
||||
} else if(yourInputMsg == 5){
|
||||
sender_blink.setMessage(String("mo5 "));
|
||||
sender_key.setMessage(String("mo5 "));
|
||||
}
|
||||
|
||||
WiFi.setHostname("vulpes");
|
||||
if (network == 0){
|
||||
// Attach to existing wifi
|
||||
WiFi.mode(WIFI_STA);
|
||||
WiFi.begin(ssid, password);
|
||||
if (WiFi.waitForConnectResult() != WL_CONNECTED) {
|
||||
Serial.println("WiFi Failed!");
|
||||
return;
|
||||
}
|
||||
Serial.println();
|
||||
Serial.print("IP Address: ");
|
||||
Serial.println(WiFi.localIP());
|
||||
} else if (network == 1){
|
||||
// Act as new access point
|
||||
WiFi.softAPConfig(local_ip, gateway, subnet);
|
||||
WiFi.softAP(ssid_ap, password_ap);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Send web page with input fields to client
|
||||
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
|
||||
request->send_P(200, "text/html", index_html, processor);
|
||||
});
|
||||
|
||||
// Send a GET request to <ESP_IP>/get?inputCustomMsg=<inputMessage>
|
||||
server.on("/get", HTTP_GET, [] (AsyncWebServerRequest *request) {
|
||||
String inputMessage;
|
||||
// GET inputCustomMsg value on <ESP_IP>/get?inputCustomMsg=<inputMessage>
|
||||
if (request->hasParam(PARAM_CMSG)) {
|
||||
inputMessage = request->getParam(PARAM_CMSG)->value();
|
||||
// arduinomorse needs lowercase characters
|
||||
std::transform(inputMessage.begin(), inputMessage.end(), inputMessage.begin(), ::tolower);
|
||||
writeFile(SPIFFS, "/inputCustomMsg.txt", inputMessage.c_str());
|
||||
yourInputCustomMsg = inputMessage;
|
||||
|
||||
}
|
||||
// GET inputSend value on <ESP_IP>/get?inputSend=<inputMessage>
|
||||
if (request->hasParam(PARAM_SEND)) {
|
||||
inputMessage = request->getParam(PARAM_SEND)->value();
|
||||
writeFile(SPIFFS, "/inputSend.txt", inputMessage.c_str());
|
||||
yourInputSend = inputMessage.toInt();
|
||||
// if not running a program, set the program running off
|
||||
//if(yourInputSend != 2){
|
||||
// Cease all programs on new input
|
||||
startProgram = false;
|
||||
programRunning = false;
|
||||
//}
|
||||
}
|
||||
// GET inputWPM value on <ESP_IP>/get?inputWPM=<inputMessage>
|
||||
if (request->hasParam(PARAM_WPM)) {
|
||||
inputMessage = request->getParam(PARAM_WPM)->value();
|
||||
writeFile(SPIFFS, "/inputWPM.txt", inputMessage.c_str());
|
||||
yourInputWPM = inputMessage.toFloat();
|
||||
sender_blink.setWPM(yourInputWPM);
|
||||
sender_key.setWPM(yourInputWPM);
|
||||
}
|
||||
// GET inputMsg value on <ESP_IP>/get?inputMsg=<inputMessage>
|
||||
if (request->hasParam(PARAM_MSG)) {
|
||||
inputMessage = request->getParam(PARAM_MSG)->value();
|
||||
writeFile(SPIFFS, "/inputMsg.txt", inputMessage.c_str());
|
||||
// save previous state
|
||||
yourInputMsg_old = yourInputMsg;
|
||||
yourInputMsg = inputMessage.toInt();
|
||||
|
||||
// Check the message every time the form is submitted.
|
||||
if(yourInputMsg == 0){
|
||||
sender_blink.setMessage(yourInputCustomMsg);
|
||||
sender_key.setMessage(yourInputCustomMsg);
|
||||
} else if(yourInputMsg == 1){
|
||||
sender_blink.setMessage(String("moe "));
|
||||
sender_key.setMessage(String("moe "));
|
||||
} else if(yourInputMsg == 2){
|
||||
sender_blink.setMessage(String("moi "));
|
||||
sender_key.setMessage(String("moi "));
|
||||
} else if(yourInputMsg == 3){
|
||||
sender_blink.setMessage(String("mos "));
|
||||
sender_key.setMessage(String("mos "));
|
||||
} else if(yourInputMsg == 4){
|
||||
sender_blink.setMessage(String("moh "));
|
||||
sender_key.setMessage(String("moh "));
|
||||
} else if(yourInputMsg == 5){
|
||||
sender_blink.setMessage(String("mo5 "));
|
||||
sender_key.setMessage(String("mo5 "));
|
||||
}
|
||||
}
|
||||
// GET inputStepLength value on <ESP_IP>/get?inputStepLength=<inputMessage>
|
||||
if (request->hasParam(PARAM_STEPLENGTH)) {
|
||||
inputMessage = request->getParam(PARAM_STEPLENGTH)->value();
|
||||
writeFile(SPIFFS, "/inputStepLength.txt", inputMessage.c_str());
|
||||
yourInputStepLength = inputMessage.toInt();
|
||||
}
|
||||
// GET inputCycleID value on <ESP_IP>/get?inputCycleID=<inputMessage>
|
||||
if (request->hasParam(PARAM_CYCLEID)) {
|
||||
inputMessage = request->getParam(PARAM_CYCLEID)->value();
|
||||
writeFile(SPIFFS, "/inputCycleID.txt", inputMessage.c_str());
|
||||
yourInputCycleID = inputMessage.toInt();
|
||||
}
|
||||
// GET inputNtransmitters value on <ESP_IP>/get?inputNtransmitters=<inputMessage>
|
||||
if (request->hasParam(PARAM_NTRANS)) {
|
||||
inputMessage = request->getParam(PARAM_NTRANS)->value();
|
||||
writeFile(SPIFFS, "/inputNtransmitters.txt", inputMessage.c_str());
|
||||
yourInputNtransmitters = inputMessage.toInt();
|
||||
}
|
||||
// GET inputTimeUnix value on <ESP_IP>/get?inputTimeUnix=<inputMessage>
|
||||
if (request->hasParam(PARAM_TIME)) {
|
||||
inputMessage = request->getParam(PARAM_TIME)->value();
|
||||
//https://stackoverflow.com/a/22733127/2152245
|
||||
yourInputTime = atol(inputMessage.c_str());
|
||||
Serial.print("yourInputTime: ");
|
||||
Serial.println(yourInputTime);
|
||||
// update the RTC time
|
||||
rtc.adjust(DateTime(yourInputTime));
|
||||
DateTime now = rtc.now();
|
||||
// Might work to fix random errors? If date is far in the future,
|
||||
// try to update again.
|
||||
// replace if with while if you want it to try a bunch...
|
||||
if(now.year() > 2040){
|
||||
Serial.print("Year is ");
|
||||
Serial.println(now.year());
|
||||
Serial.println("RTC can't set time. Trying again.");
|
||||
rtc.adjust(DateTime(yourInputTime));
|
||||
}
|
||||
|
||||
Serial.print("UTC time from browser: ");
|
||||
Serial.print(now.year(), DEC);
|
||||
Serial.print('/');
|
||||
Serial.print(now.month(), DEC);
|
||||
Serial.print('/');
|
||||
Serial.print(now.day(), DEC);
|
||||
Serial.print(" (");
|
||||
Serial.print(now.dayOfTheWeek());
|
||||
Serial.print(") ");
|
||||
Serial.print(now.hour(), DEC);
|
||||
Serial.print(':');
|
||||
Serial.print(now.minute(), DEC);
|
||||
Serial.print(':');
|
||||
Serial.print(now.second(), DEC);
|
||||
Serial.println();
|
||||
|
||||
Serial.print("rtc.now().unixtime(): ");
|
||||
Serial.println(rtc.now().unixtime());
|
||||
}
|
||||
// GET inputFloat value on <ESP_IP>/get?inputFloat=<inputMessage>
|
||||
if (request->hasParam(PARAM_FLOAT)) {
|
||||
inputMessage = request->getParam(PARAM_FLOAT)->value();
|
||||
writeFile(SPIFFS, "/inputFloat.txt", inputMessage.c_str());
|
||||
yourInputFloat = inputMessage.toFloat();
|
||||
}
|
||||
// GET inputStartTimeUnix value on <ESP_IP>/get?inputStartTimeUnix=<inputMessage>
|
||||
if (request->hasParam(PARAM_START)) {
|
||||
inputMessage = request->getParam(PARAM_START)->value();
|
||||
Serial.println(inputMessage);
|
||||
// if a start time isn't entered, don't overwrite the old one
|
||||
//if(!(inputMessage != NULL && inputMessage[0] == '\0')){
|
||||
writeFile(SPIFFS, "/inputStartTimeUnix.txt", inputMessage.c_str());
|
||||
yourInputStartTimeUnix = atol(inputMessage.c_str());
|
||||
//}
|
||||
Serial.println(yourInputStartTimeUnix);
|
||||
|
||||
// Use alarm built into RTC
|
||||
rtc.setAlarm1(DateTime(yourInputStartTimeUnix), DS3231_A1_Date);
|
||||
//rtc.setAlarm1(DateTime(2020, 6, 25, 15, 34, 0), DS3231_A2_Date);
|
||||
DateTime alarm_one = rtc.getAlarm1(); // Get the current alarm time
|
||||
char buff[] = "Alarm 1 set for at hh:mm:ss DDD, DD MMM YYYY";
|
||||
Serial.print(alarm_one.toString(buff));
|
||||
Serial.println(" (only HH:MM:SS day-of-month are accurate)");
|
||||
}
|
||||
// https://techtutorialsx.com/2018/01/14/esp32-arduino-http-server-external-and-internal-redirects/
|
||||
request->redirect("/");
|
||||
});
|
||||
server.onNotFound(notFound);
|
||||
server.begin();
|
||||
|
||||
}
|
||||
|
||||
void loop() {
|
||||
|
||||
// This statement from https://github.com/garrysblog/DS3231-Alarm-With-Adafruit-RTClib-Library/blob/master/DS3231-RTClib-Adafruit-Alarm-Poll-alarmFired/DS3231-RTClib-Adafruit-Alarm-Poll-alarmFired.ino
|
||||
// Check if alarm by polling SQW alarm pin
|
||||
if((yourInputSend == 2) & (digitalRead(alarmPin) == LOW)) {
|
||||
// Print current time and date
|
||||
DateTime now = rtc.now(); // Get the current time
|
||||
char buff[] = "Alarm triggered at hh:mm:ss DDD, DD MMM YYYY";
|
||||
Serial.println(now.toString(buff));
|
||||
startProgram = true;
|
||||
|
||||
// Disable and clear alarm
|
||||
rtc.clearAlarm(1);
|
||||
rtc.clearAlarm(2); // clear the other one just in case
|
||||
}
|
||||
|
||||
// Once alarm has started the program, set things up to run
|
||||
if(startProgram == true){
|
||||
//Serial.println("Start sending");
|
||||
start_millis = millis() + ((yourInputCycleID - 1) * yourInputStepLength);
|
||||
stop_millis = start_millis + yourInputStepLength;
|
||||
if(yourInputCycleID == 1){
|
||||
pause_until_millis = stop_millis + (yourInputStepLength * (yourInputNtransmitters - 1));
|
||||
} else {
|
||||
// Subtract 2 rather than 1 here to account for start_millis duration at beginning of repeat.
|
||||
pause_until_millis = stop_millis + (yourInputStepLength * (yourInputNtransmitters - 2));
|
||||
}
|
||||
programRunning = true;
|
||||
startProgram = false;
|
||||
}
|
||||
|
||||
// if you want to send continuous code, and it's not sending, then start it up
|
||||
if((yourInputSend == 1)){
|
||||
// If not sending, start sending. Yes, these need to be separate statements.
|
||||
if (!sender_blink.continueSending()){
|
||||
sender_blink.startSending();
|
||||
}
|
||||
if (!sender_key.continueSending()){
|
||||
sender_key.startSending();
|
||||
}
|
||||
// if you want to send cycle code and it's not sending, then start it up
|
||||
} else if((yourInputSend == 2) & (programRunning == true)){
|
||||
if((millis() < start_millis)){
|
||||
// Shut the pin off manually
|
||||
digitalWrite(blinker, LOW);
|
||||
digitalWrite(keyer, LOW);
|
||||
} else if((millis() >= start_millis) & (millis() <= stop_millis)){
|
||||
// If not sending, start sending. Yes, these need to be separate statements
|
||||
// for the blinker and keyer.
|
||||
if (!sender_blink.continueSending()){
|
||||
sender_blink.startSending();
|
||||
}
|
||||
if (!sender_key.continueSending()){
|
||||
sender_key.startSending();
|
||||
}
|
||||
} else if((millis() >= stop_millis) & (millis() <= pause_until_millis)){
|
||||
// do nothing in this case -- in between cycles
|
||||
// Shut the pin off manually
|
||||
digitalWrite(blinker, LOW);
|
||||
digitalWrite(keyer, LOW);
|
||||
} else if((millis() >= pause_until_millis)){
|
||||
startProgram = true;
|
||||
}
|
||||
// if the cycle program is not running
|
||||
} else if((yourInputSend == 2) & (programRunning == false)){
|
||||
// do we need something here?
|
||||
// if you don't want to send code
|
||||
} else if(yourInputSend == 0){
|
||||
// Shut the pin off manually
|
||||
digitalWrite(blinker, LOW);
|
||||
digitalWrite(keyer, LOW);
|
||||
}
|
||||
|
||||
}
|
||||
232
src/morse.cpp
Executable file
232
src/morse.cpp
Executable file
@ -0,0 +1,232 @@
|
||||
// Morse Code sending library
|
||||
|
||||
#include <morse.h>
|
||||
|
||||
// MorseSender
|
||||
int MorseSender::copyTimings(
|
||||
morseTiming_t *rawOut,
|
||||
morseBitmask_t definition)
|
||||
{
|
||||
int t = 0;
|
||||
boolean foundSentinel = false;
|
||||
for(morseBitmask_t mask = MORSE_BITMASK_HIGH_BIT;
|
||||
mask > 0; mask = mask >> 1)
|
||||
{
|
||||
boolean isDah = (mask & definition) > 0;
|
||||
if(!foundSentinel)
|
||||
{
|
||||
if (isDah) { foundSentinel = true; }
|
||||
continue;
|
||||
}
|
||||
rawOut[2*t] = isDah ? DAH : DIT;
|
||||
rawOut[2*t + 1] = DIT;
|
||||
t++;
|
||||
}
|
||||
return t;
|
||||
}
|
||||
unsigned int MorseSender::fillTimings(char c)
|
||||
{
|
||||
int t = 0;
|
||||
unsigned int start = 0;
|
||||
if (c >= 'a' && c <= 'z')
|
||||
{
|
||||
t = copyTimings(timingBuffer, MORSE_LETTERS[c-'a']);
|
||||
}
|
||||
else if (c >= '0' && c <= '9')
|
||||
{
|
||||
int n = c - '0';
|
||||
boolean ditsFirst = (n <= 5);
|
||||
if (!ditsFirst)
|
||||
{
|
||||
n -= 5;
|
||||
}
|
||||
while(t < 5)
|
||||
{
|
||||
timingBuffer[2*t] = ((t < n) == ditsFirst) ? DIT : DAH;
|
||||
timingBuffer[2*t + 1] = DIT;
|
||||
t++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int s = 0;
|
||||
while(MORSE_PUNCT_ETC[s].c != END)
|
||||
{
|
||||
if(MORSE_PUNCT_ETC[s].c == c)
|
||||
{
|
||||
t = copyTimings(timingBuffer,
|
||||
MORSE_PUNCT_ETC[s].timing);
|
||||
break;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
if (MORSE_PUNCT_ETC[s].c == END)
|
||||
{
|
||||
start = t = 1; // start on a space
|
||||
}
|
||||
}
|
||||
|
||||
timingBuffer[2*t - 1] = DAH;
|
||||
timingBuffer[2*t] = END;
|
||||
|
||||
/*
|
||||
Serial.print("Refilled timing buffer for '");
|
||||
Serial.print(c);
|
||||
Serial.print("': ");
|
||||
int i = start;
|
||||
while(timingBuffer[i] != END)
|
||||
{
|
||||
Serial.print((int)timingBuffer[i]);
|
||||
Serial.print(", ");
|
||||
i++;
|
||||
}
|
||||
Serial.println("END");
|
||||
*/
|
||||
|
||||
return start;
|
||||
}
|
||||
|
||||
// see note in header about pure-virtual-ness
|
||||
void MorseSender::setOn() {};
|
||||
void MorseSender::setOff() {};
|
||||
|
||||
// noop defaults
|
||||
void MorseSender::setReady() {};
|
||||
void MorseSender::setComplete() {};
|
||||
|
||||
MorseSender::MorseSender(unsigned int outputPin, float wpm) :
|
||||
pin(outputPin)
|
||||
{
|
||||
setWPM(wpm);
|
||||
}
|
||||
|
||||
void MorseSender::setup() { pinMode(pin, OUTPUT); }
|
||||
|
||||
void MorseSender::setWPM(float wpm)
|
||||
{
|
||||
setSpeed((morseTiming_t)(1000.0*60.0/(max(1.0f, wpm)*DITS_PER_WORD)));
|
||||
}
|
||||
|
||||
void MorseSender::setSpeed(morseTiming_t duration)
|
||||
{
|
||||
DIT = max(duration, (morseTiming_t) 1);
|
||||
DAH = 3*DIT;
|
||||
}
|
||||
|
||||
void MorseSender::setMessage(const String newMessage)
|
||||
{
|
||||
message = newMessage;
|
||||
|
||||
// Force startSending() before continueSending().
|
||||
messageIndex = message.length();
|
||||
|
||||
// If a different message was in progress, make sure it stops cleanly.
|
||||
if (timingIndex % 2 == 0) {
|
||||
setOff();
|
||||
}
|
||||
}
|
||||
|
||||
void MorseSender::sendBlocking()
|
||||
{
|
||||
//Serial.println("Sending blocking: ");
|
||||
//Serial.println(message);
|
||||
startSending();
|
||||
while(continueSending());
|
||||
}
|
||||
|
||||
void MorseSender::startSending()
|
||||
{
|
||||
messageIndex = 0;
|
||||
if (message.length() == 0) { return; }
|
||||
timingIndex = fillTimings(message[0]);
|
||||
setReady();
|
||||
if (timingIndex % 2 == 0) {
|
||||
setOn();
|
||||
//Serial.print("Starting with on, duration=");
|
||||
} else {
|
||||
//Serial.print("Starting with off, duration=");
|
||||
}
|
||||
lastChangedMillis = millis();
|
||||
//Serial.println((int)timingBuffer[timingIndex]);
|
||||
}
|
||||
|
||||
boolean MorseSender::continueSending()
|
||||
{
|
||||
if(messageIndex >= message.length()) { return false; }
|
||||
|
||||
unsigned long elapsedMillis = millis() - lastChangedMillis;
|
||||
if (elapsedMillis < timingBuffer[timingIndex]) { return true; }
|
||||
|
||||
timingIndex++;
|
||||
if (timingBuffer[timingIndex] == END)
|
||||
{
|
||||
messageIndex++;
|
||||
if(messageIndex >= message.length()) {
|
||||
setOff();
|
||||
setComplete();
|
||||
return false;
|
||||
}
|
||||
timingIndex = fillTimings(message[messageIndex]);
|
||||
}
|
||||
|
||||
lastChangedMillis += elapsedMillis;
|
||||
//Serial.print("Next is ");
|
||||
if (timingIndex % 2 == 0) {
|
||||
//Serial.print("(on) ");
|
||||
setOn();
|
||||
} else {
|
||||
//Serial.print("(off) ");
|
||||
setOff();
|
||||
}
|
||||
//Serial.println((int)timingBuffer[timingIndex]);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void *MorseSender::operator new(size_t size) { return malloc(size); }
|
||||
void MorseSender::operator delete(void* ptr) { if (ptr) free(ptr); }
|
||||
|
||||
|
||||
// SpeakerMorseSender
|
||||
|
||||
// void SpeakerMorseSender::setOn() { tone(pin, frequency); }
|
||||
// void SpeakerMorseSender::setOff() {
|
||||
// if (carrFrequency == CARRIER_FREQUENCY_NONE) {
|
||||
// noTone(pin);
|
||||
// } else {
|
||||
// tone(pin, carrFrequency);
|
||||
// }
|
||||
// }
|
||||
// void SpeakerMorseSender::setReady() { setOff(); }
|
||||
// void SpeakerMorseSender::setComplete() { noTone(pin); }
|
||||
// SpeakerMorseSender::SpeakerMorseSender(
|
||||
// int outputPin,
|
||||
// unsigned int toneFrequency,
|
||||
// unsigned int carrierFrequency,
|
||||
// float wpm)
|
||||
// : MorseSender(outputPin, wpm),
|
||||
// frequency(toneFrequency),
|
||||
// carrFrequency(carrierFrequency) {};
|
||||
|
||||
|
||||
// LEDMorseSender
|
||||
|
||||
void LEDMorseSender::setOn() { digitalWrite(pin, activeLow ? LOW : HIGH); }
|
||||
void LEDMorseSender::setOff() { digitalWrite(pin, activeLow ? HIGH : LOW); }
|
||||
LEDMorseSender::LEDMorseSender(int outputPin, bool activeLow, float wpm)
|
||||
: MorseSender(outputPin, wpm), activeLow(activeLow) {};
|
||||
LEDMorseSender::LEDMorseSender(int outputPin, float wpm)
|
||||
: MorseSender(outputPin, wpm), activeLow(false) {};
|
||||
|
||||
// PWMMorseSender
|
||||
|
||||
void PWMMorseSender::setOn() { analogWrite(pin, brightness); }
|
||||
void PWMMorseSender::setOff() { analogWrite(pin, 0); }
|
||||
void PWMMorseSender::setBrightness(byte bright) {
|
||||
brightness = bright;
|
||||
}
|
||||
PWMMorseSender::PWMMorseSender(
|
||||
int outputPin,
|
||||
float wpm,
|
||||
byte bright)
|
||||
: MorseSender(outputPin, wpm), brightness(bright) {};
|
||||
276
src/morse.h
Executable file
276
src/morse.h
Executable file
@ -0,0 +1,276 @@
|
||||
#pragma once
|
||||
/**
|
||||
* Generate and send Morse Code on an LED or a speaker. Allow sending
|
||||
* in a non-blocking manner (by calling a 'continue sending' method
|
||||
* every so often to turn an LED on/off, or to call tone/noTone appropriately).
|
||||
*
|
||||
* All input should be lowercase. Prosigns (SK, KN, etc) have special
|
||||
* character values #defined.
|
||||
*
|
||||
* See also:
|
||||
* Morse decoder (using binary tree):
|
||||
* http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1289074596/15
|
||||
* Generator (on playground):
|
||||
* http://www.arduino.cc/playground/Code/Morse
|
||||
*/
|
||||
|
||||
// for malloc and free, for the new/delete operators
|
||||
#include <stdlib.h>
|
||||
#include <analogWrite.h>
|
||||
|
||||
// Arduino language types
|
||||
#if defined(ARDUINO) && ARDUINO >= 100
|
||||
#include "Arduino.h"
|
||||
#else
|
||||
#include "WProgram.h"
|
||||
#endif
|
||||
|
||||
#define WPM_DEFAULT 12.0
|
||||
// PARIS WPM measurement: 50; CODEX WPM measurement: 60 (Wikipedia:Morse_code)
|
||||
#define DITS_PER_WORD 50
|
||||
// Pass to SpeakerMorseSender as carrierFrequency to suppress the carrier.
|
||||
#define CARRIER_FREQUENCY_NONE 0
|
||||
|
||||
// Bitmasks are 1 for dah and 0 for dit, in left-to-right order;
|
||||
// the sequence proper begins after the first 1 (a sentinel).
|
||||
// Credit for this scheme to Mark VandeWettering K6HX ( brainwagon.org ).
|
||||
typedef unsigned int morseTiming_t;
|
||||
typedef unsigned char morseBitmask_t; // see also MAX_TIMINGS
|
||||
#define MORSE_BITMASK_HIGH_BIT B10000000
|
||||
|
||||
// sentinel
|
||||
#define END 0
|
||||
|
||||
// the most timing numbers any unit will need; ex: k = on,off,on,off,on,end = 5
|
||||
#define MAX_TIMINGS 15
|
||||
|
||||
// Punctuation and Prosigns
|
||||
#define PROSIGN_SK 'S'
|
||||
#define PROSIGN_KN 'K'
|
||||
#define PROSIGN_BT 'B'
|
||||
typedef struct {
|
||||
char c;
|
||||
morseBitmask_t timing;
|
||||
} specialTiming;
|
||||
const specialTiming MORSE_PUNCT_ETC[] = {
|
||||
{'.', B1010101},
|
||||
{'?', B1001100},
|
||||
{'/', B110010},
|
||||
{PROSIGN_SK, B1000101},
|
||||
{PROSIGN_KN, B110110},
|
||||
{PROSIGN_BT, B110001},
|
||||
{END, B1},
|
||||
};
|
||||
|
||||
// Morse Code (explicit declaration of letter timings)
|
||||
const morseBitmask_t MORSE_LETTERS[26] = {
|
||||
/* a */ B101,
|
||||
/* b */ B11000,
|
||||
/* c */ B11010,
|
||||
/* d */ B1100,
|
||||
/* e */ B10,
|
||||
/* f */ B10010,
|
||||
/* g */ B1110,
|
||||
/* h */ B10000,
|
||||
/* i */ B100,
|
||||
/* j */ B10111,
|
||||
/* k */ B1101,
|
||||
/* l */ B10100,
|
||||
/* m */ B111,
|
||||
/* n */ B110,
|
||||
/* o */ B1111,
|
||||
/* p */ B10110,
|
||||
/* q */ B11101,
|
||||
/* r */ B1010,
|
||||
/* s */ B1000,
|
||||
/* t */ B11,
|
||||
/* u */ B1001,
|
||||
/* v */ B10001,
|
||||
/* w */ B1011,
|
||||
/* x */ B11001,
|
||||
/* y */ B11011,
|
||||
/* z */ B11100,
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Define the logic of converting characters to on/off timing,
|
||||
* and encapsulate the state of one sending-in-progress Morse message.
|
||||
*
|
||||
* Subclasses define setOn and setOff for (for example) LED and speaker output.
|
||||
*/
|
||||
class MorseSender {
|
||||
protected:
|
||||
const unsigned int pin;
|
||||
// The setOn and setOff methods would be pure virtual,
|
||||
// but that has compiler issues.
|
||||
// See: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1167672075 .
|
||||
|
||||
/**
|
||||
* Called to set put the output in 'on' state, during a dit or dah.
|
||||
*/
|
||||
virtual void setOn();
|
||||
virtual void setOff();
|
||||
|
||||
/**
|
||||
* Called before sending a message. Used for example to enable a
|
||||
* carrier. (Noop in the base class.)
|
||||
*/
|
||||
virtual void setReady();
|
||||
virtual void setComplete();
|
||||
|
||||
private:
|
||||
morseTiming_t DIT, DAH;
|
||||
String message;
|
||||
|
||||
// on,off,...,wait,0 list, millis
|
||||
morseTiming_t timingBuffer[MAX_TIMINGS+1];
|
||||
|
||||
// index of the character currently being sent
|
||||
unsigned int messageIndex;
|
||||
// timing unit currently being sent
|
||||
unsigned int timingIndex;
|
||||
|
||||
// when this timing unit was started
|
||||
unsigned long lastChangedMillis;
|
||||
|
||||
/**
|
||||
* Copy definition timings (on only) to raw timings (on/off).
|
||||
* @return the number of 'on' timings copied
|
||||
*/
|
||||
int copyTimings(morseTiming_t *rawOut,
|
||||
morseBitmask_t definition);
|
||||
|
||||
/**
|
||||
* Fill a buffer with on,off,..,END timings (millis)
|
||||
* @return the index at which to start within the new timing sequence
|
||||
*/
|
||||
unsigned int fillTimings(char c);
|
||||
|
||||
public:
|
||||
/**
|
||||
* Create a sender which will output to the given pin.
|
||||
*/
|
||||
MorseSender(unsigned int outputPin, float wpm=WPM_DEFAULT);
|
||||
|
||||
/**
|
||||
* To be called during the Arduino setup(); set the pin as OUTPUT.
|
||||
*/
|
||||
void setup();
|
||||
|
||||
/**
|
||||
* Set the words per minute (based on PARIS timing).
|
||||
*/
|
||||
void setWPM(float wpm);
|
||||
|
||||
/**
|
||||
* Set the duration, in milliseconds, of a DIT.
|
||||
*/
|
||||
void setSpeed(morseTiming_t duration);
|
||||
|
||||
/**
|
||||
* Set the message to be sent.
|
||||
* This halts any sending in progress.
|
||||
*/
|
||||
void setMessage(const String newMessage);
|
||||
|
||||
/**
|
||||
* Send the entirety of the current message before returning. See the "simple"
|
||||
* example, which uses sendBlocking to send one message.
|
||||
*/
|
||||
void sendBlocking();
|
||||
|
||||
/**
|
||||
* Prepare to send and begin sending the current message. After calling this,
|
||||
* call continueSending repeatedly until it returns false to finish sending
|
||||
* the message. See the "speeds" example, which calls startSending and
|
||||
* continueSending on two different senders.
|
||||
*/
|
||||
void startSending();
|
||||
|
||||
/**
|
||||
* Switch outputs on and off (and refill the internal timing buffer)
|
||||
* as necessary to continue with the sending of the current message.
|
||||
* This should be called every few milliseconds (at a significantly
|
||||
* smaller interval than a DIT) to produce a legible fist.
|
||||
*
|
||||
* @see startSending, which must be called first
|
||||
* @return false if sending is complete, otherwise true (keep sending)
|
||||
*/
|
||||
boolean continueSending();
|
||||
|
||||
void *operator new(size_t size);
|
||||
void operator delete(void* ptr);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Adapt Morse sending to use the Arduino language tone() and noTone()
|
||||
* functions, for use with a speaker.
|
||||
*
|
||||
* If a carrierFrequency is given, instead of calling noTone, call tone
|
||||
* with a low frequency. This is useful ex. for maintaining radio links.
|
||||
*/
|
||||
class SpeakerMorseSender: public MorseSender {
|
||||
private:
|
||||
unsigned int frequency;
|
||||
unsigned int carrFrequency;
|
||||
protected:
|
||||
virtual void setOn();
|
||||
virtual void setOff();
|
||||
virtual void setReady();
|
||||
virtual void setComplete();
|
||||
public:
|
||||
// concert A = 440
|
||||
// middle C = 261.626; higher octaves = 523.251, 1046.502
|
||||
SpeakerMorseSender(
|
||||
int outputPin,
|
||||
unsigned int toneFrequency=1046,
|
||||
unsigned int carrierFrequency=CARRIER_FREQUENCY_NONE,
|
||||
float wpm=WPM_DEFAULT);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Sends Morse on a digital output pin.
|
||||
*/
|
||||
class LEDMorseSender: public MorseSender {
|
||||
private:
|
||||
bool activeLow;
|
||||
protected:
|
||||
virtual void setOn();
|
||||
virtual void setOff();
|
||||
public:
|
||||
/**
|
||||
* Creates a LED Morse code sender with the given GPIO pin. The optional
|
||||
* boolean activeLow indicates LED is ON with digital LOW value.
|
||||
* @param outputPin GPIO pin number
|
||||
* @param activeLow set to true to indicate the LED ON with digital LOW value. default: false
|
||||
* @param wpm words per minute, default: WPM_DEFAULT
|
||||
*/
|
||||
LEDMorseSender(int outputPin, bool activeLow = false, float wpm=WPM_DEFAULT);
|
||||
|
||||
/**
|
||||
* Creates a LED Morse code sender with the given GPIO pin. This constructor is for backward compability.
|
||||
* @param outputPin GPIO pin number
|
||||
* @param wpm words per minute
|
||||
*/
|
||||
LEDMorseSender(int outputPin, float wpm);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Sends Morse on an analog output pin (using PWM). The brightness value is
|
||||
* between 0 and 255 and is passed directly to analogWrite.
|
||||
*/
|
||||
class PWMMorseSender: public MorseSender {
|
||||
private:
|
||||
byte brightness;
|
||||
protected:
|
||||
virtual void setOn();
|
||||
virtual void setOff();
|
||||
public:
|
||||
PWMMorseSender(int outputPin, float wpm=WPM_DEFAULT, byte brightness=255);
|
||||
void setBrightness(byte brightness);
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user