Labouest/bouton_ouverture_V2
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Compare commits

base: Labouest:master
Branches Tags
Labouest:master
Labouest:feat/main-algo-2
Labouest:feat/main-algo
Labouest:fix/OKblink
Labouest:feat/correction-libLed
Labouest:main-code
Labouest:feat--add-ntp-support
Labouest:add--led-lib
Labouest:feat--discord-call-api
Labouest:V2.0.0
..
compare: Labouest:feat--discord-call-api
Branches Tags
Labouest:master
Labouest:feat/main-algo-2
Labouest:feat/main-algo
Labouest:fix/OKblink
Labouest:feat/correction-libLed
Labouest:main-code
Labouest:feat--add-ntp-support
Labouest:add--led-lib
Labouest:feat--discord-call-api
Labouest:V2.0.0

No commits in common. "master" and "feat--discord-call-api" have entirely different histories.
master ... feat--disc

24 changed files with 9 additions and 2219 deletions
Show Stats Expand all files Collapse all files

8
.vscode/settings.json vendored
View File

@ -1,8 +0,0 @@
{
"cmake.configureOnOpen": true,
"files.associations": {
"*.html": "html",
"atomic": "cpp",
"cstdint": "cpp"
}
}

9
config.ini
View File

@ -19,12 +19,3 @@ build_flags =
-D EXAMPLE_STRING=\"Pouet\" -D EXAMPLE_STRING=\"Pouet\"
-D DEBUG -D DEBUG
-D ENCODER_SWITCH=D5
-D ENCODER_DT=D6
-D ENCODER_CLK=D7
-D PIXEL_PIN=4
-D PIXEL_COUNT=24
-D RESET_TIME=60000

1
docs/.gitignore vendored
View File

@ -1 +0,0 @@
output

45
include/Program.h
View File

@ -3,19 +3,9 @@
#include <Arduino.h> #include <Arduino.h>
#include <ESP8266WiFi.h> #include <ESP8266WiFi.h>
#include <NTPClient.h>
#include <WiFiUdp.h>
#include "DiscordAPI.h" #include "DiscordAPI.h"
#include "SwitchableEncodeur.h"
#include "LedLib.h"
enum MainMenu{
INITIAL_STATE,
GET_START_HOUR,
SELECT_END_HOUR,
SEND_TO_DISCORD
};
class Program { class Program {
public: public:
@ -28,42 +18,9 @@ public:
* Program main loop * Program main loop
*/ */
void loop(); void loop();
private: private:
/**
* Encoder object
*/
SwitchableEncodeur* encoder;
/**
* Old encoder position
*/
long oldPosition;
DiscordAPI* discord; DiscordAPI* discord;
LedLib* ledLib;
WiFiUDP* ntpUDP;
NTPClient* timeClient;
/**
* @brief Send time to discord
* the start time is automaticly set to the current time
* @param[in] timeEnd LabOuest closing time
*/
void sendTime(String timeEnd);
//state of the button
MainMenu menu;
//temps de reset in ms
ulong resetMillis;
//numéro de led de dépard
int nLedStart;
// apres midi
bool pm;
}; };
#endif #endif

1
lib/Encoder/.piopm
View File

@ -1 +0,0 @@
{"type": "library", "name": "Encoder", "version": "1.4.2", "spec": {"owner": "paulstoffregen", "id": 129, "name": "Encoder", "requirements": null, "uri": null}}

10
lib/Encoder/Encoder.cpp
View File

@ -1,10 +0,0 @@
#include "Encoder.h"
// Yes, all the code is in the header file, to provide the user
// configure options with #define (before they include it), and
// to facilitate some crafty optimizations!
Encoder_internal_state_t * Encoder::interruptArgs[];

969
lib/Encoder/Encoder.h
View File

@ -1,969 +0,0 @@
/* Encoder Library, for measuring quadrature encoded signals
* http://www.pjrc.com/teensy/td_libs_Encoder.html
* Copyright (c) 2011,2013 PJRC.COM, LLC - Paul Stoffregen <paul@pjrc.com>
*
* Version 1.2 - fix -2 bug in C-only code
* Version 1.1 - expand to support boards with up to 60 interrupts
* Version 1.0 - initial release
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef Encoder_h_
#define Encoder_h_
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#elif defined(WIRING)
#include "Wiring.h"
#else
#include "WProgram.h"
#include "pins_arduino.h"
#endif
#include "utility/direct_pin_read.h"
#if defined(ENCODER_USE_INTERRUPTS) || !defined(ENCODER_DO_NOT_USE_INTERRUPTS)
#define ENCODER_USE_INTERRUPTS
#define ENCODER_ARGLIST_SIZE CORE_NUM_INTERRUPT
#include "utility/interrupt_pins.h"
#ifdef ENCODER_OPTIMIZE_INTERRUPTS
#include "utility/interrupt_config.h"
#endif
#else
#define ENCODER_ARGLIST_SIZE 0
#endif
// All the data needed by interrupts is consolidated into this ugly struct
// to facilitate assembly language optimizing of the speed critical update.
// The assembly code uses auto-incrementing addressing modes, so the struct
// must remain in exactly this order.
typedef struct {
volatile IO_REG_TYPE * pin1_register;
volatile IO_REG_TYPE * pin2_register;
IO_REG_TYPE pin1_bitmask;
IO_REG_TYPE pin2_bitmask;
uint8_t state;
int32_t position;
} Encoder_internal_state_t;
class Encoder
{
public:
Encoder(uint8_t pin1, uint8_t pin2) {
#ifdef INPUT_PULLUP
pinMode(pin1, INPUT_PULLUP);
pinMode(pin2, INPUT_PULLUP);
#else
pinMode(pin1, INPUT);
digitalWrite(pin1, HIGH);
pinMode(pin2, INPUT);
digitalWrite(pin2, HIGH);
#endif
encoder.pin1_register = PIN_TO_BASEREG(pin1);
encoder.pin1_bitmask = PIN_TO_BITMASK(pin1);
encoder.pin2_register = PIN_TO_BASEREG(pin2);
encoder.pin2_bitmask = PIN_TO_BITMASK(pin2);
encoder.position = 0;
// allow time for a passive R-C filter to charge
// through the pullup resistors, before reading
// the initial state
delayMicroseconds(2000);
uint8_t s = 0;
if (DIRECT_PIN_READ(encoder.pin1_register, encoder.pin1_bitmask)) s |= 1;
if (DIRECT_PIN_READ(encoder.pin2_register, encoder.pin2_bitmask)) s |= 2;
encoder.state = s;
#ifdef ENCODER_USE_INTERRUPTS
interrupts_in_use = attach_interrupt(pin1, &encoder);
interrupts_in_use += attach_interrupt(pin2, &encoder);
#endif
//update_finishup(); // to force linker to include the code (does not work)
}
#ifdef ENCODER_USE_INTERRUPTS
inline int32_t read() {
if (interrupts_in_use < 2) {
noInterrupts();
update(&encoder);
} else {
noInterrupts();
}
int32_t ret = encoder.position;
interrupts();
return ret;
}
inline int32_t readAndReset() {
if (interrupts_in_use < 2) {
noInterrupts();
update(&encoder);
} else {
noInterrupts();
}
int32_t ret = encoder.position;
encoder.position = 0;
interrupts();
return ret;
}
inline void write(int32_t p) {
noInterrupts();
encoder.position = p;
interrupts();
}
#else
inline int32_t read() {
update(&encoder);
return encoder.position;
}
inline int32_t readAndReset() {
update(&encoder);
int32_t ret = encoder.position;
encoder.position = 0;
return ret;
}
inline void write(int32_t p) {
encoder.position = p;
}
#endif
private:
Encoder_internal_state_t encoder;
#ifdef ENCODER_USE_INTERRUPTS
uint8_t interrupts_in_use;
#endif
public:
static Encoder_internal_state_t * interruptArgs[ENCODER_ARGLIST_SIZE];
// _______ _______
// Pin1 ______| |_______| |______ Pin1
// negative <--- _______ _______ __ --> positive
// Pin2 __| |_______| |_______| Pin2
// new new old old
// pin2 pin1 pin2 pin1 Result
// ---- ---- ---- ---- ------
// 0 0 0 0 no movement
// 0 0 0 1 +1
// 0 0 1 0 -1
// 0 0 1 1 +2 (assume pin1 edges only)
// 0 1 0 0 -1
// 0 1 0 1 no movement
// 0 1 1 0 -2 (assume pin1 edges only)
// 0 1 1 1 +1
// 1 0 0 0 +1
// 1 0 0 1 -2 (assume pin1 edges only)
// 1 0 1 0 no movement
// 1 0 1 1 -1
// 1 1 0 0 +2 (assume pin1 edges only)
// 1 1 0 1 -1
// 1 1 1 0 +1
// 1 1 1 1 no movement
/*
// Simple, easy-to-read "documentation" version :-)
//
void update(void) {
uint8_t s = state & 3;
if (digitalRead(pin1)) s |= 4;
if (digitalRead(pin2)) s |= 8;
switch (s) {
case 0: case 5: case 10: case 15:
break;
case 1: case 7: case 8: case 14:
position++; break;
case 2: case 4: case 11: case 13:
position--; break;
case 3: case 12:
position += 2; break;
default:
position -= 2; break;
}
state = (s >> 2);
}
*/
public:
// update() is not meant to be called from outside Encoder,
// but it is public to allow static interrupt routines.
// DO NOT call update() directly from sketches.
static void update(Encoder_internal_state_t *arg) {
#if defined(__AVR__)
// The compiler believes this is just 1 line of code, so
// it will inline this function into each interrupt
// handler. That's a tiny bit faster, but grows the code.
// Especially when used with ENCODER_OPTIMIZE_INTERRUPTS,
// the inline nature allows the ISR prologue and epilogue
// to only save/restore necessary registers, for very nice
// speed increase.
asm volatile (
"ld r30, X+" "\n\t"
"ld r31, X+" "\n\t"
"ld r24, Z" "\n\t" // r24 = pin1 input
"ld r30, X+" "\n\t"
"ld r31, X+" "\n\t"
"ld r25, Z" "\n\t" // r25 = pin2 input
"ld r30, X+" "\n\t" // r30 = pin1 mask
"ld r31, X+" "\n\t" // r31 = pin2 mask
"ld r22, X" "\n\t" // r22 = state
"andi r22, 3" "\n\t"
"and r24, r30" "\n\t"
"breq L%=1" "\n\t" // if (pin1)
"ori r22, 4" "\n\t" // state |= 4
"L%=1:" "and r25, r31" "\n\t"
"breq L%=2" "\n\t" // if (pin2)
"ori r22, 8" "\n\t" // state |= 8
"L%=2:" "ldi r30, lo8(pm(L%=table))" "\n\t"
"ldi r31, hi8(pm(L%=table))" "\n\t"
"add r30, r22" "\n\t"
"adc r31, __zero_reg__" "\n\t"
"asr r22" "\n\t"
"asr r22" "\n\t"
"st X+, r22" "\n\t" // store new state
"ld r22, X+" "\n\t"
"ld r23, X+" "\n\t"
"ld r24, X+" "\n\t"
"ld r25, X+" "\n\t"
"ijmp" "\n\t" // jumps to update_finishup()
// TODO move this table to another static function,
// so it doesn't get needlessly duplicated. Easier
// said than done, due to linker issues and inlining
"L%=table:" "\n\t"
"rjmp L%=end" "\n\t" // 0
"rjmp L%=plus1" "\n\t" // 1
"rjmp L%=minus1" "\n\t" // 2
"rjmp L%=plus2" "\n\t" // 3
"rjmp L%=minus1" "\n\t" // 4
"rjmp L%=end" "\n\t" // 5
"rjmp L%=minus2" "\n\t" // 6
"rjmp L%=plus1" "\n\t" // 7
"rjmp L%=plus1" "\n\t" // 8
"rjmp L%=minus2" "\n\t" // 9
"rjmp L%=end" "\n\t" // 10
"rjmp L%=minus1" "\n\t" // 11
"rjmp L%=plus2" "\n\t" // 12
"rjmp L%=minus1" "\n\t" // 13
"rjmp L%=plus1" "\n\t" // 14
"rjmp L%=end" "\n\t" // 15
"L%=minus2:" "\n\t"
"subi r22, 2" "\n\t"
"sbci r23, 0" "\n\t"
"sbci r24, 0" "\n\t"
"sbci r25, 0" "\n\t"
"rjmp L%=store" "\n\t"
"L%=minus1:" "\n\t"
"subi r22, 1" "\n\t"
"sbci r23, 0" "\n\t"
"sbci r24, 0" "\n\t"
"sbci r25, 0" "\n\t"
"rjmp L%=store" "\n\t"
"L%=plus2:" "\n\t"
"subi r22, 254" "\n\t"
"rjmp L%=z" "\n\t"
"L%=plus1:" "\n\t"
"subi r22, 255" "\n\t"
"L%=z:" "sbci r23, 255" "\n\t"
"sbci r24, 255" "\n\t"
"sbci r25, 255" "\n\t"
"L%=store:" "\n\t"
"st -X, r25" "\n\t"
"st -X, r24" "\n\t"
"st -X, r23" "\n\t"
"st -X, r22" "\n\t"
"L%=end:" "\n"
: : "x" (arg) : "r22", "r23", "r24", "r25", "r30", "r31");
#else
uint8_t p1val = DIRECT_PIN_READ(arg->pin1_register, arg->pin1_bitmask);
uint8_t p2val = DIRECT_PIN_READ(arg->pin2_register, arg->pin2_bitmask);
uint8_t state = arg->state & 3;
if (p1val) state |= 4;
if (p2val) state |= 8;
arg->state = (state >> 2);
switch (state) {
case 1: case 7: case 8: case 14:
arg->position++;
return;
case 2: case 4: case 11: case 13:
arg->position--;
return;
case 3: case 12:
arg->position += 2;
return;
case 6: case 9:
arg->position -= 2;
return;
}
#endif
}
private:
/*
#if defined(__AVR__)
// TODO: this must be a no inline function
// even noinline does not seem to solve difficult
// problems with this. Oh well, it was only meant
// to shrink code size - there's no performance
// improvement in this, only code size reduction.
__attribute__((noinline)) void update_finishup(void) {
asm volatile (
"ldi r30, lo8(pm(Ltable))" "\n\t"
"ldi r31, hi8(pm(Ltable))" "\n\t"
"Ltable:" "\n\t"
"rjmp L%=end" "\n\t" // 0
"rjmp L%=plus1" "\n\t" // 1
"rjmp L%=minus1" "\n\t" // 2
"rjmp L%=plus2" "\n\t" // 3
"rjmp L%=minus1" "\n\t" // 4
"rjmp L%=end" "\n\t" // 5
"rjmp L%=minus2" "\n\t" // 6
"rjmp L%=plus1" "\n\t" // 7
"rjmp L%=plus1" "\n\t" // 8
"rjmp L%=minus2" "\n\t" // 9
"rjmp L%=end" "\n\t" // 10
"rjmp L%=minus1" "\n\t" // 11
"rjmp L%=plus2" "\n\t" // 12
"rjmp L%=minus1" "\n\t" // 13
"rjmp L%=plus1" "\n\t" // 14
"rjmp L%=end" "\n\t" // 15
"L%=minus2:" "\n\t"
"subi r22, 2" "\n\t"
"sbci r23, 0" "\n\t"
"sbci r24, 0" "\n\t"
"sbci r25, 0" "\n\t"
"rjmp L%=store" "\n\t"
"L%=minus1:" "\n\t"
"subi r22, 1" "\n\t"
"sbci r23, 0" "\n\t"
"sbci r24, 0" "\n\t"
"sbci r25, 0" "\n\t"
"rjmp L%=store" "\n\t"
"L%=plus2:" "\n\t"
"subi r22, 254" "\n\t"
"rjmp L%=z" "\n\t"
"L%=plus1:" "\n\t"
"subi r22, 255" "\n\t"
"L%=z:" "sbci r23, 255" "\n\t"
"sbci r24, 255" "\n\t"
"sbci r25, 255" "\n\t"
"L%=store:" "\n\t"
"st -X, r25" "\n\t"
"st -X, r24" "\n\t"
"st -X, r23" "\n\t"
"st -X, r22" "\n\t"
"L%=end:" "\n"
: : : "r22", "r23", "r24", "r25", "r30", "r31");
}
#endif
*/
#ifdef ENCODER_USE_INTERRUPTS
// this giant function is an unfortunate consequence of Arduino's
// attachInterrupt function not supporting any way to pass a pointer
// or other context to the attached function.
static uint8_t attach_interrupt(uint8_t pin, Encoder_internal_state_t *state) {
switch (pin) {
#ifdef CORE_INT0_PIN
case CORE_INT0_PIN:
interruptArgs[0] = state;
attachInterrupt(0, isr0, CHANGE);
break;
#endif
#ifdef CORE_INT1_PIN
case CORE_INT1_PIN:
interruptArgs[1] = state;
attachInterrupt(1, isr1, CHANGE);
break;
#endif
#ifdef CORE_INT2_PIN
case CORE_INT2_PIN:
interruptArgs[2] = state;
attachInterrupt(2, isr2, CHANGE);
break;
#endif
#ifdef CORE_INT3_PIN
case CORE_INT3_PIN:
interruptArgs[3] = state;
attachInterrupt(3, isr3, CHANGE);
break;
#endif
#ifdef CORE_INT4_PIN
case CORE_INT4_PIN:
interruptArgs[4] = state;
attachInterrupt(4, isr4, CHANGE);
break;
#endif
#ifdef CORE_INT5_PIN
case CORE_INT5_PIN:
interruptArgs[5] = state;
attachInterrupt(5, isr5, CHANGE);
break;
#endif
#ifdef CORE_INT6_PIN
case CORE_INT6_PIN:
interruptArgs[6] = state;
attachInterrupt(6, isr6, CHANGE);
break;
#endif
#ifdef CORE_INT7_PIN
case CORE_INT7_PIN:
interruptArgs[7] = state;
attachInterrupt(7, isr7, CHANGE);
break;
#endif
#ifdef CORE_INT8_PIN
case CORE_INT8_PIN:
interruptArgs[8] = state;
attachInterrupt(8, isr8, CHANGE);
break;
#endif
#ifdef CORE_INT9_PIN
case CORE_INT9_PIN:
interruptArgs[9] = state;
attachInterrupt(9, isr9, CHANGE);
break;
#endif
#ifdef CORE_INT10_PIN
case CORE_INT10_PIN:
interruptArgs[10] = state;
attachInterrupt(10, isr10, CHANGE);
break;
#endif
#ifdef CORE_INT11_PIN
case CORE_INT11_PIN:
interruptArgs[11] = state;
attachInterrupt(11, isr11, CHANGE);
break;
#endif
#ifdef CORE_INT12_PIN
case CORE_INT12_PIN:
interruptArgs[12] = state;
attachInterrupt(12, isr12, CHANGE);
break;
#endif
#ifdef CORE_INT13_PIN
case CORE_INT13_PIN:
interruptArgs[13] = state;
attachInterrupt(13, isr13, CHANGE);
break;
#endif
#ifdef CORE_INT14_PIN
case CORE_INT14_PIN:
interruptArgs[14] = state;
attachInterrupt(14, isr14, CHANGE);
break;
#endif
#ifdef CORE_INT15_PIN
case CORE_INT15_PIN:
interruptArgs[15] = state;
attachInterrupt(15, isr15, CHANGE);
break;
#endif
#ifdef CORE_INT16_PIN
case CORE_INT16_PIN:
interruptArgs[16] = state;
attachInterrupt(16, isr16, CHANGE);
break;
#endif
#ifdef CORE_INT17_PIN
case CORE_INT17_PIN:
interruptArgs[17] = state;
attachInterrupt(17, isr17, CHANGE);
break;
#endif
#ifdef CORE_INT18_PIN
case CORE_INT18_PIN:
interruptArgs[18] = state;
attachInterrupt(18, isr18, CHANGE);
break;
#endif
#ifdef CORE_INT19_PIN
case CORE_INT19_PIN:
interruptArgs[19] = state;
attachInterrupt(19, isr19, CHANGE);
break;
#endif
#ifdef CORE_INT20_PIN
case CORE_INT20_PIN:
interruptArgs[20] = state;
attachInterrupt(20, isr20, CHANGE);
break;
#endif
#ifdef CORE_INT21_PIN
case CORE_INT21_PIN:
interruptArgs[21] = state;
attachInterrupt(21, isr21, CHANGE);
break;
#endif
#ifdef CORE_INT22_PIN
case CORE_INT22_PIN:
interruptArgs[22] = state;
attachInterrupt(22, isr22, CHANGE);
break;
#endif
#ifdef CORE_INT23_PIN
case CORE_INT23_PIN:
interruptArgs[23] = state;
attachInterrupt(23, isr23, CHANGE);
break;
#endif
#ifdef CORE_INT24_PIN
case CORE_INT24_PIN:
interruptArgs[24] = state;
attachInterrupt(24, isr24, CHANGE);
break;
#endif
#ifdef CORE_INT25_PIN
case CORE_INT25_PIN:
interruptArgs[25] = state;
attachInterrupt(25, isr25, CHANGE);
break;
#endif
#ifdef CORE_INT26_PIN
case CORE_INT26_PIN:
interruptArgs[26] = state;
attachInterrupt(26, isr26, CHANGE);
break;
#endif
#ifdef CORE_INT27_PIN
case CORE_INT27_PIN:
interruptArgs[27] = state;
attachInterrupt(27, isr27, CHANGE);
break;
#endif
#ifdef CORE_INT28_PIN
case CORE_INT28_PIN:
interruptArgs[28] = state;
attachInterrupt(28, isr28, CHANGE);
break;
#endif
#ifdef CORE_INT29_PIN
case CORE_INT29_PIN:
interruptArgs[29] = state;
attachInterrupt(29, isr29, CHANGE);
break;
#endif
#ifdef CORE_INT30_PIN
case CORE_INT30_PIN:
interruptArgs[30] = state;
attachInterrupt(30, isr30, CHANGE);
break;
#endif
#ifdef CORE_INT31_PIN
case CORE_INT31_PIN:
interruptArgs[31] = state;
attachInterrupt(31, isr31, CHANGE);
break;
#endif
#ifdef CORE_INT32_PIN
case CORE_INT32_PIN:
interruptArgs[32] = state;
attachInterrupt(32, isr32, CHANGE);
break;
#endif
#ifdef CORE_INT33_PIN
case CORE_INT33_PIN:
interruptArgs[33] = state;
attachInterrupt(33, isr33, CHANGE);
break;
#endif
#ifdef CORE_INT34_PIN
case CORE_INT34_PIN:
interruptArgs[34] = state;
attachInterrupt(34, isr34, CHANGE);
break;
#endif
#ifdef CORE_INT35_PIN
case CORE_INT35_PIN:
interruptArgs[35] = state;
attachInterrupt(35, isr35, CHANGE);
break;
#endif
#ifdef CORE_INT36_PIN
case CORE_INT36_PIN:
interruptArgs[36] = state;
attachInterrupt(36, isr36, CHANGE);
break;
#endif
#ifdef CORE_INT37_PIN
case CORE_INT37_PIN:
interruptArgs[37] = state;
attachInterrupt(37, isr37, CHANGE);
break;
#endif
#ifdef CORE_INT38_PIN
case CORE_INT38_PIN:
interruptArgs[38] = state;
attachInterrupt(38, isr38, CHANGE);
break;
#endif
#ifdef CORE_INT39_PIN
case CORE_INT39_PIN:
interruptArgs[39] = state;
attachInterrupt(39, isr39, CHANGE);
break;
#endif
#ifdef CORE_INT40_PIN
case CORE_INT40_PIN:
interruptArgs[40] = state;
attachInterrupt(40, isr40, CHANGE);
break;
#endif
#ifdef CORE_INT41_PIN
case CORE_INT41_PIN:
interruptArgs[41] = state;
attachInterrupt(41, isr41, CHANGE);
break;
#endif
#ifdef CORE_INT42_PIN
case CORE_INT42_PIN:
interruptArgs[42] = state;
attachInterrupt(42, isr42, CHANGE);
break;
#endif
#ifdef CORE_INT43_PIN
case CORE_INT43_PIN:
interruptArgs[43] = state;
attachInterrupt(43, isr43, CHANGE);
break;
#endif
#ifdef CORE_INT44_PIN
case CORE_INT44_PIN:
interruptArgs[44] = state;
attachInterrupt(44, isr44, CHANGE);
break;
#endif
#ifdef CORE_INT45_PIN
case CORE_INT45_PIN:
interruptArgs[45] = state;
attachInterrupt(45, isr45, CHANGE);
break;
#endif
#ifdef CORE_INT46_PIN
case CORE_INT46_PIN:
interruptArgs[46] = state;
attachInterrupt(46, isr46, CHANGE);
break;
#endif
#ifdef CORE_INT47_PIN
case CORE_INT47_PIN:
interruptArgs[47] = state;
attachInterrupt(47, isr47, CHANGE);
break;
#endif
#ifdef CORE_INT48_PIN
case CORE_INT48_PIN:
interruptArgs[48] = state;
attachInterrupt(48, isr48, CHANGE);
break;
#endif
#ifdef CORE_INT49_PIN
case CORE_INT49_PIN:
interruptArgs[49] = state;
attachInterrupt(49, isr49, CHANGE);
break;
#endif
#ifdef CORE_INT50_PIN
case CORE_INT50_PIN:
interruptArgs[50] = state;
attachInterrupt(50, isr50, CHANGE);
break;
#endif
#ifdef CORE_INT51_PIN
case CORE_INT51_PIN:
interruptArgs[51] = state;
attachInterrupt(51, isr51, CHANGE);
break;
#endif
#ifdef CORE_INT52_PIN
case CORE_INT52_PIN:
interruptArgs[52] = state;
attachInterrupt(52, isr52, CHANGE);
break;
#endif
#ifdef CORE_INT53_PIN
case CORE_INT53_PIN:
interruptArgs[53] = state;
attachInterrupt(53, isr53, CHANGE);
break;
#endif
#ifdef CORE_INT54_PIN
case CORE_INT54_PIN:
interruptArgs[54] = state;
attachInterrupt(54, isr54, CHANGE);
break;
#endif
#ifdef CORE_INT55_PIN
case CORE_INT55_PIN:
interruptArgs[55] = state;
attachInterrupt(55, isr55, CHANGE);
break;
#endif
#ifdef CORE_INT56_PIN
case CORE_INT56_PIN:
interruptArgs[56] = state;
attachInterrupt(56, isr56, CHANGE);
break;
#endif
#ifdef CORE_INT57_PIN
case CORE_INT57_PIN:
interruptArgs[57] = state;
attachInterrupt(57, isr57, CHANGE);
break;
#endif
#ifdef CORE_INT58_PIN
case CORE_INT58_PIN:
interruptArgs[58] = state;
attachInterrupt(58, isr58, CHANGE);
break;
#endif
#ifdef CORE_INT59_PIN
case CORE_INT59_PIN:
interruptArgs[59] = state;
attachInterrupt(59, isr59, CHANGE);
break;
#endif
default:
return 0;
}
return 1;
}
#endif // ENCODER_USE_INTERRUPTS
#if defined(ENCODER_USE_INTERRUPTS) && !defined(ENCODER_OPTIMIZE_INTERRUPTS)
#ifdef CORE_INT0_PIN
static void IRAM_ATTR isr0(void) { update(interruptArgs[0]); }
#endif
#ifdef CORE_INT1_PIN
static void IRAM_ATTR isr1(void) { update(interruptArgs[1]); }
#endif
#ifdef CORE_INT2_PIN
static void IRAM_ATTR isr2(void) { update(interruptArgs[2]); }
#endif
#ifdef CORE_INT3_PIN
static void IRAM_ATTR isr3(void) { update(interruptArgs[3]); }
#endif
#ifdef CORE_INT4_PIN
static void IRAM_ATTR isr4(void) { update(interruptArgs[4]); }
#endif
#ifdef CORE_INT5_PIN
static void IRAM_ATTR isr5(void) { update(interruptArgs[5]); }
#endif
#ifdef CORE_INT6_PIN
static void IRAM_ATTR isr6(void) { update(interruptArgs[6]); }
#endif
#ifdef CORE_INT7_PIN
static void IRAM_ATTR isr7(void) { update(interruptArgs[7]); }
#endif
#ifdef CORE_INT8_PIN
static void IRAM_ATTR isr8(void) { update(interruptArgs[8]); }
#endif
#ifdef CORE_INT9_PIN
static void IRAM_ATTR isr9(void) { update(interruptArgs[9]); }
#endif
#ifdef CORE_INT10_PIN
static void IRAM_ATTR isr10(void) { update(interruptArgs[10]); }
#endif
#ifdef CORE_INT11_PIN
static void IRAM_ATTR isr11(void) { update(interruptArgs[11]); }
#endif
#ifdef CORE_INT12_PIN
static void IRAM_ATTR isr12(void) { update(interruptArgs[12]); }
#endif
#ifdef CORE_INT13_PIN
static void IRAM_ATTR isr13(void) { update(interruptArgs[13]); }
#endif
#ifdef CORE_INT14_PIN
static void IRAM_ATTR isr14(void) { update(interruptArgs[14]); }
#endif
#ifdef CORE_INT15_PIN
static void IRAM_ATTR isr15(void) { update(interruptArgs[15]); }
#endif
#ifdef CORE_INT16_PIN
static void IRAM_ATTR isr16(void) { update(interruptArgs[16]); }
#endif
#ifdef CORE_INT17_PIN
static void IRAM_ATTR isr17(void) { update(interruptArgs[17]); }
#endif
#ifdef CORE_INT18_PIN
static void IRAM_ATTR isr18(void) { update(interruptArgs[18]); }
#endif
#ifdef CORE_INT19_PIN
static void IRAM_ATTR isr19(void) { update(interruptArgs[19]); }
#endif
#ifdef CORE_INT20_PIN
static void IRAM_ATTR isr20(void) { update(interruptArgs[20]); }
#endif
#ifdef CORE_INT21_PIN
static void IRAM_ATTR isr21(void) { update(interruptArgs[21]); }
#endif
#ifdef CORE_INT22_PIN
static void IRAM_ATTR isr22(void) { update(interruptArgs[22]); }
#endif
#ifdef CORE_INT23_PIN
static void IRAM_ATTR isr23(void) { update(interruptArgs[23]); }
#endif
#ifdef CORE_INT24_PIN
static void IRAM_ATTR isr24(void) { update(interruptArgs[24]); }
#endif
#ifdef CORE_INT25_PIN
static void IRAM_ATTR isr25(void) { update(interruptArgs[25]); }
#endif
#ifdef CORE_INT26_PIN
static void IRAM_ATTR isr26(void) { update(interruptArgs[26]); }
#endif
#ifdef CORE_INT27_PIN
static void IRAM_ATTR isr27(void) { update(interruptArgs[27]); }
#endif
#ifdef CORE_INT28_PIN
static void IRAM_ATTR isr28(void) { update(interruptArgs[28]); }
#endif
#ifdef CORE_INT29_PIN
static void IRAM_ATTR isr29(void) { update(interruptArgs[29]); }
#endif
#ifdef CORE_INT30_PIN
static void IRAM_ATTR isr30(void) { update(interruptArgs[30]); }
#endif
#ifdef CORE_INT31_PIN
static void IRAM_ATTR isr31(void) { update(interruptArgs[31]); }
#endif
#ifdef CORE_INT32_PIN
static void IRAM_ATTR isr32(void) { update(interruptArgs[32]); }
#endif
#ifdef CORE_INT33_PIN
static void IRAM_ATTR isr33(void) { update(interruptArgs[33]); }
#endif
#ifdef CORE_INT34_PIN
static void IRAM_ATTR isr34(void) { update(interruptArgs[34]); }
#endif
#ifdef CORE_INT35_PIN
static void IRAM_ATTR isr35(void) { update(interruptArgs[35]); }
#endif
#ifdef CORE_INT36_PIN
static void IRAM_ATTR isr36(void) { update(interruptArgs[36]); }
#endif
#ifdef CORE_INT37_PIN
static void IRAM_ATTR isr37(void) { update(interruptArgs[37]); }
#endif
#ifdef CORE_INT38_PIN
static void IRAM_ATTR isr38(void) { update(interruptArgs[38]); }
#endif
#ifdef CORE_INT39_PIN
static void IRAM_ATTR isr39(void) { update(interruptArgs[39]); }
#endif
#ifdef CORE_INT40_PIN
static void IRAM_ATTR isr40(void) { update(interruptArgs[40]); }
#endif
#ifdef CORE_INT41_PIN
static void IRAM_ATTR isr41(void) { update(interruptArgs[41]); }
#endif
#ifdef CORE_INT42_PIN
static void IRAM_ATTR isr42(void) { update(interruptArgs[42]); }
#endif
#ifdef CORE_INT43_PIN
static void IRAM_ATTR isr43(void) { update(interruptArgs[43]); }
#endif
#ifdef CORE_INT44_PIN
static void IRAM_ATTR isr44(void) { update(interruptArgs[44]); }
#endif
#ifdef CORE_INT45_PIN
static void IRAM_ATTR isr45(void) { update(interruptArgs[45]); }
#endif
#ifdef CORE_INT46_PIN
static void IRAM_ATTR isr46(void) { update(interruptArgs[46]); }
#endif
#ifdef CORE_INT47_PIN
static void IRAM_ATTR isr47(void) { update(interruptArgs[47]); }
#endif
#ifdef CORE_INT48_PIN
static void IRAM_ATTR isr48(void) { update(interruptArgs[48]); }
#endif
#ifdef CORE_INT49_PIN
static void IRAM_ATTR isr49(void) { update(interruptArgs[49]); }
#endif
#ifdef CORE_INT50_PIN
static void IRAM_ATTR isr50(void) { update(interruptArgs[50]); }
#endif
#ifdef CORE_INT51_PIN
static void IRAM_ATTR isr51(void) { update(interruptArgs[51]); }
#endif
#ifdef CORE_INT52_PIN
static void IRAM_ATTR isr52(void) { update(interruptArgs[52]); }
#endif
#ifdef CORE_INT53_PIN
static void IRAM_ATTR isr53(void) { update(interruptArgs[53]); }
#endif
#ifdef CORE_INT54_PIN
static void IRAM_ATTR isr54(void) { update(interruptArgs[54]); }
#endif
#ifdef CORE_INT55_PIN
static void IRAM_ATTR isr55(void) { update(interruptArgs[55]); }
#endif
#ifdef CORE_INT56_PIN
static void IRAM_ATTR isr56(void) { update(interruptArgs[56]); }
#endif
#ifdef CORE_INT57_PIN
static void IRAM_ATTR isr57(void) { update(interruptArgs[57]); }
#endif
#ifdef CORE_INT58_PIN
static void IRAM_ATTR isr58(void) { update(interruptArgs[58]); }
#endif
#ifdef CORE_INT59_PIN
static void IRAM_ATTR isr59(void) { update(interruptArgs[59]); }
#endif
#endif
};
#if defined(ENCODER_USE_INTERRUPTS) && defined(ENCODER_OPTIMIZE_INTERRUPTS)
#if defined(__AVR__)
#if defined(INT0_vect) && CORE_NUM_INTERRUPT > 0
ISR(INT0_vect) { Encoder::update(Encoder::interruptArgs[SCRAMBLE_INT_ORDER(0)]); }
#endif
#if defined(INT1_vect) && CORE_NUM_INTERRUPT > 1
ISR(INT1_vect) { Encoder::update(Encoder::interruptArgs[SCRAMBLE_INT_ORDER(1)]); }
#endif
#if defined(INT2_vect) && CORE_NUM_INTERRUPT > 2
ISR(INT2_vect) { Encoder::update(Encoder::interruptArgs[SCRAMBLE_INT_ORDER(2)]); }
#endif
#if defined(INT3_vect) && CORE_NUM_INTERRUPT > 3
ISR(INT3_vect) { Encoder::update(Encoder::interruptArgs[SCRAMBLE_INT_ORDER(3)]); }
#endif
#if defined(INT4_vect) && CORE_NUM_INTERRUPT > 4
ISR(INT4_vect) { Encoder::update(Encoder::interruptArgs[SCRAMBLE_INT_ORDER(4)]); }
#endif
#if defined(INT5_vect) && CORE_NUM_INTERRUPT > 5
ISR(INT5_vect) { Encoder::update(Encoder::interruptArgs[SCRAMBLE_INT_ORDER(5)]); }
#endif
#if defined(INT6_vect) && CORE_NUM_INTERRUPT > 6
ISR(INT6_vect) { Encoder::update(Encoder::interruptArgs[SCRAMBLE_INT_ORDER(6)]); }
#endif
#if defined(INT7_vect) && CORE_NUM_INTERRUPT > 7
ISR(INT7_vect) { Encoder::update(Encoder::interruptArgs[SCRAMBLE_INT_ORDER(7)]); }
#endif
#endif // AVR
#if defined(attachInterrupt)
// Don't intefere with other libraries or sketch use of attachInterrupt()
// https://github.com/PaulStoffregen/Encoder/issues/8
#undef attachInterrupt
#endif
#endif // ENCODER_OPTIMIZE_INTERRUPTS
#endif

9
lib/Encoder/README.md
View File

@ -1,9 +0,0 @@
# Encoder Library
Encoder counts pulses from quadrature encoded signals, which are commonly available from rotary knobs, motor or shaft sensors and other position sensors.
http://www.pjrc.com/teensy/td_libs_Encoder.html
http://www.youtube.com/watch?v=2puhIong-cs
![Encoder Knobs Demo](http://www.pjrc.com/teensy/td_libs_Encoder_1.jpg)

29
lib/Encoder/examples/Basic/Basic.pde
View File

@ -1,29 +0,0 @@
/* Encoder Library - Basic Example
* http://www.pjrc.com/teensy/td_libs_Encoder.html
*
* This example code is in the public domain.
*/
#include <Encoder.h>
// Change these two numbers to the pins connected to your encoder.
// Best Performance: both pins have interrupt capability
// Good Performance: only the first pin has interrupt capability
// Low Performance: neither pin has interrupt capability
Encoder myEnc(5, 6);
// avoid using pins with LEDs attached
void setup() {
Serial.begin(9600);
Serial.println("Basic Encoder Test:");
}
long oldPosition = -999;
void loop() {
long newPosition = myEnc.read();
if (newPosition != oldPosition) {
oldPosition = newPosition;
Serial.println(newPosition);
}
}

46
lib/Encoder/examples/NoInterrupts/NoInterrupts.pde
View File

@ -1,46 +0,0 @@
/* Encoder Library - NoInterrupts Example
* http://www.pjrc.com/teensy/td_libs_Encoder.html
*
* This example code is in the public domain.
*/
// If you define ENCODER_DO_NOT_USE_INTERRUPTS *before* including
// Encoder, the library will never use interrupts. This is mainly
// useful to reduce the size of the library when you are using it
// with pins that do not support interrupts. Without interrupts,
// your program must call the read() function rapidly, or risk
// missing changes in position.
#define ENCODER_DO_NOT_USE_INTERRUPTS
#include <Encoder.h>
// Beware of Serial.print() speed. Without interrupts, if you
// transmit too much data with Serial.print() it can slow your
// reading from Encoder. Arduino 1.0 has improved transmit code.
// Using the fastest baud rate also helps. Teensy has USB packet
// buffering. But all boards can experience problems if you print
// too much and fill up buffers.
// Change these two numbers to the pins connected to your encoder.
// With ENCODER_DO_NOT_USE_INTERRUPTS, no interrupts are ever
// used, even if the pin has interrupt capability
Encoder myEnc(5, 6);
// avoid using pins with LEDs attached
void setup() {
Serial.begin(9600);
Serial.println("Basic NoInterrupts Test:");
}
long position = -999;
void loop() {
long newPos = myEnc.read();
if (newPos != position) {
position = newPos;
Serial.println(position);
}
// With any substantial delay added, Encoder can only track
// very slow motion. You may uncomment this line to see
// how badly a delay affects your encoder.
//delay(50);
}

113
lib/Encoder/examples/SpeedTest/SpeedTest.pde
View File

@ -1,113 +0,0 @@
/* Encoder Library - SpeedTest - for measuring maximum Encoder speed
* http://www.pjrc.com/teensy/td_libs_Encoder.html
*
* This example code is in the public domain.
*/
// This SpeedTest example provides a simple way to verify how much
// CPU time Encoder is consuming. Connect a DC voltmeter to the
// output pin and measure the voltage while the encoder is stopped
// or running at a very slow speed. Even though the pin is rapidly
// pulsing, a DC voltmeter will show the average voltage. Due to
// software timing, it will read a number much less than a steady
// logic high, but this number will give you a baseline reading
// for output with minimal interrupt overhead. Then increase the
// encoder speed. The voltage will decrease as the processor spends
// more time in Encoder's interrupt routines counting the pulses
// and less time pulsing the output pin. When the voltage is
// close to zero and will not decrease any farther, you have reached
// the absolute speed limit. Or, if using a mechanical system where
// you reach a speed limit imposed by your motors or other hardware,
// the amount this voltage has decreased, compared to the baseline,
// should give you a good approximation of the portion of available
// CPU time Encoder is consuming at your maximum speed.
// Encoder requires low latency interrupt response. Available CPU
// time does NOT necessarily prove or guarantee correct performance.
// If another library, like NewSoftSerial, is disabling interrupts
// for lengthy periods of time, Encoder can be prevented from
// properly counting the intput signals while interrupt are disabled.
// This optional setting causes Encoder to use more optimized code,
// but the downside is a conflict if any other part of your sketch
// or any other library you're using requires attachInterrupt().
// It must be defined before Encoder.h is included.
//#define ENCODER_OPTIMIZE_INTERRUPTS
#include <Encoder.h>
#include "pins_arduino.h"
// Change these two numbers to the pins connected to your encoder
// or shift register circuit which emulates a quadrature encoder
// case 1: both pins are interrupts
// case 2: only first pin used as interrupt
Encoder myEnc(5, 6);
// Connect a DC voltmeter to this pin.
const int outputPin = 12;
/* This simple circuit, using a Dual Flip-Flop chip, can emulate
quadrature encoder signals. The clock can come from a fancy
function generator or a cheap 555 timer chip. The clock
frequency can be measured with another board running FreqCount
http://www.pjrc.com/teensy/td_libs_FreqCount.html
+5V
| Quadrature Encoder Signal Emulator
Clock |
Input o----*-------------------------- ---------------------------o Output1
| |14 | |
| _______|_______ | | _______________
| | CD4013 | | | | CD4013 |
| 5 | | 1 | | 9 | | 13
---------| D Q |-----|----*----| D Q |------o Output2
| | | | | | |
| | 3 | | | 11 | |
| ----|> Clk | ---------|> Clk |
| | | | |
| 6 | | 8 | |
| ----| S | ----| S |
| | | | | | |
| | 4 | _ | 2 | 10 | _ | 12
| *----| R Q |--- *----| R Q |----
| | | | | | | |
| | |_______________| | |_______________| |
| | | | |
| | | 7 | |
| | | | |
--------------------------------------------------------------
| | |
| | |
----- ----- -----
--- --- ---
- - -
*/
void setup() {
pinMode(outputPin, OUTPUT);
}
#if defined(__AVR__) || defined(TEENSYDUINO)
#define REGTYPE unsigned char
#else
#define REGTYPE unsigned long
#endif
void loop() {
volatile int count = 0;
volatile REGTYPE *reg = portOutputRegister(digitalPinToPort(outputPin));
REGTYPE mask = digitalPinToBitMask(outputPin);
while (1) {
myEnc.read(); // Read the encoder while interrupts are enabled.
noInterrupts();
*reg |= mask; // Pulse the pin high, while interrupts are disabled.
count = count + 1;
*reg &= ~mask;
interrupts();
}
}

46
lib/Encoder/examples/TwoKnobs/TwoKnobs.pde
View File

@ -1,46 +0,0 @@
/* Encoder Library - TwoKnobs Example
* http://www.pjrc.com/teensy/td_libs_Encoder.html
*
* This example code is in the public domain.
*/
#include <Encoder.h>
// Change these pin numbers to the pins connected to your encoder.
// Best Performance: both pins have interrupt capability
// Good Performance: only the first pin has interrupt capability
// Low Performance: neither pin has interrupt capability
Encoder knobLeft(5, 6);
Encoder knobRight(7, 8);
// avoid using pins with LEDs attached
void setup() {
Serial.begin(9600);
Serial.println("TwoKnobs Encoder Test:");
}
long positionLeft = -999;
long positionRight = -999;
void loop() {
long newLeft, newRight;
newLeft = knobLeft.read();
newRight = knobRight.read();
if (newLeft != positionLeft || newRight != positionRight) {
Serial.print("Left = ");
Serial.print(newLeft);
Serial.print(", Right = ");
Serial.print(newRight);
Serial.println();
positionLeft = newLeft;
positionRight = newRight;
}
// if a character is sent from the serial monitor,
// reset both back to zero.
if (Serial.available()) {
Serial.read();
Serial.println("Reset both knobs to zero");
knobLeft.write(0);
knobRight.write(0);
}
}

4
lib/Encoder/keywords.txt
View File

@ -1,4 +0,0 @@
ENCODER_USE_INTERRUPTS LITERAL1
ENCODER_OPTIMIZE_INTERRUPTS LITERAL1
ENCODER_DO_NOT_USE_INTERRUPTS LITERAL1
Encoder KEYWORD1

10
lib/Encoder/library.properties
View File

@ -1,10 +0,0 @@
name=Encoder
version=1.4.2
author=Paul Stoffregen
maintainer=Paul Stoffregen
sentence=Counts quadrature pulses from rotary & linear position encoders.
paragraph=Encoder counts pulses from quadrature encoded signals, which are commonly available from rotary knobs, motor or shaft sensors and other position sensors.
category=Signal Input/Output
url=http://www.pjrc.com/teensy/td_libs_Encoder.html
architectures=*

104
lib/Encoder/utility/direct_pin_read.h
View File

@ -1,104 +0,0 @@
#ifndef direct_pin_read_h_
#define direct_pin_read_h_
#if defined(__AVR__)
#define IO_REG_TYPE uint8_t
#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define DIRECT_PIN_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
#elif defined(TEENSYDUINO) && (defined(KINETISK) || defined(KINETISL))
#define IO_REG_TYPE uint8_t
#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define DIRECT_PIN_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
#define IO_REG_TYPE uint32_t
#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define DIRECT_PIN_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
#elif defined(__SAM3X8E__) // || defined(ESP8266)
#define IO_REG_TYPE uint32_t
#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define DIRECT_PIN_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
#elif defined(__PIC32MX__)
#define IO_REG_TYPE uint32_t
#define PIN_TO_BASEREG(pin) (portModeRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define DIRECT_PIN_READ(base, mask) (((*(base+4)) & (mask)) ? 1 : 0)
/* ESP8266 v2.0.0 Arduino workaround for bug https://github.com/esp8266/Arduino/issues/1110 */
#elif defined(ESP8266)
#define IO_REG_TYPE uint32_t
#define PIN_TO_BASEREG(pin) ((volatile uint32_t *)(0x60000000+(0x318)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define DIRECT_PIN_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
/* ESP32 Arduino (https://github.com/espressif/arduino-esp32) */
#elif defined(ESP32)
#define IO_REG_TYPE uint32_t
#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define DIRECT_PIN_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
#elif defined(__SAMD21G18A__)
#define IO_REG_TYPE uint32_t
#define PIN_TO_BASEREG(pin) portModeRegister(digitalPinToPort(pin))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define DIRECT_PIN_READ(base, mask) (((*((base)+8)) & (mask)) ? 1 : 0)
#elif defined(__SAMD51__)
#define IO_REG_TYPE uint32_t
#define PIN_TO_BASEREG(pin) portInputRegister(digitalPinToPort(pin))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define DIRECT_PIN_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
#elif defined(RBL_NRF51822)
#define IO_REG_TYPE uint32_t
#define PIN_TO_BASEREG(pin) (0)
#define PIN_TO_BITMASK(pin) (pin)
#define DIRECT_PIN_READ(base, pin) nrf_gpio_pin_read(pin)
#elif defined(__arc__) /* Arduino101/Genuino101 specifics */
#include "scss_registers.h"
#include "portable.h"
#include "avr/pgmspace.h"
#define GPIO_ID(pin) (g_APinDescription[pin].ulGPIOId)
#define GPIO_TYPE(pin) (g_APinDescription[pin].ulGPIOType)
#define GPIO_BASE(pin) (g_APinDescription[pin].ulGPIOBase)
#define EXT_PORT_OFFSET_SS 0x0A
#define EXT_PORT_OFFSET_SOC 0x50
#define PIN_TO_BASEREG(pin) ((volatile uint32_t *)g_APinDescription[pin].ulGPIOBase)
#define PIN_TO_BITMASK(pin) pin
#define IO_REG_TYPE uint32_t
static inline __attribute__((always_inline))
IO_REG_TYPE directRead(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
IO_REG_TYPE ret;
if (SS_GPIO == GPIO_TYPE(pin)) {
ret = READ_ARC_REG(((IO_REG_TYPE)base + EXT_PORT_OFFSET_SS));
} else {
ret = MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, EXT_PORT_OFFSET_SOC);
}
return ((ret >> GPIO_ID(pin)) & 0x01);
}
#define DIRECT_PIN_READ(base, pin) directRead(base, pin)
#endif
#endif

87
lib/Encoder/utility/interrupt_config.h
View File

@ -1,87 +0,0 @@
#if defined(__AVR__)
#include <avr/io.h>
#include <avr/interrupt.h>
#define attachInterrupt(num, func, mode) enableInterrupt(num)
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define SCRAMBLE_INT_ORDER(num) ((num < 4) ? num + 2 : ((num < 6) ? num - 4 : num))
#define DESCRAMBLE_INT_ORDER(num) ((num < 2) ? num + 4 : ((num < 6) ? num - 2 : num))
#else
#define SCRAMBLE_INT_ORDER(num) (num)
#define DESCRAMBLE_INT_ORDER(num) (num)
#endif
static void enableInterrupt(uint8_t num)
{
switch (DESCRAMBLE_INT_ORDER(num)) {
#if defined(EICRA) && defined(EIMSK)
case 0:
EICRA = (EICRA & 0xFC) | 0x01;
EIMSK |= 0x01;
return;
case 1:
EICRA = (EICRA & 0xF3) | 0x04;
EIMSK |= 0x02;
return;
case 2:
EICRA = (EICRA & 0xCF) | 0x10;
EIMSK |= 0x04;
return;
case 3:
EICRA = (EICRA & 0x3F) | 0x40;
EIMSK |= 0x08;
return;
#elif defined(MCUCR) && defined(GICR)
case 0:
MCUCR = (MCUCR & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00);
GICR |= (1 << INT0);
return;
case 1:
MCUCR = (MCUCR & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10);
GICR |= (1 << INT1);
return;
#elif defined(MCUCR) && defined(GIMSK)
case 0:
MCUCR = (MCUCR & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00);
GIMSK |= (1 << INT0);
return;
case 1:
MCUCR = (MCUCR & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10);
GIMSK |= (1 << INT1);
return;
#endif
#if defined(EICRB) && defined(EIMSK)
case 4:
EICRB = (EICRB & 0xFC) | 0x01;
EIMSK |= 0x10;
return;
case 5:
EICRB = (EICRB & 0xF3) | 0x04;
EIMSK |= 0x20;
return;
case 6:
EICRB = (EICRB & 0xCF) | 0x10;
EIMSK |= 0x40;
return;
case 7:
EICRB = (EICRB & 0x3F) | 0x40;
EIMSK |= 0x80;
return;
#endif
}
}
#elif defined(__PIC32MX__)
#ifdef ENCODER_OPTIMIZE_INTERRUPTS
#undef ENCODER_OPTIMIZE_INTERRUPTS
#endif
#else
#ifdef ENCODER_OPTIMIZE_INTERRUPTS
#undef ENCODER_OPTIMIZE_INTERRUPTS
#endif
#endif

340
lib/Encoder/utility/interrupt_pins.h
View File

@ -1,340 +0,0 @@
// interrupt pins for known boards
// Teensy (and maybe others) define these automatically
#if !defined(CORE_NUM_INTERRUPT)
// Wiring boards
#if defined(WIRING)
#define CORE_NUM_INTERRUPT NUM_EXTERNAL_INTERRUPTS
#if NUM_EXTERNAL_INTERRUPTS > 0
#define CORE_INT0_PIN EI0
#endif
#if NUM_EXTERNAL_INTERRUPTS > 1
#define CORE_INT1_PIN EI1
#endif
#if NUM_EXTERNAL_INTERRUPTS > 2
#define CORE_INT2_PIN EI2
#endif
#if NUM_EXTERNAL_INTERRUPTS > 3
#define CORE_INT3_PIN EI3
#endif
#if NUM_EXTERNAL_INTERRUPTS > 4
#define CORE_INT4_PIN EI4
#endif
#if NUM_EXTERNAL_INTERRUPTS > 5
#define CORE_INT5_PIN EI5
#endif
#if NUM_EXTERNAL_INTERRUPTS > 6
#define CORE_INT6_PIN EI6
#endif
#if NUM_EXTERNAL_INTERRUPTS > 7
#define CORE_INT7_PIN EI7
#endif
// Arduino Uno, Duemilanove, Diecimila, LilyPad, Mini, Fio, etc...
#elif defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328PB__) ||defined(__AVR_ATmega168__) || defined(__AVR_ATmega8__)
#define CORE_NUM_INTERRUPT 2
#define CORE_INT0_PIN 2
#define CORE_INT1_PIN 3
// Arduino Mega
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define CORE_NUM_INTERRUPT 6
#define CORE_INT0_PIN 2
#define CORE_INT1_PIN 3
#define CORE_INT2_PIN 21
#define CORE_INT3_PIN 20
#define CORE_INT4_PIN 19
#define CORE_INT5_PIN 18
// Arduino Nano Every, Uno R2 Wifi
#elif defined(__AVR_ATmega4809__)
#define CORE_NUM_INTERRUPT 22
#define CORE_INT0_PIN 0
#define CORE_INT1_PIN 1
#define CORE_INT2_PIN 2
#define CORE_INT3_PIN 3
#define CORE_INT4_PIN 4
#define CORE_INT5_PIN 5
#define CORE_INT6_PIN 6
#define CORE_INT7_PIN 7
#define CORE_INT8_PIN 8
#define CORE_INT9_PIN 9
#define CORE_INT10_PIN 10
#define CORE_INT11_PIN 11
#define CORE_INT12_PIN 12
#define CORE_INT13_PIN 13
#define CORE_INT14_PIN 14
#define CORE_INT15_PIN 15
#define CORE_INT16_PIN 16
#define CORE_INT17_PIN 17
#define CORE_INT18_PIN 18
#define CORE_INT19_PIN 19
#define CORE_INT20_PIN 20
#define CORE_INT21_PIN 21
// Arduino Leonardo (untested)
#elif defined(__AVR_ATmega32U4__) && !defined(CORE_TEENSY)
#define CORE_NUM_INTERRUPT 5
#define CORE_INT0_PIN 3
#define CORE_INT1_PIN 2
#define CORE_INT2_PIN 0
#define CORE_INT3_PIN 1
#define CORE_INT4_PIN 7
// Sanguino (untested) and ATmega1284P
#elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__) || defined(__AVR_ATmega1284P__)
#define CORE_NUM_INTERRUPT 3
#define CORE_INT0_PIN 10
#define CORE_INT1_PIN 11
#define CORE_INT2_PIN 2
// ATmega32u2 and ATmega32u16 based boards with HoodLoader2
#elif defined(__AVR_ATmega32U2__) || defined(__AVR_ATmega16U2__)
#define CORE_NUM_INTERRUPT 8
#define CORE_INT0_PIN 8
#define CORE_INT1_PIN 17
#define CORE_INT2_PIN 13
#define CORE_INT3_PIN 14
#define CORE_INT4_PIN 15
#define CORE_INT5_PIN 16
#define CORE_INT6_PIN 19
#define CORE_INT7_PIN 20
// Chipkit Uno32 - attachInterrupt may not support CHANGE option
#elif defined(__PIC32MX__) && defined(_BOARD_UNO_)
#define CORE_NUM_INTERRUPT 5
#define CORE_INT0_PIN 38
#define CORE_INT1_PIN 2
#define CORE_INT2_PIN 7
#define CORE_INT3_PIN 8
#define CORE_INT4_PIN 35
// Chipkit Uno32 - attachInterrupt may not support CHANGE option
#elif defined(__PIC32MX__) && defined(_BOARD_MEGA_)
#define CORE_NUM_INTERRUPT 5
#define CORE_INT0_PIN 3
#define CORE_INT1_PIN 2
#define CORE_INT2_PIN 7
#define CORE_INT3_PIN 21
#define CORE_INT4_PIN 20
// http://hlt.media.mit.edu/?p=1229
#elif defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
#define CORE_NUM_INTERRUPT 1
#define CORE_INT0_PIN 2
// ATtiny441 ATtiny841
#elif defined(__AVR_ATtiny441__) || defined(__AVR_ATtiny841__)
#define CORE_NUM_INTERRUPT 1
#define CORE_INT0_PIN 9
//https://github.com/SpenceKonde/ATTinyCore/blob/master/avr/extras/ATtiny_x313.md
#elif defined(__AVR_ATtinyX313__)
#define CORE_NUM_INTERRUPT 2
#define CORE_INT0_PIN 4
#define CORE_INT1_PIN 5
// Attiny167 same core as abobe
#elif defined(__AVR_ATtiny167__)
#define CORE_NUM_INTERRUPT 2
#define CORE_INT0_PIN 14
#define CORE_INT1_PIN 3
// Arduino Due
#elif defined(__SAM3X8E__)
#define CORE_NUM_INTERRUPT 54
#define CORE_INT0_PIN 0
#define CORE_INT1_PIN 1
#define CORE_INT2_PIN 2
#define CORE_INT3_PIN 3
#define CORE_INT4_PIN 4
#define CORE_INT5_PIN 5
#define CORE_INT6_PIN 6
#define CORE_INT7_PIN 7
#define CORE_INT8_PIN 8
#define CORE_INT9_PIN 9
#define CORE_INT10_PIN 10
#define CORE_INT11_PIN 11
#define CORE_INT12_PIN 12
#define CORE_INT13_PIN 13
#define CORE_INT14_PIN 14
#define CORE_INT15_PIN 15
#define CORE_INT16_PIN 16
#define CORE_INT17_PIN 17
#define CORE_INT18_PIN 18
#define CORE_INT19_PIN 19
#define CORE_INT20_PIN 20
#define CORE_INT21_PIN 21
#define CORE_INT22_PIN 22
#define CORE_INT23_PIN 23
#define CORE_INT24_PIN 24
#define CORE_INT25_PIN 25
#define CORE_INT26_PIN 26
#define CORE_INT27_PIN 27
#define CORE_INT28_PIN 28
#define CORE_INT29_PIN 29
#define CORE_INT30_PIN 30
#define CORE_INT31_PIN 31
#define CORE_INT32_PIN 32
#define CORE_INT33_PIN 33
#define CORE_INT34_PIN 34
#define CORE_INT35_PIN 35
#define CORE_INT36_PIN 36
#define CORE_INT37_PIN 37
#define CORE_INT38_PIN 38
#define CORE_INT39_PIN 39
#define CORE_INT40_PIN 40
#define CORE_INT41_PIN 41
#define CORE_INT42_PIN 42
#define CORE_INT43_PIN 43
#define CORE_INT44_PIN 44
#define CORE_INT45_PIN 45
#define CORE_INT46_PIN 46
#define CORE_INT47_PIN 47
#define CORE_INT48_PIN 48
#define CORE_INT49_PIN 49
#define CORE_INT50_PIN 50
#define CORE_INT51_PIN 51
#define CORE_INT52_PIN 52
#define CORE_INT53_PIN 53
// ESP8266 (https://github.com/esp8266/Arduino/)
#elif defined(ESP8266)
#define CORE_NUM_INTERRUPT EXTERNAL_NUM_INTERRUPTS
#define CORE_INT0_PIN 0
#define CORE_INT1_PIN 1
#define CORE_INT2_PIN 2
#define CORE_INT3_PIN 3
#define CORE_INT4_PIN 4
#define CORE_INT5_PIN 5
// GPIO6-GPIO11 are typically used to interface with the flash memory IC on
// most esp8266 modules, so we should avoid adding interrupts to these pins.
#define CORE_INT12_PIN 12
#define CORE_INT13_PIN 13
#define CORE_INT14_PIN 14
#define CORE_INT15_PIN 15
// ESP32 (https://github.com/espressif/arduino-esp32)
#elif defined(ESP32)
#define CORE_NUM_INTERRUPT 40
#define CORE_INT0_PIN 0
#define CORE_INT1_PIN 1
#define CORE_INT2_PIN 2
#define CORE_INT3_PIN 3
#define CORE_INT4_PIN 4
#define CORE_INT5_PIN 5
// GPIO6-GPIO11 are typically used to interface with the flash memory IC on
// esp32, so we should avoid adding interrupts to these pins.
#define CORE_INT12_PIN 12
#define CORE_INT13_PIN 13
#define CORE_INT14_PIN 14
#define CORE_INT15_PIN 15
#define CORE_INT16_PIN 16
#define CORE_INT17_PIN 17
#define CORE_INT18_PIN 18
#define CORE_INT19_PIN 19
#define CORE_INT21_PIN 21
#define CORE_INT22_PIN 22
#define CORE_INT23_PIN 23
#define CORE_INT25_PIN 25
#define CORE_INT26_PIN 26
#define CORE_INT27_PIN 27
#define CORE_INT32_PIN 32
#define CORE_INT33_PIN 33
#define CORE_INT34_PIN 34
#define CORE_INT35_PIN 35
#define CORE_INT36_PIN 36
#define CORE_INT39_PIN 39
// Arduino Zero - TODO: interrupts do not seem to work
// please help, contribute a fix!
#elif defined(__SAMD21G18A__)
#define CORE_NUM_INTERRUPT 31
#define CORE_INT0_PIN 0
#define CORE_INT1_PIN 1
#define CORE_INT2_PIN 2
#define CORE_INT3_PIN 3
#define CORE_INT4_PIN 4
#define CORE_INT5_PIN 5
#define CORE_INT6_PIN 6
#define CORE_INT7_PIN 7
#define CORE_INT8_PIN 8
#define CORE_INT9_PIN 9
#define CORE_INT10_PIN 10
#define CORE_INT11_PIN 11
#define CORE_INT12_PIN 12
#define CORE_INT13_PIN 13
#define CORE_INT14_PIN 14
#define CORE_INT15_PIN 15
#define CORE_INT16_PIN 16
#define CORE_INT17_PIN 17
#define CORE_INT18_PIN 18
#define CORE_INT19_PIN 19
#define CORE_INT20_PIN 20
#define CORE_INT21_PIN 21
#define CORE_INT22_PIN 22
#define CORE_INT23_PIN 23
#define CORE_INT24_PIN 24
#define CORE_INT25_PIN 25
#define CORE_INT26_PIN 26
#define CORE_INT27_PIN 27
#define CORE_INT28_PIN 28
#define CORE_INT29_PIN 29
#define CORE_INT30_PIN 30
#elif defined(__SAMD51__)
#define CORE_NUM_INTERRUPT 26
#define CORE_INT0_PIN 0
#define CORE_INT1_PIN 1
#define CORE_INT2_PIN 2
#define CORE_INT3_PIN 3
#define CORE_INT4_PIN 4
#define CORE_INT5_PIN 5
#define CORE_INT6_PIN 6
#define CORE_INT7_PIN 7
#define CORE_INT8_PIN 8
#define CORE_INT9_PIN 9
#define CORE_INT10_PIN 10
#define CORE_INT11_PIN 11
#define CORE_INT12_PIN 12
#define CORE_INT13_PIN 13
#define CORE_INT14_PIN 14
#define CORE_INT15_PIN 15
#define CORE_INT16_PIN 16
#define CORE_INT17_PIN 17
#define CORE_INT18_PIN 18
#define CORE_INT19_PIN 19
#define CORE_INT20_PIN 20
#define CORE_INT21_PIN 21
#define CORE_INT22_PIN 22
#define CORE_INT23_PIN 23
#define CORE_INT24_PIN 24
#define CORE_INT25_PIN 25
// Arduino 101
#elif defined(__arc__)
#define CORE_NUM_INTERRUPT 14
#define CORE_INT2_PIN 2
#define CORE_INT5_PIN 5
#define CORE_INT7_PIN 7
#define CORE_INT8_PIN 8
#define CORE_INT10_PIN 10
#define CORE_INT11_PIN 11
#define CORE_INT12_PIN 12
#define CORE_INT13_PIN 13
#endif
#endif
#if !defined(CORE_NUM_INTERRUPT)
#error "Interrupts are unknown for this board, please add to this code"
#endif
#if CORE_NUM_INTERRUPT <= 0
#error "Encoder requires interrupt pins, but this board does not have any :("
#error "You could try defining ENCODER_DO_NOT_USE_INTERRUPTS as a kludge."
#endif

30
lib/LedLib/include/LedLib.h
View File

@ -1,30 +0,0 @@
#ifndef NEOLED_H
#define NEOLED_H 0
#include <Adafruit_NeoPixel.h>
// Classe LedLib : Gestion de l'allumage des LEDs en fonction du Rotary
// Class LedLib : Manages LEDs colors according to the Rotary
class LedLib{
public :
LedLib(int pixelCount, int pixelPin, int bright);
// Fonction pour allumer correctement les LEDs en fonction du Rotary
// Function to manage LEDs colors according to the Rotary
void actLed(int nb, int start = 0);
// Fonction qui renvoie le nombre de LEDs allumées
// Function that returns the number of LEDs lit
int getledNB();
void okBlink();
private :
// Le nombre de LEDs allumées
// Amount of LEDs lit
int ledNb;
Adafruit_NeoPixel* strip;
};
#endif

68
lib/LedLib/scr/LedLib.cpp
View File

@ -1,68 +0,0 @@
#include "../include/LedLib.h"
// Initialisation
// Initialization
LedLib::LedLib(int pixelCount, int pixelPin, int bright){
this->ledNb = 0;
this->strip = new Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);
this->strip->begin();
this->strip->show();
this->strip->setBrightness(bright);
}
// Fonction pour allumer correctement les LEDs en fonction du Rotary
// Function to manage LEDs colors according to the Rotary
void LedLib::actLed(int nb, int start){
this->ledNb = nb;
// On éteint tout
// We shut everything up
this->strip->clear();
// Allumer 0 LED ? Inutile
// Useless to light up 0 LED
if (nb != 0) {
// Boucle dans les LEDs
// Loop in LEDs
for (int i = start; i <= nb+start-1; i++) {
int j = i;
if(j >= 24){
j -= 24;
}
// Une LED sur deux est blanche : heure entière, l'autre rouge pour 30m
// One LED out of two is white: whole hour, the other red for 30m
if (j%2 == 0) {
this->strip->setPixelColor(j, 255, 255, 255);
}else{
this->strip->setPixelColor(j, 255, 0, 0);
}
}
}
// Maintenant on allume
// Then light everything up
this->strip->show();
}
// Fonction qui renvoie le nombre de LEDs allumées
// Function that returns the number of LEDs lit
int LedLib::getledNB(){
return this->ledNb;
}
void LedLib::okBlink(){
this->strip->clear();
for(int i = 0; i < 3; i++){
for(int j = 0; j < 24; j++){
this->strip->setPixelColor(j, 0, 255, 0);
}
this->strip->show();
delay(100);
this->strip->clear();
this->strip->show();
delay(100);
}
}

92
lib/SwitchableEncodeur/include/SwitchableEncodeur.h
View File

@ -1,92 +0,0 @@
#ifndef SWITCHABLEENCODEUR_H
#define SWITCHABLEENCODEUR_H
#include "Encoder.h"
class SwitchableEncodeur : public Encoder {
public:
/**
* @brief Construct a new Switchable Encodeur object
*
* @param pin1 ENCODER_DT
* @param pin2 ENCODER_CLK
* @param pinSW ENCODER_SW
* @param nbMenu nombre D'état du system
*/
SwitchableEncodeur(uint8_t pin1, uint8_t pin2, uint8_t pinSW, int nbMenu = 0);
/**
* @brief reset the menu
*/
void resetMenu();
/**
* @brief add one to the menu
*/
void addMenu();
/**
* @brief Get the Menu number
* @return int
*/
int getMenu();
/**
* @brief Get return the encodeur value
*
* @return int dernière valeur de l'encodeur
*/
int getValue();
/**
* @brief set the encodeur value
*
* @param val the new encodeur value
*/
void setValue(int val);
/**
* @brief update the encodeur value
*
* @return true the value has changed
* @return false the value has not changed
*/
bool update();
/**
* @brief reset the encodeur value
*/
void resetValue();
static SwitchableEncodeur* getInstance();
private:
static SwitchableEncodeur* instance;
/**
* @brief menu actuel
*/
int menu;
/**
* @brief old position of the encoder
*/
int oldPosition = -999;
/**
* @brief old menu number
*/
int oldMenu = -999;
/**
* @brief nombre de menu
*/
int nbMenu;
};
#endif

74
lib/SwitchableEncodeur/src/SwitchableEncodeur.cpp
View File

@ -1,74 +0,0 @@
#include "../include/SwitchableEncodeur.h"
IRAM_ATTR void switchEncoder() {
static unsigned long last_interrupt_time = 0;
unsigned long interrupt_time = millis();
// If interrupts come faster than 200ms, assume it's a bounce and ignore
if (interrupt_time - last_interrupt_time > 200){
SwitchableEncodeur::getInstance()->addMenu();
}
last_interrupt_time = interrupt_time;
}
SwitchableEncodeur* SwitchableEncodeur::instance = nullptr;
SwitchableEncodeur::SwitchableEncodeur(uint8_t pin1, uint8_t pin2, uint8_t pinSW, int nbMenu): Encoder(pin1, pin2){
SwitchableEncodeur::instance = this;
this->menu = 0;
this->nbMenu = nbMenu;
pinMode(pinSW, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(pinSW), switchEncoder, RISING);//FIXME: maybe change to FALLING
this->oldPosition = -999;
this->oldMenu = -999;
}
void SwitchableEncodeur::resetMenu() {
this->menu = 0;
}
void SwitchableEncodeur::addMenu() {
this->menu++;
if (this->menu > this->nbMenu) {
this->menu = 0;
}
}
int SwitchableEncodeur::getMenu() {
return this->menu;
}
SwitchableEncodeur* SwitchableEncodeur::getInstance() {
return SwitchableEncodeur::instance;
}
bool SwitchableEncodeur::update() {
bool sortie = false;
long newPosition = this->read()/4;
if(newPosition < 0){
newPosition = 0;
this->readAndReset();
}
if (newPosition != this->oldPosition || this->menu != this->oldMenu) {
this->oldMenu = this->menu;
this->oldPosition = newPosition;
if(this->oldPosition <= 0){
this->oldPosition = 0;
}
sortie = true;
}
return sortie;
}
int SwitchableEncodeur::getValue() {
return this->oldPosition;
}
void SwitchableEncodeur::resetValue() {
this->oldPosition = 0;
this->readAndReset();
}
void SwitchableEncodeur::setValue(int val){
this->write(val*4);
}

2
platformio.ini
View File

@ -52,8 +52,6 @@ upload_speed = 921600
lib_deps = lib_deps =
; example: ; example:
; erropix/ESP32 AnalogWrite@0.2 ; erropix/ESP32 AnalogWrite@0.2
adafruit/Adafruit NeoPixel@^1.11.0
arduino-libraries/NTPClient@^3.2.1
; Checker settings ; Checker settings
check_tool = clangtidy, cppcheck check_tool = clangtidy, cppcheck

127
src/Program.cpp
View File

@ -1,12 +1,9 @@
#include "Program.h" #include "Program.h"
Program::Program() { Program::Program() {
// Startup
// Startup Serial
Serial.begin(MONITOR_SPEED); Serial.begin(MONITOR_SPEED);
// Startup WiFi
WiFi.begin(WSSID, PASS); WiFi.begin(WSSID, PASS);
Serial.print("Connecting to "); Serial.print("Connecting to ");
@ -15,8 +12,7 @@ Program::Program() {
int i = 0; int i = 0;
while (WiFi.status() != WL_CONNECTED) { // Wait for the Wi-Fi to connect while (WiFi.status() != WL_CONNECTED) { // Wait for the Wi-Fi to connect
delay(1000); delay(1000);
Serial.print(++i); Serial.print(++i); Serial.print(' ');
Serial.print(' ');
} }
Serial.println('\n'); Serial.println('\n');
@ -24,122 +20,13 @@ Program::Program() {
Serial.print("IP address:\t"); Serial.print("IP address:\t");
Serial.println(WiFi.localIP()); // Send the IP address of the ESP8266 to the computer Serial.println(WiFi.localIP()); // Send the IP address of the ESP8266 to the computer
// Startup Discord API
this->discord = new DiscordAPI(DISCORD_HOOK); this->discord = new DiscordAPI(DISCORD_HOOK);
// startup NTP delay(1000);
this->ntpUDP = new WiFiUDP(); Serial.println(this->discord->sendHeure("10h", "18h"));
this->timeClient = new NTPClient(*this->ntpUDP, "pool.ntp.org", 3600*1);//*2 = gnt+2
this->timeClient->update();
// Startup Rotary
this->encoder = new SwitchableEncodeur(ENCODER_DT, ENCODER_CLK, ENCODER_SWITCH, 3);
// Startup LEDs
this->ledLib = new LedLib(PIXEL_COUNT, PIXEL_PIN, 255);
this->ledLib->okBlink();
this->menu=MainMenu::INITIAL_STATE;
this->resetMillis = 0;
}
void Program::sendTime(String timeEnd){
String start = (String)this->timeClient->getHours() + "h";
int startQuater = this->timeClient->getMinutes()/15;
if (startQuater != 0){
start += (String)(startQuater * 15);
}
this->discord->sendHeure(start, timeEnd);
this->nLedStart = 0;
this->pm = false;
} }
void Program::loop() { void Program::loop() {
switch (this->menu){ // Loop
case MainMenu::INITIAL_STATE: // default state
this->encoder->resetValue();
this->ledLib->actLed(0,0);
break;
case MainMenu::GET_START_HOUR:{ // get NTP Hour
//TODO: géré heure d'été et d'hiver
this->timeClient->update();
int hour = this->timeClient->getHours();
int min = this->timeClient->getMinutes();
int day = this->timeClient->getDay();
if(hour >= 12){
hour -= 12;
this->pm = true;
}else{
this->pm = false;
}
this->nLedStart = hour*2;
if(min >= 30){
this->nLedStart++;
}
this->menu=MainMenu::SELECT_END_HOUR;
this->resetMillis = millis();
if(day == 2 || day == 5){
this->encoder->setValue(21-this->nLedStart);
}else{
this->encoder->setValue(1);
}
break;}
case MainMenu::SELECT_END_HOUR: // select Close hour
this->ledLib->actLed(this->encoder->getValue(), this->nLedStart);
break;
case MainMenu::SEND_TO_DISCORD:{ // send value to discord
String strTime = "";
bool min = false;
int endLed = this->encoder->getValue();
int hour = (this->nLedStart + endLed)/2;
if(this->pm)hour += 12;
if(this->nLedStart % 2 == 1){
if(endLed % 2 == 1){
hour -=1;
min = true;
}
}else{
if(endLed % 2 == 0){
hour -=1;
min = true;
}
}
if(hour >= 24)hour -= 24;
strTime += hour;
strTime += "h";
if(min)strTime += "30";
this->sendTime(strTime);
this->menu = MainMenu::INITIAL_STATE;
this->encoder->resetMenu();
this->encoder->resetValue();
this->ledLib->okBlink();
}
break;
default:
break;
}
// MAJ encodeur
if(this->encoder->update()){
if(this->encoder->getMenu() == 1 && this->menu == MainMenu::INITIAL_STATE){//passage de l'état initial au 1er état
this->menu = MainMenu::GET_START_HOUR;
}
if(this->encoder->getMenu() == 2 && this->menu == MainMenu::SELECT_END_HOUR){//validation du choix de l'heure
this->menu = MainMenu::SEND_TO_DISCORD;
}
}
// Reseteur
if(this->resetMillis + RESET_TIME == millis()){
this->encoder->resetMenu();
this->resetMillis = millis();
this->menu = MainMenu::INITIAL_STATE;
}
//TODO: gestion cas d'erreur (pas de wifi, discord down,...)
//TODO: gestion d'une ouverture de plus de 12h avec les led (chagement de couleur)
// int currentDayOfWeek = this->timeClient->getDay();
// Serial.print("Day of week: ");
// Serial.println(currentDayOfWeek);
} }

2
src/main.cpp
View File

@ -9,5 +9,3 @@ void setup() {
void loop() { void loop() {
program->loop(); program->loop();
} }