MicroGirs.ino

Go to the documentation of this file.

 
// Change the following two entries if desired
 
#define INPUTPIN 5
 
#define BAUDRATE 115200
 
#include <IRremote.h>
#include <limits.h>
 
#define RECEIVE
 
#define TRANSMIT
 
// (The sending pin is in general not configurable, see the documentation of IRremote.)
 
#define EOLCHAR '\r'
 
 
#ifdef TRANSMIT
#ifdef RECEIVE
#define modulesSupported "base transmit receive"
#else // ! RECEIVE
#define modulesSupported "base transmit"
#endif
#else // !TRANSMIT
#ifdef RECEIVE
#define modulesSupported "base receive"
#else // ! RECETVE
#error At lease one of TRANSMIT and RECEIVE must be defined
#endif
#endif
 
#define PROGNAME "MicroGirs"
 
#define VERSION "2020-07-05"
 
#define okString "OK"
#define errorString "ERROR"
#define timeoutString "."
 
// For compatibility with IRremote, we deliberately use
// the platform dependent types.
// (Although it is a questionable idea ;-) )
typedef unsigned frequency_t; // max 65535, unless 32-bit
 
typedef unsigned microseconds_t; // max 65535, unless 32-bit
 
static const microseconds_t DUMMYENDING = 40000U;
static const frequency_t FREQUENCY_T_MAX = UINT16_MAX;
static const frequency_t MICROSECONDS_T_MAX = UINT16_MAX;
 
#ifdef RECEIVE
 
IRrecv irRecv(INPUTPIN);
#endif
 
#ifdef TRANSMIT
/*}
 * Instance of the IRremote class.
 */
IRsend irSend;
#endif
 
class Tokenizer {
private:
    static const int invalidIndex = -1;
 
    int index; // signed since invalidIndex is possible
    const String& payload;
    void trim();
 
public:
    Tokenizer(const String &str);
    virtual ~Tokenizer();
 
    String getToken();
    String getRest();
    String getLine();
    long getInt();
    microseconds_t getMicroseconds();
    frequency_t getFrequency();
 
    static const int invalid = INT_MAX;
};
 
Tokenizer::Tokenizer(const String& str) : index(0), payload(str) {
}
 
Tokenizer::~Tokenizer() {
}
 
String Tokenizer::getRest() {
    String result = index == invalidIndex ? String("") : payload.substring(index);
    index = invalidIndex;
    return result;
}
 
String Tokenizer::getLine() {
    if (index == invalidIndex)
        return String("");
 
    int i = payload.indexOf('\n', index);
    String s = (i > 0) ? payload.substring(index, i) : payload.substring(index);
    index = (i > 0) ? i+1 : invalidIndex;
    return s;
}
 
String Tokenizer::getToken() {
    if (index < 0)
        return String("");
 
    int i = payload.indexOf(' ', index);
    String s = (i > 0) ? payload.substring(index, i) : payload.substring(index);
    index = (i > 0) ? i : invalidIndex;
    if (index != invalidIndex)
    if (index != invalidIndex)
        while (payload.charAt(index) == ' ')
            index++;
    return s;
}
 
long Tokenizer::getInt() {
    String token = getToken();
    return token == "" ? (long) invalid : token.toInt();
}
 
microseconds_t Tokenizer::getMicroseconds() {
    long t = getToken().toInt();
    return (microseconds_t) ((t < MICROSECONDS_T_MAX) ? t : MICROSECONDS_T_MAX);
}
 
frequency_t Tokenizer::getFrequency() {
    long t = getToken().toInt();
    return (frequency_t) ((t < FREQUENCY_T_MAX) ? t : FREQUENCY_T_MAX);
}
 
#ifdef TRANSMIT
static inline unsigned hz2khz(frequency_t hz) {
    return (hz + 500)/1000;
}
 
static void sendRaw(const microseconds_t intro[], unsigned lengthIntro,
        const microseconds_t repeat[], unsigned lengthRepeat,
        const microseconds_t ending[], unsigned lengthEnding,
        frequency_t frequency, unsigned times) {
    if (lengthIntro > 0U)
        irSend.sendRaw(intro, lengthIntro, hz2khz(frequency));
    if (lengthRepeat > 0U)
        for (unsigned i = 0U; i < times - (lengthIntro > 0U); i++)
            irSend.sendRaw(repeat, lengthRepeat, hz2khz(frequency));
    if (lengthEnding > 0U)
        irSend.sendRaw(ending, lengthEnding, hz2khz(frequency));
}
#endif // TRANSMIT
 
#ifdef RECEIVE
 
static void receive(Stream& stream) {
    irRecv.enableIRIn();
    irRecv.resume(); // Receive the next value
    decode_results results;
 
    while (!irRecv.decode(&results)) {
    }
    irRecv.disableIRIn();
 
    dump(stream, &results);
}
 
static void dump(Stream& stream, decode_results* results) {
    unsigned int count = results->rawlen;
    // If buffer gets full, count = RAW_BUFFER_LENGTH, which is odd,
    // and IrScrutinizer does not like that.
    count &=  ~1;
    for (unsigned int i = 1; i < count; i++) {
        stream.write(i & 1 ? '+' : '-');
        stream.print(results->rawbuf[i] * USECPERTICK, DEC);
        stream.print(" ");
    }
    stream.print('-');
    stream.println(DUMMYENDING);
}
#endif // RECEIVE
 
void setup() {
    Serial.begin(BAUDRATE);
    while (!Serial)
        ; // wait for serial port to connect.
 
    Serial.println(F(PROGNAME " " VERSION));
    //Serial.setTimeout(SERIALTIMEOUT);
/*
#ifdef RECEIVE
    // There is unfortunately no disableIRIn in IRremote.
    // Therefore, turn it on, and leave it on.
    // We _hope_ that it will not interfere with sending.
    irRecv.enableIRIn();
#endif
*/
}
 
 
static String readCommand(Stream& stream) {
    while (stream.available() == 0) {
    }
 
    String line = stream.readStringUntil(EOLCHAR);
    line.trim();
    return line;
}
 
static void processCommand(const String& line, Stream& stream) {
    Tokenizer tokenizer(line);
    String cmd = tokenizer.getToken();
 
    // Decode the command in cmd
    if (cmd.length() == 0) {
        // empty command, do nothing
        stream.println(F(okString));
        return;
    }
 
    switch (cmd[0]) {
        case 'm':
            stream.println(F(modulesSupported));
            break;
 
#ifdef RECEIVE
        case 'r': // receive
        //case 'a':
        //case 'c':
            receive(stream);
            break;
#endif // RECEIVE
 
#ifdef TRANSMIT
        case 's': // send
        {
            // TODO: handle unparsable data gracefully
            unsigned noSends = (unsigned) tokenizer.getInt();
            frequency_t frequency = tokenizer.getFrequency();
            unsigned introLength = (unsigned) tokenizer.getInt();
            unsigned repeatLength = (unsigned) tokenizer.getInt();
            unsigned endingLength = (unsigned) tokenizer.getInt();
            microseconds_t intro[introLength];
            microseconds_t repeat[repeatLength];
            microseconds_t ending[endingLength];
            for (unsigned i = 0; i < introLength; i++)
                intro[i] = tokenizer.getMicroseconds();
            for (unsigned i = 0; i < repeatLength; i++)
                repeat[i] = tokenizer.getMicroseconds();
            for (unsigned i = 0; i < endingLength; i++)
                ending[i] = tokenizer.getMicroseconds();
            sendRaw(intro, introLength, repeat, repeatLength, ending, endingLength, frequency, noSends);
            stream.println(F(okString));
        }
            break;
#endif // TRANSMIT
 
        case 'v': // version
            stream.println(F(PROGNAME " " VERSION));
            break;
        default:
            stream.println(F(errorString));
    }
}
 
void loop() {
    String line = readCommand(Serial);
    processCommand(line, Serial);
}