RievoGitAdmin/buenzliai
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

migration to platformio

Browse source
This commit is contained in:
Marcel 2024-05-23 16:16:00 +02:00
commit cad91967b1
22 changed files with 2985 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

49
.gitattributes vendored Normal file
View file

@ -0,0 +1,49 @@
# Auto detect text files and perform LF normalization
* text=auto
# Custom for Visual Studio
*.cs diff=csharp
# Standard to msysgit
*.doc diff=astextplain
*.DOC diff=astextplain
*.docx diff=astextplain
*.DOCX diff=astextplain
*.dot diff=astextplain
*.DOT diff=astextplain
*.pdf diff=astextplain
*.PDF diff=astextplain
*.rtf diff=astextplain
*.RTF diff=astextplain
# ------------------------
# LFS
#-------------------------
# libraries and packages
*.a filter=lfs -crlf
*.apk filter=lfs diff=lfs merge=lfs -text
*.dll filter=lfs -crlf
*.dylib filter=lfs diff=lfs merge=lfs -text
*.exe filter=lfs -crlf
*.rar filter=lfs diff=lfs merge=lfs -text
*.unitypackage filter=lfs -crlf
*.zip filter=lfs -crlf
# models and playables
*.blend filter=lfs -crlf
*.wav filter=lfs diff=lfs merge=lfs -text
# images
*.cubemap filter=lfs -crlf
*.exr filter=lfs -crlf
*.fbx filter=lfs -crlf
*.hdr filter=lfs diff=lfs merge=lfs -text
*.jpg filter=lfs -crlf
*.gif filter=lfs -crlf
*.mp3 filter=lfs -crlf
*.wav filter=lfs -crlf
*.mp4 filter=lfs -crlf
*.png filter=lfs -crlf
*.psd filter=lfs -crlf
*.tga filter=lfs -crlf
*.tif filter=lfs -crlf

2
.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
.pio
.idea

39
include/README Normal file
View file

@ -0,0 +1,39 @@
This directory is intended for project header files.
A header file is a file containing C declarations and macro definitions
to be shared between several project source files. You request the use of a
header file in your project source file (C, C++, etc) located in `src` folder
by including it, with the C preprocessing directive `#include'.
```src/main.c
#include "header.h"
int main (void)
{
...
}
```
Including a header file produces the same results as copying the header file
into each source file that needs it. Such copying would be time-consuming
and error-prone. With a header file, the related declarations appear
in only one place. If they need to be changed, they can be changed in one
place, and programs that include the header file will automatically use the
new version when next recompiled. The header file eliminates the labor of
finding and changing all the copies as well as the risk that a failure to
find one copy will result in inconsistencies within a program.
In C, the usual convention is to give header files names that end with `.h'.
It is most portable to use only letters, digits, dashes, and underscores in
header file names, and at most one dot.
Read more about using header files in official GCC documentation:
* Include Syntax
* Include Operation
* Once-Only Headers
* Computed Includes
https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html

46
lib/README Normal file
View file

@ -0,0 +1,46 @@
This directory is intended for project specific (private) libraries.
PlatformIO will compile them to static libraries and link into executable file.
The source code of each library should be placed in an own separate directory
("lib/your_library_name/[here are source files]").
For example, see a structure of the following two libraries `Foo` and `Bar`:
|--lib
| |
| |--Bar
| | |--docs
| | |--examples
| | |--src
| | |- Bar.c
| | |- Bar.h
| | |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
| |
| |--Foo
| | |- Foo.c
| | |- Foo.h
| |
| |- README --> THIS FILE
|
|- platformio.ini
|--src
|- main.c
and a contents of `src/main.c`:
```
#include <Foo.h>
#include <Bar.h>
int main (void)
{
...
}
```
PlatformIO Library Dependency Finder will find automatically dependent
libraries scanning project source files.
More information about PlatformIO Library Dependency Finder
- https://docs.platformio.org/page/librarymanager/ldf.html

18
platformio.ini Normal file
View file

@ -0,0 +1,18 @@
; PlatformIO Project Configuration File
;
; Build options: build flags, source filter
; Upload options: custom upload port, speed and extra flags
; Library options: dependencies, extra library storages
; Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
[env:uno]
platform = atmelavr
board = uno
framework = arduino
lib_deps =
adafruit/Adafruit BusIO@^1.16.1
dfrobot/DFRobotDFPlayerMini@^1.0.6
fmalpartida/LiquidCrystal@^1.5.0

1820
src/Adafruit_PN532.cpp Normal file
View file

File diff suppressed because it is too large Load diff

221
src/Adafruit_PN532.h Normal file
View file

@ -0,0 +1,221 @@
/**************************************************************************/
/*!
@file Adafruit_PN532.h
v2.0 - Refactored to add I2C support from Adafruit_NFCShield_I2C library.
v1.1 - Added full command list
- Added 'verbose' mode flag to constructor to toggle debug output
- Changed readPassiveTargetID() to return variable length values
*/
/**************************************************************************/
#ifndef ADAFRUIT_PN532_H
#define ADAFRUIT_PN532_H
#include "Arduino.h"
#include <Adafruit_I2CDevice.h>
#include <Adafruit_SPIDevice.h>
#define PN532_PREAMBLE (0x00) ///< Command sequence start, byte 1/3
#define PN532_STARTCODE1 (0x00) ///< Command sequence start, byte 2/3
#define PN532_STARTCODE2 (0xFF) ///< Command sequence start, byte 3/3
#define PN532_POSTAMBLE (0x00) ///< EOD
#define PN532_HOSTTOPN532 (0xD4) ///< Host-to-PN532
#define PN532_PN532TOHOST (0xD5) ///< PN532-to-host
// PN532 Commands
#define PN532_COMMAND_DIAGNOSE (0x00) ///< Diagnose
#define PN532_COMMAND_GETFIRMWAREVERSION (0x02) ///< Get firmware version
#define PN532_COMMAND_GETGENERALSTATUS (0x04) ///< Get general status
#define PN532_COMMAND_READREGISTER (0x06) ///< Read register
#define PN532_COMMAND_WRITEREGISTER (0x08) ///< Write register
#define PN532_COMMAND_READGPIO (0x0C) ///< Read GPIO
#define PN532_COMMAND_WRITEGPIO (0x0E) ///< Write GPIO
#define PN532_COMMAND_SETSERIALBAUDRATE (0x10) ///< Set serial baud rate
#define PN532_COMMAND_SETPARAMETERS (0x12) ///< Set parameters
#define PN532_COMMAND_SAMCONFIGURATION (0x14) ///< SAM configuration
#define PN532_COMMAND_POWERDOWN (0x16) ///< Power down
#define PN532_COMMAND_RFCONFIGURATION (0x32) ///< RF config
#define PN532_COMMAND_RFREGULATIONTEST (0x58) ///< RF regulation test
#define PN532_COMMAND_INJUMPFORDEP (0x56) ///< Jump for DEP
#define PN532_COMMAND_INJUMPFORPSL (0x46) ///< Jump for PSL
#define PN532_COMMAND_INLISTPASSIVETARGET (0x4A) ///< List passive target
#define PN532_COMMAND_INATR (0x50) ///< ATR
#define PN532_COMMAND_INPSL (0x4E) ///< PSL
#define PN532_COMMAND_INDATAEXCHANGE (0x40) ///< Data exchange
#define PN532_COMMAND_INCOMMUNICATETHRU (0x42) ///< Communicate through
#define PN532_COMMAND_INDESELECT (0x44) ///< Deselect
#define PN532_COMMAND_INRELEASE (0x52) ///< Release
#define PN532_COMMAND_INSELECT (0x54) ///< Select
#define PN532_COMMAND_INAUTOPOLL (0x60) ///< Auto poll
#define PN532_COMMAND_TGINITASTARGET (0x8C) ///< Init as target
#define PN532_COMMAND_TGSETGENERALBYTES (0x92) ///< Set general bytes
#define PN532_COMMAND_TGGETDATA (0x86) ///< Get data
#define PN532_COMMAND_TGSETDATA (0x8E) ///< Set data
#define PN532_COMMAND_TGSETMETADATA (0x94) ///< Set metadata
#define PN532_COMMAND_TGGETINITIATORCOMMAND (0x88) ///< Get initiator command
#define PN532_COMMAND_TGRESPONSETOINITIATOR (0x90) ///< Response to initiator
#define PN532_COMMAND_TGGETTARGETSTATUS (0x8A) ///< Get target status
#define PN532_RESPONSE_INDATAEXCHANGE (0x41) ///< Data exchange
#define PN532_RESPONSE_INLISTPASSIVETARGET (0x4B) ///< List passive target
#define PN532_WAKEUP (0x55) ///< Wake
#define PN532_SPI_STATREAD (0x02) ///< Stat read
#define PN532_SPI_DATAWRITE (0x01) ///< Data write
#define PN532_SPI_DATAREAD (0x03) ///< Data read
#define PN532_SPI_READY (0x01) ///< Ready
#define PN532_I2C_ADDRESS (0x48 >> 1) ///< Default I2C address
#define PN532_I2C_READBIT (0x01) ///< Read bit
#define PN532_I2C_BUSY (0x00) ///< Busy
#define PN532_I2C_READY (0x01) ///< Ready
#define PN532_I2C_READYTIMEOUT (20) ///< Ready timeout
#define PN532_MIFARE_ISO14443A (0x00) ///< MiFare
// Mifare Commands
#define MIFARE_CMD_AUTH_A (0x60) ///< Auth A
#define MIFARE_CMD_AUTH_B (0x61) ///< Auth B
#define MIFARE_CMD_READ (0x30) ///< Read
#define MIFARE_CMD_WRITE (0xA0) ///< Write
#define MIFARE_CMD_TRANSFER (0xB0) ///< Transfer
#define MIFARE_CMD_DECREMENT (0xC0) ///< Decrement
#define MIFARE_CMD_INCREMENT (0xC1) ///< Increment
#define MIFARE_CMD_STORE (0xC2) ///< Store
#define MIFARE_ULTRALIGHT_CMD_WRITE (0xA2) ///< Write (MiFare Ultralight)
// Prefixes for NDEF Records (to identify record type)
#define NDEF_URIPREFIX_NONE (0x00) ///< No prefix
#define NDEF_URIPREFIX_HTTP_WWWDOT (0x01) ///< HTTP www. prefix
#define NDEF_URIPREFIX_HTTPS_WWWDOT (0x02) ///< HTTPS www. prefix
#define NDEF_URIPREFIX_HTTP (0x03) ///< HTTP prefix
#define NDEF_URIPREFIX_HTTPS (0x04) ///< HTTPS prefix
#define NDEF_URIPREFIX_TEL (0x05) ///< Tel prefix
#define NDEF_URIPREFIX_MAILTO (0x06) ///< Mailto prefix
#define NDEF_URIPREFIX_FTP_ANONAT (0x07) ///< FTP
#define NDEF_URIPREFIX_FTP_FTPDOT (0x08) ///< FTP dot
#define NDEF_URIPREFIX_FTPS (0x09) ///< FTPS
#define NDEF_URIPREFIX_SFTP (0x0A) ///< SFTP
#define NDEF_URIPREFIX_SMB (0x0B) ///< SMB
#define NDEF_URIPREFIX_NFS (0x0C) ///< NFS
#define NDEF_URIPREFIX_FTP (0x0D) ///< FTP
#define NDEF_URIPREFIX_DAV (0x0E) ///< DAV
#define NDEF_URIPREFIX_NEWS (0x0F) ///< NEWS
#define NDEF_URIPREFIX_TELNET (0x10) ///< Telnet prefix
#define NDEF_URIPREFIX_IMAP (0x11) ///< IMAP prefix
#define NDEF_URIPREFIX_RTSP (0x12) ///< RTSP
#define NDEF_URIPREFIX_URN (0x13) ///< URN
#define NDEF_URIPREFIX_POP (0x14) ///< POP
#define NDEF_URIPREFIX_SIP (0x15) ///< SIP
#define NDEF_URIPREFIX_SIPS (0x16) ///< SIPS
#define NDEF_URIPREFIX_TFTP (0x17) ///< TFPT
#define NDEF_URIPREFIX_BTSPP (0x18) ///< BTSPP
#define NDEF_URIPREFIX_BTL2CAP (0x19) ///< BTL2CAP
#define NDEF_URIPREFIX_BTGOEP (0x1A) ///< BTGOEP
#define NDEF_URIPREFIX_TCPOBEX (0x1B) ///< TCPOBEX
#define NDEF_URIPREFIX_IRDAOBEX (0x1C) ///< IRDAOBEX
#define NDEF_URIPREFIX_FILE (0x1D) ///< File
#define NDEF_URIPREFIX_URN_EPC_ID (0x1E) ///< URN EPC ID
#define NDEF_URIPREFIX_URN_EPC_TAG (0x1F) ///< URN EPC tag
#define NDEF_URIPREFIX_URN_EPC_PAT (0x20) ///< URN EPC pat
#define NDEF_URIPREFIX_URN_EPC_RAW (0x21) ///< URN EPC raw
#define NDEF_URIPREFIX_URN_EPC (0x22) ///< URN EPC
#define NDEF_URIPREFIX_URN_NFC (0x23) ///< URN NFC
#define PN532_GPIO_VALIDATIONBIT (0x80) ///< GPIO validation bit
#define PN532_GPIO_P30 (0) ///< GPIO 30
#define PN532_GPIO_P31 (1) ///< GPIO 31
#define PN532_GPIO_P32 (2) ///< GPIO 32
#define PN532_GPIO_P33 (3) ///< GPIO 33
#define PN532_GPIO_P34 (4) ///< GPIO 34
#define PN532_GPIO_P35 (5) ///< GPIO 35
/**
* @brief Class for working with Adafruit PN532 NFC/RFID breakout boards.
*/
class Adafruit_PN532 {
public:
Adafruit_PN532(uint8_t clk, uint8_t miso, uint8_t mosi,
uint8_t ss); // Software SPI
Adafruit_PN532(uint8_t ss, SPIClass *theSPI = &SPI); // Hardware SPI
Adafruit_PN532(uint8_t irq, uint8_t reset,
TwoWire *theWire = &Wire); // Hardware I2C
Adafruit_PN532(uint8_t reset, HardwareSerial *theSer); // Hardware UART
bool begin(void);
void reset(void);
void wakeup(void);
// Generic PN532 functions
bool SAMConfig(void);
uint32_t getFirmwareVersion(void);
bool sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen,
uint16_t timeout = 100);
bool writeGPIO(uint8_t pinstate);
uint8_t readGPIO(void);
bool setPassiveActivationRetries(uint8_t maxRetries);
// ISO14443A functions
bool readPassiveTargetID(
uint8_t cardbaudrate, uint8_t *uid, uint8_t *uidLength,
uint16_t timeout = 0); // timeout 0 means no timeout - will block forever.
bool startPassiveTargetIDDetection(uint8_t cardbaudrate);
bool readDetectedPassiveTargetID(uint8_t *uid, uint8_t *uidLength);
bool inDataExchange(uint8_t *send, uint8_t sendLength, uint8_t *response,
uint8_t *responseLength);
bool inListPassiveTarget();
uint8_t AsTarget();
uint8_t getDataTarget(uint8_t *cmd, uint8_t *cmdlen);
uint8_t setDataTarget(uint8_t *cmd, uint8_t cmdlen);
// Mifare Classic functions
bool mifareclassic_IsFirstBlock(uint32_t uiBlock);
bool mifareclassic_IsTrailerBlock(uint32_t uiBlock);
uint8_t mifareclassic_AuthenticateBlock(uint8_t *uid, uint8_t uidLen,
uint32_t blockNumber,
uint8_t keyNumber, uint8_t *keyData);
uint8_t mifareclassic_ReadDataBlock(uint8_t blockNumber, uint8_t *data);
uint8_t mifareclassic_WriteDataBlock(uint8_t blockNumber, uint8_t *data);
uint8_t mifareclassic_FormatNDEF(void);
uint8_t mifareclassic_WriteNDEFURI(uint8_t sectorNumber,
uint8_t uriIdentifier, const char *url);
// Mifare Ultralight functions
uint8_t mifareultralight_ReadPage(uint8_t page, uint8_t *buffer);
uint8_t mifareultralight_WritePage(uint8_t page, uint8_t *data);
// NTAG2xx functions
uint8_t ntag2xx_ReadPage(uint8_t page, uint8_t *buffer);
uint8_t ntag2xx_WritePage(uint8_t page, uint8_t *data);
uint8_t ntag2xx_WriteNDEFURI(uint8_t uriIdentifier, char *url,
uint8_t dataLen);
// Help functions to display formatted text
static void PrintHex(const byte *data, const uint32_t numBytes);
static void PrintHexChar(const byte *pbtData, const uint32_t numBytes);
private:
int8_t _irq = -1, _reset = -1, _cs = -1;
int8_t _uid[7]; // ISO14443A uid
int8_t _uidLen; // uid len
int8_t _key[6]; // Mifare Classic key
int8_t _inListedTag; // Tg number of inlisted tag.
// Low level communication functions that handle both SPI and I2C.
void readdata(uint8_t *buff, uint8_t n);
void writecommand(uint8_t *cmd, uint8_t cmdlen);
bool isready();
bool waitready(uint16_t timeout);
bool readack();
Adafruit_SPIDevice *spi_dev = NULL;
Adafruit_I2CDevice *i2c_dev = NULL;
HardwareSerial *ser_dev = NULL;
};
#endif

73
src/audioState.h Normal file
View file

@ -0,0 +1,73 @@
#pragma once
#include <Arduino.h>
#include <DFRobotDFPlayerMini.h>
#include <LiquidCrystal.h>
void printMp3Detail(LiquidCrystal* lcd, uint8_t type, int value)
{
lcd->clear();
switch (type)
{
case TimeOut:
lcd->print("Time Out!");
break;
case WrongStack:
lcd->print("Stack Wrong!");
break;
case DFPlayerCardInserted:
lcd->print("Card Inserted!");
break;
case DFPlayerCardRemoved:
lcd->print("Card Removed!");
break;
case DFPlayerCardOnline:
lcd->print("Card Online!");
break;
case DFPlayerUSBInserted:
lcd->print("USB Inserted!");
break;
case DFPlayerUSBRemoved:
lcd->print("USB Removed!");
break;
case DFPlayerPlayFinished:
lcd->print("Num:");
lcd->print(value);
lcd->print(" Finished!");
break;
case DFPlayerError:
lcd->print("DFPlayerError:");
switch (value)
{
case Busy:
lcd->print("Card not found");
break;
case Sleeping:
lcd->print("Sleeping");
break;
case SerialWrongStack:
lcd->print("Wrong Stack");
break;
case CheckSumNotMatch:
lcd->print("Checksum Error");
break;
case FileIndexOut:
lcd->print("File Index OOB");
break;
case FileMismatch:
lcd->print("File Mismatch");
break;
case Advertise:
lcd->print("In Advertise");
break;
default:
lcd->print("Unknown Error");
break;
}
break;
default:
lcd->print("Unknown Type");
break;
}
delay(2000); // Display the message for 2 seconds
}

17
src/context.cpp Normal file
View file

@ -0,0 +1,17 @@
#include "Context.h"
Context::Context(Station* stations, const int stationCount, const unsigned long delta, DFRobotDFPlayerMini* dfPlayer) {
this->stations = stations;
this->stationCount = stationCount;
this->delta = delta;
this->dfPlayer = dfPlayer;
}
int Context::getStationIndex(const Station* station) const
{
for (int i = 0; i < stationCount; ++i) {
if (&stations[i] == station) {
return i;
}
}
return -1;
}

15
src/context.h Normal file
View file

@ -0,0 +1,15 @@
#pragma once
#include <DFRobotDFPlayerMini.h>
#include "station.h"
class Context {
public:
Context(Station* stations, int stationCount, unsigned long delta, DFRobotDFPlayerMini* dfPlayer);
Station* stations;
int stationCount;
unsigned long delta;
DFRobotDFPlayerMini* dfPlayer;
int getStationIndex(const Station* station) const;
};

185
src/main.cpp Normal file
View file

@ -0,0 +1,185 @@
#include <LiquidCrystal.h>
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_PN532.h>
#include <SoftwareSerial.h>
#include <DFRobotDFPlayerMini.h>
#include "station.h"
#include "statemachine.h"
#include "state.h"
#include "states.h"
#include "timer.h"
#include "audioState.h"
#define PN532_CS 10
// Using this library to set a timeout on readPassiveTagID
// The library in use is slightly modified to fix this issue: https://github.com/adafruit/Adafruit-PN532/issues/117
Adafruit_PN532 nfc(PN532_CS);
constexpr int rs = 9, en = 8, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
SoftwareSerial softSerial(6, 7); // RX, TX
DFRobotDFPlayerMini dfPlayer;
Station stations[5] = {
Station(1680767519, "Yellow"), Station(3346823711, "Green"), Station(3569318175, "Pink"),
Station(2174777887, "Blue"), Station(102951984, "Weird")
};
Station* currentStation;
int currentStationIndex = -1;
Timer stationDetectionTimer(500, true);
String previousDisplayContent;
StateMachine stateMachine(new Startup());
unsigned long lastLoopTime = 0;
unsigned long currentLoopTime = 0;
unsigned long deltaTime = 0;
void setupNFC()
{
nfc.begin();
uint32_t versiondata = nfc.getFirmwareVersion();
if (!versiondata)
{
while (1); // halt
}
// configure board to read RFID tags and cards
nfc.SAMConfig();
}
Station* detectStation()
{
uint8_t uid[7];
uint8_t uidLength;
constexpr uint16_t timeout = 100;
const bool success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength, timeout);
if (!success)
{
return nullptr;
}
uint32_t id = 0;
for (uint8_t i = 0; i < uidLength; i++)
{
id <<= 8;
id |= uid[i];
}
Station* found = 0;
for (unsigned int i = 0; i < sizeof(stations) / sizeof(stations[0]); i++)
{
Station* currentStation = &stations[i];
if (currentStation->check(id))
{
found = currentStation;
}
}
return found;
}
void checkStations()
{
Station* station = detectStation();
if (station != nullptr)
{
if (currentStation == nullptr)
{
currentStation = station;
stateMachine.putDown(Context(stations, sizeof(stations) / sizeof(stations[0]), deltaTime, &dfPlayer), currentStation);
}
}
else
{
if (currentStation != nullptr)
{
currentStation = nullptr;
stateMachine.pickedUp(Context(stations, sizeof(stations) / sizeof(stations[0]), deltaTime, &dfPlayer));
}
}
}
void printString(const String& str)
{
int currentColumn = 0;
int currentRow = 0;
lcd.clear();
for (unsigned int i = 0; i < str.length(); i++)
{
lcd.setCursor(currentColumn, currentRow);
lcd.print(str[i]);
currentColumn++;
if (currentColumn >= 16)
{
currentColumn = 0;
currentRow++;
if (currentRow >= 2)
{
break;
}
}
}
}
void loop(void)
{
currentLoopTime = millis();
deltaTime = currentLoopTime - lastLoopTime;
bool doCheck = stationDetectionTimer.update(deltaTime);
if (doCheck)
{
checkStations();
}
stateMachine.update(Context(stations, sizeof(stations) / sizeof(stations[0]), deltaTime, &dfPlayer));
String newContent = stateMachine.updateDisplay();
if (previousDisplayContent != newContent)
{
lcd.clear();
printString(newContent);
previousDisplayContent = newContent;
}
lastLoopTime = currentLoopTime;
delay(10);
}
void setup(void)
{
setupNFC();
Serial.begin(9600);
lcd.begin(16, 2);
stationDetectionTimer.start();
softSerial.begin(9600);
lcd.print("Initializing MP3");
lcd.clear();
if (!dfPlayer.begin(softSerial, true, true))
{
lcd.print("Failed to init");
lcd.setCursor(0, 1);
lcd.print("DFPlayer!");
while (true)
{
delay(100);
printMp3Detail(&lcd, dfPlayer.readType(), dfPlayer.read());
}
}
// dfPlayer.volume(15);
// dfPlayer.play(1);
}

10
src/sounds.h Normal file
View file

@ -0,0 +1,10 @@
#include <Arduino.h>
#define IDLE 1
#define WRONG_SIDE_STATION 2
#define TIMER_DOWN 3
#define GAME_WON 4
#define REMOVED_FROM_SIDE_STATION 5
#define REMOVED_FROM_MAIN_STATION 6
#define OBJECT_PLACED_ON_MAIN_STATION 7
#define OBJECT_PLACED_ON_SIDE_STATION 8

17
src/state.h Normal file
View file

@ -0,0 +1,17 @@
#pragma once
#include "station.h"
#include "context.h"
class Station;
class State
{
public:
virtual ~State() = default;
virtual State* pickedUp(Context context) { return this; }
virtual State* putDown(Context context, Station* newStation) { return this; }
virtual State* update(Context context) { return this; }
virtual String updateDisplay() { return ""; }
};

37
src/statemachine.cpp Normal file
View file

@ -0,0 +1,37 @@
#include "statemachine.h"
#include "station.h"
#include "context.h"
StateMachine::StateMachine(State* initialState)
: currentState(initialState) {}
StateMachine::~StateMachine() {
delete currentState;
}
void StateMachine::updateState(State* newState) {
if (newState != currentState) {
delete currentState;
currentState = newState;
}
}
void StateMachine::pickedUp(const Context& context) {
State* newState = currentState->pickedUp(context);
updateState(newState);
}
void StateMachine::putDown(const Context& context, Station* newStation) {
State* newState = currentState->putDown(context, newStation);
updateState(newState);
}
void StateMachine::update(const Context& context) {
State* newState = currentState->update(context);
updateState(newState);
}
String StateMachine::updateDisplay() const
{
return currentState->updateDisplay();
}

21
src/statemachine.h Normal file
View file

@ -0,0 +1,21 @@
#pragma once
#include <LiquidCrystal.h>
#include "state.h"
#include "station.h"
#include "context.h"
class StateMachine {
private:
State* currentState;
void updateState(State* newState);
public:
StateMachine(State* initialState);
~StateMachine();
void pickedUp(const Context& context);
void putDown(const Context& context, Station* newStation);
void update(const Context& context);
String updateDisplay() const;
};

213
src/states.cpp Normal file
View file

@ -0,0 +1,213 @@
#include "states.h"
#include "state.h"
#include "station.h"
Startup::Startup() = default;
State* Startup::putDown(const Context context, Station* newStation)
{
const int newStationIndex = context.getStationIndex(newStation);
if (newStationIndex == 0)
{
return new WaitingForGameStart();
}
return this;
}
State* Startup::update(Context context)
{
return this;
}
String Startup::updateDisplay()
{
return "Initializing:Put"
"on first station";
}
//------------------------------------
WaitingForGameStart::WaitingForGameStart() = default;
State* WaitingForGameStart::pickedUp(const Context context)
{
return new OnTheMove(context.stations + 1); // first element of the array
}
State* WaitingForGameStart::update(Context context)
{
return this;
}
String WaitingForGameStart::updateDisplay()
{
return "Waiting for Game"
"Start...";
}
//------------------------------------
OnTheMove::OnTheMove(Station* targetStation)
{
this->targetStation = targetStation;
}
State* OnTheMove::putDown(const Context context, Station* newStation)
{
if (newStation == this->targetStation)
{
if (targetStation == context.stations) // first station
{
return new End();
}
return new Hacking(this->targetStation);
}
return new IncorrectStation(targetStation);
}
State* OnTheMove::update(const Context context)
{
return this;
}
String OnTheMove::updateDisplay()
{
return "On the Move... ";
}
//------------------------------------
IncorrectStation::IncorrectStation(Station* targetStation)
{
this->targetStation = targetStation;
}
State* IncorrectStation::pickedUp(const Context context)
{
return new OnTheMove(this->targetStation);
}
State* IncorrectStation::update(const Context context)
{
return this;
}
String IncorrectStation::updateDisplay()
{
return "Wrong Station! ";
}
//------------------------------------
Hacking::Hacking(Station* currentStation): timer(5000, false)
{
this->currentStation = currentStation;
this->timer.start();
}
State* Hacking::pickedUp(const Context context)
{
return new Complain(currentStation);
}
State* Hacking::update(const Context context)
{
Serial.println(String(context.delta));
const bool done = timer.update(context.delta);
if (done)
{
const int currentStationIndex = context.getStationIndex(currentStation);
const int nextStationIndex = (currentStationIndex + 1) % context.stationCount;
Station* nextStation = context.stations + nextStationIndex;
return new WaitingForPickup(currentStation, nextStation);
}
return this;
}
String Hacking::updateDisplay()
{
return "Hacking B)";
}
//------------------------------------
Complain::Complain(Station* currentStation)
{
this->currentStation = currentStation;
}
State* Complain::putDown(const Context context, Station* newStation)
{
if (this->currentStation == newStation) // was put back on correct station
{
return new Hacking(this->currentStation);
}
return this; // was not put back on correct station (just keeps complaining)
}
State* Complain::update(Context context)
{
return this;
}
String Complain::updateDisplay()
{
return "Put me back!!";
}
//------------------------------------
WaitingForPickup::WaitingForPickup(Station* currentStation, Station* targetStation)
{
this->currentStation = currentStation;
this->targetStation = targetStation;
}
State* WaitingForPickup::pickedUp(Context context)
{
return new OnTheMove(targetStation);
}
State* WaitingForPickup::update(Context context)
{
return this;
}
String WaitingForPickup::updateDisplay()
{
return "Pick me up ";
}
End::End() = default;
State* End::pickedUp(const Context context)
{
// todo what happens when we pick up here?...
return this;
}
State* End::update(const Context context)
{
// todo after some time return waiting for game start...
return this;
}
String End::updateDisplay()
{
return "END...";
}

98
src/states.h Normal file
View file

@ -0,0 +1,98 @@
#pragma once
#include <timer.h>
#include "context.h"
#include "state.h"
#include "states.h"
#include "station.h"
class Startup final : public State
{
public:
Startup();
State* putDown(Context context, Station* newStation) override;
State* update(Context context) override;
String updateDisplay() override;
};
class WaitingForGameStart final : public State
{
public:
WaitingForGameStart();
State* pickedUp(Context context) override;
State* update(Context context) override;
String updateDisplay() override;
};
class OnTheMove final : public State
{
private:
Station* targetStation;
public:
explicit OnTheMove(Station* targetStation);
State* putDown(Context context, Station* newStation) override;
State* update(Context context) override;
String updateDisplay() override;
};
class IncorrectStation final : public State
{
private:
Station* targetStation;
public:
explicit IncorrectStation(Station* targetStation);
State* pickedUp(Context context) override;
State* update(Context context) override;
String updateDisplay() override;
};
class Hacking final : public State
{
private:
Timer timer;
Station* currentStation;
public:
explicit Hacking(Station* currentStation);
State* pickedUp(Context context) override;
State* update(Context context) override;
String updateDisplay() override;
};
class Complain final : public State
{
private:
Station* currentStation;
public:
explicit Complain(Station* currentStation);
State* putDown(Context context, Station* newStation) override;
State* update(Context context) override;
String updateDisplay() override;
};
class WaitingForPickup final : public State
{
private:
Station* currentStation;
Station* targetStation;
public:
WaitingForPickup(Station* currentStation, Station* targetStation);
State* pickedUp(Context context) override;
State* update(Context context) override;
String updateDisplay() override;
};
class End final : public State
{
public:
End();
State* pickedUp(Context context) override;
State* update(Context context) override;
String updateDisplay() override;
};

17
src/station.cpp Normal file
View file

@ -0,0 +1,17 @@
#include <Arduino.h>
#include "station.h"
Station::Station(uint32_t nfcTagId, String name) {
{
this->nfcTagId = nfcTagId;
this->name = name;
}
}
bool Station::check(uint32_t nfcTagId) {
return nfcTagId == this->nfcTagId;
}
String Station::getName() {
return this->name;
}

12
src/station.h Normal file
View file

@ -0,0 +1,12 @@
#pragma once
#include <Arduino.h>
class Station {
private:
uint32_t nfcTagId;
String name;
public:
Station(uint32_t nfcTagId, String name);
bool check(uint32_t nfcTagId);
String getName();
};

47
src/timer.cpp Normal file
View file

@ -0,0 +1,47 @@
#include "timer.h"
#include <HardwareSerial.h>
Timer::Timer(const unsigned long duration, const bool autoRestart): currentTime(0), running(false)
{
this->autoRestart = autoRestart;
this->duration = duration;
this->endTime = duration;
}
void Timer::start()
{
this->running = true;
}
bool Timer::update(const unsigned long delta)
{
Serial.print("Timer ");
if (!running)
{
Serial.print(" not running...");
return false;
}
bool timedOut = false;
this->currentTime += delta;
Serial.print(" target : " + String(this->currentTime) + "/" + String(this->endTime));
if (currentTime > this->endTime)
{
timedOut = true;
}
if (timedOut && this->autoRestart)
{
this->endTime += this->duration;
}
if (timedOut && !this->autoRestart)
{
running = false;
}
Serial.println();
return timedOut;
}
bool Timer::isRunning() const
{
return this->running;
}

17
src/timer.h Normal file
View file

@ -0,0 +1,17 @@
#pragma once
class Timer {
private:
unsigned long duration;
bool autoRestart;
unsigned long currentTime;
unsigned long endTime;
bool running;
public:
Timer(unsigned long duration, bool autoRestart);
void start();
bool update(unsigned long delta);
bool isRunning() const;
};

11
test/README Normal file
View file

@ -0,0 +1,11 @@
This directory is intended for PlatformIO Test Runner and project tests.
Unit Testing is a software testing method by which individual units of
source code, sets of one or more MCU program modules together with associated
control data, usage procedures, and operating procedures, are tested to
determine whether they are fit for use. Unit testing finds problems early
in the development cycle.
More information about PlatformIO Unit Testing:
- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html