commit 778eabc7e4e75e3d30b8d3885b3fd018ad31b930 from: Tracey Emery date: Fri Apr 1 20:50:04 2022 UTC rename and rearrange, and add new software commit - 91f78949964b22129bf4447e970174440501e903 commit + 778eabc7e4e75e3d30b8d3885b3fd018ad31b930 blob - /dev/null blob + bf0e6b42a0294c5f75c61fd8471b8d7f86cf783c (mode 644) --- /dev/null +++ LICENSE.md @@ -0,0 +1,25 @@ +BSD 2-Clause License + +Copyright (c) 2021, 2022 Tracey Emery K7TLE +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. blob - /dev/null blob + f319582269c7b36e59df732d5460f0a647b628b9 (mode 644) --- /dev/null +++ README.md @@ -0,0 +1,93 @@ +# ESP32-Foxhunt-Rabbit + +Software for building a foxhunt rabbit using the Espressif ESP32U line of chips. + +# audio_call.h information + +For both the Rabbit_Web_UI and Rabbit_Controller, a file called audio_call.h is +required for this to run. Obviously, I'm not going to upload my club's audio +file, because it is only legal for club members to use it. + +To create your own file, the following website has the information you need: +https://circuitdigest.com/microcontroller-projects/esp32-based-audio-player + +Notes +----- + +I modified XT_DAC_Audio and the audio_call.h instructions to place the large +file in PROGMEM. The author of the blog states that the ESP32 memory space is +small, but that's not true. They simply aren't putting the audio in the right +chunks. Constify the WavData and set audio in audio_call.h to: + + const unsigned char audio[######] PROGMEM + +# Library Requirements + +Both the Rabbit_Web_UI and Rabbit_Controller require the following libraries: + +Libraries +--------- + +XT_DAC_Audio: +https://www.xtronical.com/the-dacaudio-library-download-and-installation/ + +Morse: +https://github.com/basepr1me/Morse + +# Rabbit_Web_UI + +The Rabbit_Web_UI is a stand-alone ESP32, which can be controlled via a web +browser. It requires two additional libraries: + +Libraries +--------- + +AsyncTCP: +https://github.com/me-no-dev/AsyncTCP + +ESPAsyncWebServer: +https://github.com/me-no-dev/ESPAsyncWebServer + +Notes +----- + +To turn enable hunting to start when turning on the rabbit, set hunting = 1. + +Also, note the notes about the following in the ino file: + + #define CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED 0 + #define CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED 0 + +# Rabbit_Controller and Rabbit_Remote + +The Rabbit_Controller and Rabbit_Remote use two ESP32s, one acting as the rabbit +and one acting as the remote control, which works with the Windows +Rabbit_Manager software. The ESP32s connect via LR mode and it is advisable to +have a large, WiFi yagi on the remote. With this setup, line-of-sight works to +approximately 1/8 of a mile in my testing, with a +3 dBi antenna on the rabbit. +Espressif specs state this should work at .6 miles, but I believe that would +require two directional antennas, which would make the rabbit much easier to +find in a foxhunt. However, an 1/8 mile is plenty to hide from hunters. + +# Rabbit_Manager + +This is the Windows software used to control the rabbit via the Rabbit_Remote +controller. Rabbit_Remote acts as a repeater to control the rabbit. +Rabbit_Remote also pings the rabbit every 10 seconds to ensure Rabbit_Manager +knows that the two ESP32s are still connected. + +# Additional Notes + +This style is OpenBSD style and may not look right in the Arduino IDE, since +I don't use it. See the [rabbit.pdf](rabbit.pdf) for an example schematic to get +your rabbit started. I used a cheap Baofeng UV-5R as the transmitter, using the +earpiece to connect to the ESP32 and a specially designed ribbon cable for +controlling power from the radio with the battery installed. The schematic and +this respository are subject to large changes. + +Author +------ + +[Tracey Emery](https://github.com/basepr1me/) + +See the [License](LICENSE.md) file for more information. blob - /dev/null blob + 525240d079dac376bcf374d058b1b626b57b5403 (mode 644) --- /dev/null +++ Rabbit_Controller/Rabbit_Controller.ino @@ -0,0 +1,652 @@ +/* + * Copyright (c) 2021, 2022 Tracey Emery K7TLE + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * Watch the order of pins on the board! + * + * D14 - Red LED Power/AR #Solid/cw + * D12 - Green LED Transmitting Voice/cw/Off #Solid/Blink/Off + * D13 - Blue LED Transmitting #On during transmit + * + * D5 - Transmit optical relay + * D18 - Transmitter POWER relay + * D25 - Audio out + * D33 - Audio in + * D26 - Morse out + * + * # If we have enough memory leftover + * CLUB/R OFF # Power Transmitter Off + * CLUB/R ON # Power Transmitter On + * CLUB/R START # Start Transmitting Audio + * CLUB/R STOP # Stop Transmitting Audio + * + * packet types: + * 0x00000001: ping/pong + * 0x00000010: transmit delay + * 0x00000011: update controls + * 0x00000100: control request + */ + +#include +#include +#include +#include +#include +#include + +#include + +#include "audio_call.h" + +#define DEBUG 0 + +#define MAX_CLIENTS 8 + +#define RED_LED 14 +#define GREEN_LED 12 +#define BLUE_LED 13 + +#define TRANSMIT 5 +#define TRANSMIT_PWR 18 /* LOW - OFF, HIGH - ON (switch LOW - ON) */ +/* #define OPTIONAL 21 */ +#define TRANSMIT_DELAY 10 /* seconds */ +#define TRANSMIT_MIN 10 /* seconds */ +#define TRANSMIT_MAX 30 /* seconds */ + +#define BROADCAST 10,0,50,255 +#define IP 10,0,50,1 +#define SUBNET 255,255,255,0 +#define PORT 8080 + +#define ONE_SECOND 1000 + +#define DAC_CHANNEL 2 +#define AUDIO_OUT 25 +#define AUDIO_IN 33 + +#define PING 0x01 +#define TRANSDELAY 0x02 +#define UPDATE 0x03 +#define CRQST 0x04 +#define ENABLE 0x05 +#define ADDBUF 4 +#define CALLS 5 + +#define DPRINTF(x,y) do { if (DEBUG) { Serial.println(x); \ + sleep(y); }} while(0) + +#define WPM 15 + +#define GETCW 1 << 0 +#define GETALT 1 << 1 +#define GETPWR 1 << 2 +#define GETHUNT 1 << 3 +#define GETPTT 1 << 4 +#define GETRND 1 << 5 +#define GETAUTO 1 << 6 + +#define SETALT 1 >> 0 +#define SETPWR 1 >> 1 +#define SETHUNT 1 >> 2 +#define SETPTT 1 >> 3 +#define SETRND 1 >> 4 +#define SETAUTO 1 >> 5 + +#define EEPROM_S 1 + +Morse morse_led(M_GPIO, RED_LED, WPM); +Morse morse_dac(M_DAC, DAC_CHANNEL, WPM); + +String led_morse = "`ar`"; +String dac_morse[CALLS] = { + "de the k7mva rabbit", + "come find me k7mva", + "the k7mva rabbit is loose", + "catch me if you can k7mva", + "k7mva rabbit hiding out", + }; + +const char *local_ssid = "MVARC Rabbit 1"; +const char *local_pass = "MV@rc1234"; +IPAddress local_ip(IP); +IPAddress local_subnet(SUBNET); +IPAddress local_gateway(IP); +IPAddress local_broadcast(BROADCAST); + +WiFiUDP server; + +XT_Wav_Class Sound(audio); +XT_DAC_Audio_Class DacAudio(AUDIO_OUT, 0); + +void setup(void); +void loop(void); +void set_green(void); +void set_red(void); +void handle_transmission(void); +void process_packets(void); +void wifievent(WiFiEvent_t); +void pong(void); +void send_delay(int); +void send_control(void); +void send_enable(void); +void update_control(uint8_t []); + +unsigned long transmit_start_millis, green_start_millis; +unsigned long tx_current_millis, countdown_timer_millis; +unsigned long countdown_millis, red_start_millis; + +int transmit_now = 0; /* don't delay first */ +int autoh, hunting = 1, playing = 0, play = 0, voice = 1; +int transmit_end = 0, powered = 1, rand_num = 1, cw = 1; +int send_handle_events = 0, transmit_new = 1, alt_cw = 1; +int connected = 0, cw_ctl = 1; + +uint8_t channel = 6; +uint8_t preval = 0x7E, pre, type, pcnt, cpkt, calc, fin; + +char packet[1]; +dac_cw_config_t dac_cw_config; + +void +wifievent(WiFiEvent_t e) +{ + switch(e) { + case ARDUINO_EVENT_WIFI_AP_STACONNECTED: + DPRINTF("Rabbit Remote Connected", 0); + connected = 1; + break; + case ARDUINO_EVENT_WIFI_AP_STADISCONNECTED: + DPRINTF("Rabbit Remote Disconnected", 0); + connected = 0; + break; + default: + break; + } +} + +void +setup() +{ + /* disable brownout for startup */ + WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); + delay(1000); + + /* start EEPROM and get state */ + EEPROM.begin(EEPROM_S); + autoh = EEPROM.read(0); + hunting = autoh; + + /* immediate pin setup, transmitter shouldn't be on */ + pinMode(TRANSMIT, OUTPUT); + pinMode(TRANSMIT_PWR, OUTPUT); + digitalWrite(TRANSMIT, LOW); + digitalWrite(TRANSMIT_PWR, LOW); + + /* setup serial */ + Serial.begin(115200); + Serial.setDebugOutput(DEBUG); + sleep(1); + + DPRINTF("", 1); + DPRINTF("Setup serial", 0); + DPRINTF("Setup transmitter", 0); + + /* setup the DAC */ + dac_cw_config.scale = DAC_CW_SCALE_2; + dac_cw_config.freq = 550; + + morse_dac.dac_cw_setup(&dac_cw_config); + DPRINTF("DAC Configured", 0); + + /* setup LEDs */ + pinMode(RED_LED, OUTPUT); + pinMode(GREEN_LED, OUTPUT); + pinMode(BLUE_LED, OUTPUT); + digitalWrite(RED_LED, LOW); + digitalWrite(GREEN_LED, LOW); + digitalWrite(BLUE_LED, LOW); + DPRINTF("Setup LEDs", 0); + + /* audio setup */ + pinMode(AUDIO_OUT, OUTPUT); + pinMode(AUDIO_IN, INPUT); + DPRINTF("Setup audio", 0); + /* DacAudio.DacVolume = 35; */ + + /* setup our AP */ + WiFi.mode(WIFI_AP); + if (esp_wifi_set_protocol(WIFI_IF_AP, WIFI_PROTOCOL_LR)) + DPRINTF("LR Mode Failed", 1); + else + DPRINTF("LR Mode Enabled", 1); + WiFi.softAPConfig(local_ip, local_gateway, local_subnet); + WiFi.softAP(local_ssid, local_pass, channel, false, MAX_CLIENTS); + WiFi.onEvent(wifievent); + + DPRINTF("Setup AP", 0); + + server.begin(PORT); + DPRINTF("Started UDP Mode", 0); + + /* turning on the tranmitter is the final step */ + digitalWrite(TRANSMIT_PWR, HIGH); + digitalWrite(RED_LED, HIGH); + DPRINTF("", 0); + DPRINTF("Transmitter powered on", 1); + DPRINTF("", 0); + DPRINTF("The rabbit is ready to run!", 0); + DPRINTF("", 0); + + /* setup millis timers */ + transmit_start_millis = millis(); + green_start_millis = millis(); + red_start_millis = millis(); + + /* re-enable brownout */ + delay(1000); + WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 1); +} + +void +loop() +{ + tx_current_millis = millis(); + + if (cw_ctl) + playing = morse_dac.dac_transmitting(); + else + playing = Sound.Playing; + + process_packets(); + handle_transmission(); + + if (hunting && powered) + set_green(); + + if (!powered) { + set_red(); + digitalWrite(TRANSMIT_PWR, LOW); + } + + if (powered) + digitalWrite(TRANSMIT_PWR, HIGH); +} + +void +handle_transmission(void) +{ + if (!powered && playing) { + DacAudio.StopAllSounds(); + playing = 0; + transmit_end = 2; + } + + if (hunting && !play && !playing && transmit_now > 0 && powered && + tx_current_millis - countdown_timer_millis >= ONE_SECOND) { + countdown_timer_millis = tx_current_millis; + } + + morse_dac.dac_watchdog(); + DacAudio.FillBuffer(); + + if (hunting && !play && !playing && powered && + (tx_current_millis - transmit_start_millis >= transmit_now)) { + digitalWrite(BLUE_LED, HIGH); + DPRINTF("Transmitting", 0); + transmit_start_millis = tx_current_millis; + if (rand_num) { + transmit_now = random(TRANSMIT_MIN, + TRANSMIT_MAX) * ONE_SECOND; + } else { + /* setup our transmit delay now */ + if (transmit_new) { + transmit_now = ONE_SECOND; + transmit_new = 0; + } else + transmit_now = TRANSMIT_DELAY * ONE_SECOND; + } + send_delay(transmit_now / ONE_SECOND); + play = 1; + } + + if (hunting && play && !playing && !cw_ctl) { + digitalWrite(TRANSMIT, HIGH); + if (tx_current_millis - transmit_start_millis >= ONE_SECOND) { + DPRINTF("Play audio", 0); + DacAudio.Play(&Sound); + play = 0; + transmit_end = 1; + } + } else if (hunting && play && !playing && cw_ctl) { + digitalWrite(TRANSMIT, HIGH); + if (tx_current_millis - transmit_start_millis >= ONE_SECOND) { + DPRINTF("Send CW", 0); + morse_dac.dac_tx(dac_morse[random(0, CALLS)]); + play = 0; + transmit_end = 1; + } + } + + if (transmit_end && playing) { + transmit_start_millis = tx_current_millis; + countdown_timer_millis = tx_current_millis; + countdown_millis = tx_current_millis; + transmit_end = 2; + } + + if (!playing && transmit_end == 2) { + if (tx_current_millis - transmit_start_millis >= ONE_SECOND) { + if (!alt_cw && cw) + cw_ctl = 1; + else if (!cw) + cw_ctl = 0; + else if (alt_cw) + cw_ctl = !cw_ctl; + DPRINTF("End transmission", 0); + DPRINTF("", 0); + digitalWrite(BLUE_LED, LOW); + digitalWrite(TRANSMIT, LOW); + transmit_start_millis = tx_current_millis; + playing = 0; + transmit_end = 0; + send_enable(); + } + } +} + +void +process_packets(void) +{ + int pkt_len = server.parsePacket(); + + if (pkt_len) { + int len, i; + uint16_t sum; + + /* check we are receiving good data */ + len = server.read(packet, 1); + if (len < 1 || len > 1) + goto done; + memcpy(&pre, packet, 1); + if (pre != preval) { + memset(&pre, 0, 1); + goto done; + } + + /* get our packet type */ + len = server.read(packet, 1); + if (len < 1 || len > 1) + goto done; + memcpy(&type, packet, 1); + + /* get our data len */ + len = server.read(packet, 1); + if (len < 1 || len > 1) + goto done; + memcpy(&pcnt, packet, 1); + + /* get our data */ + char mpkt[pcnt]; + uint8_t cpkt[pcnt]; + + len = server.read(mpkt, pcnt); + if (len != pcnt) + goto done; + memcpy(&cpkt, mpkt, pcnt); + + /* get our calculation */ + len = server.read(packet, 1); + if (len < 1 || len > 1) + goto done; + memcpy(&calc, packet, 1); + + /* get our simple checksum */ + sum = pre + type + pcnt; + for (i = 0; i < pcnt; i++) + sum += cpkt[i]; + + fin = sum & 0xFF; + + if (calc != fin) + goto err; + + /* process ping */ + switch (type) { + case (PING): + pong(); + break; + case (TRANSDELAY): + transmit_now = cpkt[0] * 1000; + break; + case (UPDATE): + update_control(cpkt); + break; + case (CRQST): + send_control(); + break; + default: + break; + } +err: + for (i = 0; i < pcnt; i++) + memset(&cpkt[i], 0, 1); + } +done: + server.flush(); + memset(&pre, 0, 1); + memset(&pcnt, 0, 1); + memset(&cpkt, 0, 1); + memset(&fin, 0, 1); +} + +void +update_control(uint8_t pkt[]) +{ + if (DEBUG) { + Serial.print("Control: "); + Serial.println(pkt[0], BIN); + } + + /* always power off when requested */ + powered = (pkt[0] >> SETPWR) & 1; + + if (playing) + return; + + play = (pkt[0] >> SETPTT) & 1; + if (play) + return; + + cw = pkt[0] & 1; + + alt_cw = (pkt[0] >> SETALT) & 1; + if (cw) + cw_ctl = 1; + else if (!cw) + cw_ctl = 0; + + hunting = (pkt[0] >> SETHUNT) & 1; + if (!hunting) { + transmit_new = 1; + transmit_now = 0; + } + rand_num = (pkt[0] >> SETRND) & 1; + + if (autoh != (pkt[0] >> SETAUTO) & 1) { + autoh != autoh; + EEPROM.write(0, autoh); + EEPROM.commit(); + } +} + +void +set_green(void) +{ + if (cw_ctl && tx_current_millis - green_start_millis >= ONE_SECOND) { + digitalWrite(GREEN_LED, !digitalRead(GREEN_LED)); + green_start_millis = millis(); + } +} + +void +set_red(void) +{ + morse_led.gpio_watchdog(); + if (morse_led.gpio_transmitting()) + red_start_millis = millis(); + + if (!morse_led.gpio_transmitting() && tx_current_millis - + red_start_millis >= ONE_SECOND * 2) { + morse_led.gpio_tx(led_morse); + } +} + +void +send_enable(void) +{ + if (!connected) { + DPRINTF("Connection Failed", 0); + return; + } + + DPRINTF("Transmit Enable", 0); + + uint16_t sum; + uint8_t i = 0, j, cnt = 1; + uint8_t buf[cnt + ADDBUF]; + + buf[i++] = preval; + buf[i++] = ENABLE; + buf[i++] = cnt; + buf[i++] = 0; + + for (j = 0; j < i; j++) + sum += buf[j]; + fin = sum & 0xFF; + + buf[i++] = fin; + + server.beginPacket(server.remoteIP(), server.remotePort()); + server.write(buf, cnt + ADDBUF); + server.endPacket(); +} + +void +pong(void) +{ + if (!connected) { + DPRINTF("Connection Failed", 0); + return; + } + + DPRINTF("PING", 0); + + uint16_t sum; + uint8_t i = 0, j, cnt = 1; + uint8_t buf[cnt + ADDBUF]; + + buf[i++] = preval; + buf[i++] = PING; + buf[i++] = cnt; + buf[i++] = 0; + + for (j = 0; j < i; j++) + sum += buf[j]; + fin = sum & 0xFF; + + buf[i++] = fin; + + server.beginPacket(server.remoteIP(), server.remotePort()); + server.write(buf, cnt + ADDBUF); + server.endPacket(); +} + +void +send_control(void) +{ + if (!connected) { + DPRINTF("Connection Failed", 0); + return; + } + + DPRINTF("Control Requested", 0); + + uint16_t sum; + uint8_t i = 0, j, pkt = 0, cnt = 1; + uint8_t buf[cnt + ADDBUF]; + + if (cw) + pkt |= GETCW; + if (alt_cw) + pkt |= GETALT; + if (powered) + pkt |= GETPWR; + if (hunting) + pkt |= GETHUNT; + if (play) + pkt |= GETPTT; + if (rand_num) + pkt |= GETRND; + + pkt |= GETAUTO; + + buf[i++] = preval; + buf[i++] = CRQST; + buf[i++] = cnt; + buf[i++] = pkt; + + for (j = 0; j < i; j++) + sum += buf[j]; + fin = sum & 0xFF; + + buf[i++] = fin; + + server.beginPacket(server.remoteIP(), server.remotePort()); + + server.beginPacket(server.remoteIP(), server.remotePort()); + server.write(buf, cnt + ADDBUF); + server.endPacket(); +} + +void +send_delay(int trans_delay) +{ + if (!connected) { + DPRINTF("Connection Failed", 0); + return; + } + + DPRINTF("Transmit Delay", 0); + + uint16_t sum; + uint8_t i = 0, j, cnt = 1; + uint8_t buf[cnt + ADDBUF]; + + buf[i++] = preval; + buf[i++] = TRANSDELAY; + buf[i++] = cnt; + buf[i++] = trans_delay & 0xFF; + + for (j = 0; j < i; j++) + sum += buf[j]; + fin = sum & 0xFF; + + buf[i++] = fin; + + server.beginPacket(server.remoteIP(), server.remotePort()); + server.write(buf, cnt + ADDBUF); + server.endPacket(); +} blob - /dev/null blob + be4ff2537965919811ce0c9099423443d507553c (mode 644) --- /dev/null +++ Rabbit_Manager/TODO @@ -0,0 +1,7 @@ +# TODO + +* Rename software to Rabbit Manager +* Kill the stupid "you can't close the software during a hunt" junk +* Upload to repository +* Add the auto-hunt functionality +* Probably never work in C# and windows if you really don't have to again :( blob - /dev/null blob + ca1e81e96921ed477badf1a7558a94c36356c44f (mode 644) --- /dev/null +++ Rabbit_Remote/Rabbit_Remote.ino @@ -0,0 +1,318 @@ +/* + * Copyright (c) 2022 Tracey Emery K7TLE + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * This is: client<->remote<->rabbit + * + * what the remote receives from the rabbit: + * pong response + * transmit delay + * update controls + * + * packet types: + * 0x00000001: ping/pong + * 0x00000010: transmit delay + * 0x00000011: update controls + * 0x00000100: control request + */ + +#include +#include +#include +#include +#include + +#define DEBUG 0 + +#define PORT 8080 +#define TIMEOUT 30 +#define ONE_SECOND 1000 + +#define PING 0x01 +#define TRANSDELAY 0x02 +#define UPDATE 0x03 +#define CRQST 0x04 + +#define DPRINTF(x,y) do { if (DEBUG) { Serial.println(x); \ + Serial2.println(x); delay(y); }} while(0) + +const char *ssid = "MVARC Rabbit 1"; +const char *pass = "MV@rc1234"; + +uint8_t recon = 0, do_ping = 0, did_pong = 1; +uint8_t preval = 0x7E, pre, mpre, type, pcnt, calc, fin; +uint16_t sum; + +char packet[1]; + +unsigned long ping_millis, ping_timeout; + +void wifievent(WiFiEvent_t); +void ping(void); +void check_serial(void); +void process_packet(void); +void IRAM_ATTR ping_now(void); + +volatile int interruptCounter; +hw_timer_t *ping_timer = NULL; +portMUX_TYPE timer_mux = portMUX_INITIALIZER_UNLOCKED; + +IPAddress rabbit(10, 0, 50, 1); + +WiFiUDP server; + +void +wifievent(WiFiEvent_t e) +{ + switch(e) { + case ARDUINO_EVENT_WIFI_STA_CONNECTED: + recon = 0; + break; + case ARDUINO_EVENT_WIFI_STA_DISCONNECTED: + WiFi.reconnect(); + if (DEBUG) + if (recon) + Serial.print("."); + else + Serial.print("\r\nReconnecting"); + recon = 1; + break; + default: + break; + } +} + +void setup() { + /* disable brownout for startup */ + WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); + delay(1000); + + /* setup serial */ + Serial.begin(115200); + sleep(1); + Serial.setDebugOutput(DEBUG); + + DPRINTF("", 1); + DPRINTF("Setup serial", 1000); + + /* setup AP */ + WiFi.mode(WIFI_STA); + if(esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_LR)) + DPRINTF("LR Mode Failed", 1); + else + DPRINTF("LR Mode Enabled", 1); + + WiFi.begin(ssid, pass); + WiFi.onEvent(wifievent); + if (DEBUG) + Serial.print("Connecting to Rabbit"); + while(WiFi.status() != WL_CONNECTED) { + if (DEBUG) { + delay(500); + Serial.print("."); + } + } + + server.begin(PORT); + + DPRINTF("", 1000); + DPRINTF("Connected", 1000); + + ping_timer = timerBegin(0, 80, true); + timerAttachInterrupt(ping_timer, &ping_now, true); + timerAlarmWrite(ping_timer, 10000000, true); + timerAlarmEnable(ping_timer); + + /* re-enable brownout */ + delay(1000); + WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 1); +} + +void loop() { + ping(); + check_serial(); + process_packet(); +} + +void +process_packet(void) +{ + int pkt_len = server.parsePacket(); + if (pkt_len) { + int len, i; + + /* check we are receiving good data */ + len = server.read(packet, 1); + if (len < 1 || len > 1) + return; + memcpy(&pre, packet, 1); + if (pre != preval) + goto done; + + /* get our packet type */ + len = server.read(packet, 1); + if (len < 1 || len > 1) + goto done; + memcpy(&type, packet, 1); + + /* get our data len */ + len = server.read(packet, 1); + if (len < 1 || len > 1) + goto done; + memcpy(&pcnt, packet, 1); + + /* get our data */ + char mpkt[pcnt]; + uint8_t cpkt[pcnt]; + + len = server.read(mpkt, pcnt); + if (len != pcnt) + goto done; + memcpy(&cpkt, mpkt, pcnt); + + /* get our calculation */ + len = server.read(packet, 1); + if (len < 1 || len > 1) + goto done; + memcpy(&calc, packet, 1); + + /* get our simple checksum */ + sum = pre + type + pcnt; + for (i = 0; i < pcnt; i++) + sum += cpkt[i]; + + fin = sum & 0xFF; + + if (calc != fin) + goto err; + + /* process ping */ + if (type == PING) { + uint16_t pong_millis = millis() - ping_millis; + pcnt = 2; + uint8_t ct = 1 + 1 + 1 + pcnt + 1; + uint8_t i = 0; + + if (DEBUG) { + Serial.print("PONG Packet ... "); + Serial.print(pong_millis); + Serial.println(" ms"); + } + + did_pong = 1; + calc = (preval + type + pcnt + pong_millis) & 0xFF; + uint8_t buf[ct]; + + buf[i++] = preval; + buf[i++] = type; + buf[i++] = pcnt; + buf[i++] = (pong_millis >> 8) & 0xFF; + buf[i++] = pong_millis & 0xFF; + buf[i++] = calc; + + Serial.write(buf, ct); + goto done; + } + + /* send cpkt to app */ + /* hex visual of our packet */ + if (DEBUG) { + Serial.print("\r\nPkt: "); + Serial.print(pre, HEX); + Serial.print("-"); + Serial.print(type, HEX); + Serial.print("-"); + Serial.print(pcnt, HEX); + Serial.print("-"); + for (i = 0; i < pcnt; i++) { + Serial.print(cpkt[i], HEX); + Serial.print("-"); + } + Serial.println(calc, HEX); + } + Serial.write(pre); + Serial.write(type); + Serial.write(pcnt); + for (i = 0; i < pcnt; i++) + Serial.write(cpkt[i]); + Serial.write(calc); +err: + for (i = 0; i < pcnt; i++) + memset(&cpkt[i], 0, 1); + } +done: + memset(&pre, 0, 1); + memset(&type, 0, 1); + memset(&pcnt, 0, 1); + memset(&calc, 0, 1); +} + +void +ping(void) +{ + if (recon || !do_ping) + return; + + do_ping = 0; + + server.beginPacket(rabbit, 8080); + + uint8_t buf = 0, cnt = 1; + + sum = preval + cnt + buf; + fin = sum & 0xFF; + + /* send our 3 bytes */ + server.write(preval); + server.write(cnt); + server.write(buf); + server.write(fin); + + server.endPacket(); + + if (!did_pong) { + ping_timeout += millis() - ping_millis; + if (ping_timeout >= TIMEOUT * ONE_SECOND) { + DPRINTF("PING TIMEOUT!", 0); + } + } else + ping_timeout = 0; + + ping_millis = millis(); + did_pong = 0; +} + +void IRAM_ATTR +ping_now(void) +{ + portENTER_CRITICAL_ISR(&timer_mux); + do_ping = 1; + portEXIT_CRITICAL_ISR(&timer_mux); +} + +void +check_serial(void) +{ + /* check for serial data and write to rabbit */ + if (Serial.available()) { + uint8_t spkt; + + server.beginPacket(rabbit, 8080); + while (Serial.available()) { + spkt = Serial.read(); + server.write(spkt); + } + server.endPacket(); + } +} blob - /dev/null blob + a53fc68d2047241eb411a870cee0a6a0506cc17f (mode 644) --- /dev/null +++ Rabbit_Web_UI/Rabbit_Web_UI.ino @@ -0,0 +1,519 @@ +/* + * Copyright (c) 2021, 2022 Tracey Emery K7TLE + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * Watch the order of pins on the board! + * + * D14 - Red LED Power/AR #Solid/cw + * D12 - Green LED Transmitting Voice/cw/Off #Solid/Blink/Off + * D13 - Blue LED Transmitting #On during transmit + * + * D5 - Transmit optical relay + * D18 - Transmitter POWER relay + * D25 - Audio out + * D33 - Audio in + * D26 - Morse out + * + * # If we have enough memory leftover + * CLUB/R OFF # Power Transmitter Off + * CLUB/R ON # Power Transmitter On + * CLUB/R START # Start Transmitting Audio + * CLUB/R STOP # Stop Transmitting Audio + */ + +#include +#include + +#include +#include +#include +#include +#include + +#include "audio_call.h" +#include "html.h" + +#define DEBUG 0 +#define TIMER 0 /* save some power */ + +#define MAX_CLIENTS 8 + +#define RED_LED 14 +#define GREEN_LED 12 +#define BLUE_LED 13 + +#define TRANSMIT 5 +#define TRANSMIT_PWR 18 /* LOW - OFF, HIGH - ON (switch LOW - ON) */ +/* #define OPTIONAL 21 */ +#define TRANSMIT_DELAY 10 /* seconds */ +#define TRANSMIT_MIN 10 /* seconds */ +#define TRANSMIT_MAX 30 /* seconds */ + +#define ONE_SECOND 1000 + +#define MORSE_OUT 26 +#define AUDIO_OUT 25 +#define AUDIO_IN 33 + +#define DPRINTF(x,y) do { if (DEBUG) { Serial.println(x); \ + Serial2.println(x); sleep(y); }} while(0) + +#define WPM 15 + +/* Morse */ +Morse morse_led(M_GPIO, RED_LED, WPM); +Morse morse_dac(M_DAC, MORSE_OUT, WPM); + +String led_morse = "`ar`"; +String dac_morse = "de the k7mva rabbit"; + +/* local_ssid will be used for the web interface header */ +const char *local_ssid = "MVARC Rabbit 1"; +const char *local_pass = "MV@rc1234"; +IPAddress local_ip(10, 0, 50, 1); +IPAddress local_gw(10, 0, 50, 1); +IPAddress local_net(255, 255, 255, 0); + +AsyncWebServer server(80); +AsyncEventSource events("/event"); + +XT_Wav_Class Sound(audio); +XT_DAC_Audio_Class DacAudio(AUDIO_OUT, 0); + +void setup(void); +void loop(void); +void set_green(void); +void set_red(void); +void handle_transmission(void); + +String handle_connect(const String&); + +unsigned long transmit_start_millis, green_start_millis; +unsigned long tx_current_millis, countdown_timer_millis; +unsigned long countdown_millis, red_start_millis; + +int transmit_now = 0; /* don't delay first */ +int hunting = 0, playing = 0, play = 0, voice = 1; +int transmit_end = 0, powered = 1, rand_num = 1, cw = 1; +int send_handle_events = 0, transmit_new, alt_cw = 1; + +uint8_t channel = 3; + +void +setup() +{ + /* disable brownout for startup */ + WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); + delay(1000); + + /* immediate pin setup, transmitter shouldn't be on */ + pinMode(TRANSMIT, OUTPUT); + pinMode(TRANSMIT_PWR, OUTPUT); + digitalWrite(TRANSMIT, LOW); + digitalWrite(TRANSMIT_PWR, LOW); + +#ifdef DEBUG + /* setup serial */ + Serial.begin(115200); + Serial2.begin(115200); + sleep(1); +#endif + + DPRINTF("", 1); + DPRINTF("Setup serial", 0); + DPRINTF("Setup transmitter", 0); + + /* setup LEDs */ + pinMode(RED_LED, OUTPUT); + pinMode(GREEN_LED, OUTPUT); + pinMode(BLUE_LED, OUTPUT); + digitalWrite(RED_LED, LOW); + digitalWrite(GREEN_LED, LOW); + digitalWrite(BLUE_LED, LOW); + DPRINTF("Setup LEDs", 0); + + /* audio setup */ + pinMode(AUDIO_OUT, OUTPUT); + pinMode(AUDIO_IN, INPUT); + DPRINTF("Setup audio", 0); + /* DacAudio.DacVolume = 35; */ + + /* setup our AP */ + /* + * Had to disable these in sdkconfig.h and use simple WiFi to keep + * Android 10 connected. + * + * #define CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED 0 + * #define CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED 0 + */ + + /* WiFi.mode(WIFI_AP); */ + /* WiFi.softAP(local_ssid, local_pass); */ + + WiFi.mode(WIFI_AP); + WiFi.softAPConfig(local_ip, local_gw, local_net); + WiFi.setTxPower(WIFI_POWER_19_5dBm); + WiFi.softAP(local_ssid, local_pass, channel, false, MAX_CLIENTS); + + DPRINTF("Setup AP", 0); + + /* setup our web server */ + server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) { + request->send_P(200, "text/html", index_html, handle_connect); + }); + server.on("/update", HTTP_GET, [](AsyncWebServerRequest *request) { + String input_message; + + if (request->hasParam("hunting") && powered) { + DPRINTF("Hunting toggled", 0); + input_message = request->getParam("hunting")->value(); + hunting = input_message.toInt(); + transmit_start_millis = tx_current_millis; + if (hunting) + digitalWrite(GREEN_LED, HIGH); + else { + morse_led.gpio_tx_stop(); + morse_dac.dac_tx_stop(); + digitalWrite(GREEN_LED, LOW); + } + countdown_millis = millis(); + } + if (request->hasParam("power")) { + DPRINTF("Power toggled", 0); + input_message = request->getParam("power")->value(); + powered = input_message.toInt(); + if (!powered) { + morse_led.gpio_tx_stop(); + morse_dac.dac_tx_stop(); + digitalWrite(RED_LED, LOW); + digitalWrite(GREEN_LED, LOW); + } else { + digitalWrite(RED_LED, HIGH); + digitalWrite(GREEN_LED, LOW); + } + + } + if (request->hasParam("delay")) { + DPRINTF("Delay changed", 0); + input_message = request->getParam("delay")->value(); + if (input_message.toInt() >= TRANSMIT_MIN && + input_message.toInt() <= TRANSMIT_MAX) + transmit_new = input_message.toInt(); + } + if (request->hasParam("rand")) { + DPRINTF("Random delay toggled", 0); + input_message = request->getParam("rand")->value(); + rand_num = input_message.toInt(); + } + if (request->hasParam("altcw")) { + DPRINTF("Random cw toggled", 0); + input_message = request->getParam("altcw")->value(); + alt_cw = input_message.toInt(); + } + if (request->hasParam("cw")) { + digitalWrite(GREEN_LED, HIGH); + DPRINTF("CW toggled", 0); + input_message = request->getParam("cw")->value(); + cw = input_message.toInt(); + } + if (request->hasParam("trans_now")) { + DPRINTF("PTT pressed", 0); + input_message = request->getParam("trans_now")->value(); + transmit_now = 0; + } + + request->send_P(200, "text/plain", "OK"); + }); + server.addHandler(&events); + server.begin(); + DPRINTF("Setup web server", 0); + + /* turning on the tranmitter is the final step */ + digitalWrite(TRANSMIT_PWR, HIGH); + digitalWrite(RED_LED, HIGH); + DPRINTF("", 0); + DPRINTF("Transmitter powered on", 1); + DPRINTF("", 0); + DPRINTF("The rabbit is ready to run!", 0); + DPRINTF("", 0); + + /* setup millis timers */ + transmit_start_millis = millis(); + green_start_millis = millis(); + red_start_millis = millis(); + + /* re-enable brownout */ + delay(1000); + WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 1); +} + +void +loop() +{ + tx_current_millis = millis(); + + if (cw) + playing = morse_dac.dac_transmitting(); + else + playing = Sound.Playing; + + handle_transmission(); + + if (hunting && powered) + set_green(); + + if (!powered) { + set_red(); + digitalWrite(TRANSMIT_PWR, LOW); + } + + if (powered) + digitalWrite(TRANSMIT_PWR, HIGH); +} + +void +handle_transmission(void) +{ + if (hunting && !play && !playing && transmit_now > 0 && powered && + tx_current_millis - countdown_timer_millis >= ONE_SECOND && + TIMER) { + events.send(String((transmit_now - (millis() - + countdown_millis)) / 1000).c_str(), "count", millis()); + countdown_timer_millis = tx_current_millis; + } + + if (cw) + morse_dac.dac_watchdog(); + else + DacAudio.FillBuffer(); + + if (hunting && !play && !playing && powered && + (tx_current_millis - transmit_start_millis >= transmit_now)) { + digitalWrite(BLUE_LED, HIGH); + digitalWrite(TRANSMIT, HIGH); + DPRINTF("Transmitting", 0); + transmit_start_millis = tx_current_millis; + events.send("disable", "tnbutton", millis()); + events.send("disable", "cwbox", millis()); + events.send("disable", "altcwbox", millis()); + if (TIMER) + events.send("TX", "count", millis()); + if (rand_num) { + transmit_now = random(TRANSMIT_MIN, + TRANSMIT_MAX) * ONE_SECOND; + events.send(String(transmit_now / ONE_SECOND).c_str(), + "rand", millis()); + } else { + /* setup our transmit delay now */ + if (transmit_new) + transmit_now = transmit_new * ONE_SECOND; + else + transmit_now = TRANSMIT_DELAY * ONE_SECOND; + events.send(String(transmit_now / ONE_SECOND).c_str(), + "rand", millis()); + } + play = 1; + } + + if (hunting && play && !playing && !cw) { + if (tx_current_millis - transmit_start_millis >= ONE_SECOND) { + DPRINTF("Play audio", 0); + DacAudio.Play(&Sound); + play = 0; + transmit_end = 1; + } + } else if (hunting && play && !playing && cw) { + if (tx_current_millis - transmit_start_millis >= ONE_SECOND) { + DPRINTF("Send CW", 0); + morse_dac.dac_tx(dac_morse); + play = 0; + transmit_end = 1; + } + } + + if (transmit_end && playing) { + transmit_start_millis = tx_current_millis; + countdown_timer_millis = tx_current_millis; + countdown_millis = tx_current_millis; + transmit_end = 2; + } + + if (!playing && transmit_end == 2) { + if (tx_current_millis - transmit_start_millis >= ONE_SECOND) { + events.send("enable", "tnbutton", millis()); + events.send("enable", "altcwbox", millis()); + if (!alt_cw) + events.send("enable", "cwbox", millis()); + else + cw = !cw; + DPRINTF("End transmission", 0); + DPRINTF("", 0); + digitalWrite(BLUE_LED, LOW); + digitalWrite(TRANSMIT, LOW); + transmit_start_millis = tx_current_millis; + playing = 0; + transmit_end = 0; + } + } +} + +String +handle_connect(const String& var) +{ + int power = digitalRead(TRANSMIT_PWR); + + String button1 = "