sm130.hpp

/*
 * Author: Jon Trulson <jtrulson@ics.com>
 * Copyright (c) 2015 Intel Corporation.
 *
 * 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.
 */
#pragma once

#include <string>
#include <iostream>

#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <sys/time.h>
#include <sys/select.h>
#include <sys/types.h>
#include <sys/stat.h>

#include <mraa/common.hpp>
#include <mraa/uart.hpp>
#include <mraa/gpio.hpp>

#define SM130_DEFAULT_UART 0
#define SM130_DEFAULT_RESET_PIN 13

namespace upm {
  
  class SM130 {
    
  public:

    // Valid commands
    typedef enum {
      CMD_RESET                  = 0x80,
      CMD_VERSION                = 0x81,
      CMD_SEEK_TAG               = 0x82,
      CMD_SELECT_TAG             = 0x83,
      CMD_AUTHENTICATE           = 0x85,
      CMD_READ16                 = 0x86,
      CMD_READ_VALUE             = 0x87,
      CMD_WRITE16                = 0x89,
      CMD_WRITE_VALUE            = 0x8a,
      CMD_WRITE4                 = 0x8b,
      CMD_WRITE_KEY              = 0x8c,
      CMD_INC_VALUE              = 0x8d,
      CMD_DEC_VALUE              = 0x8e,
      CMD_ANTENNA_POWER          = 0x90,
      CMD_READ_PORT              = 0x91,
      CMD_WRITE_PORT             = 0x92,
      CMD_HALT_TAG               = 0x93,
      CMD_SET_BAUD               = 0x94,
      CMD_SLEEP                  = 0x96
    } CMD_T;

    // valid tag types.
    typedef enum {
      TAG_NONE                   = 0x00, // error/invalid

      TAG_MIFARE_ULTRALIGHT      = 0x01,
      TAG_MIFARE_1K              = 0x02,
      TAG_MIFARE_4K              = 0x03,
      TAG_UNKNOWN                = 0xff
    } TAG_TYPE_T;    

    // Valid authentication keys
    typedef enum {
      KEY_TYPE_EEPROM_A0         = 0x10,
      KEY_TYPE_EEPROM_A1         = 0x11,
      KEY_TYPE_EEPROM_A2         = 0x12,
      KEY_TYPE_EEPROM_A3         = 0x13,
      KEY_TYPE_EEPROM_A4         = 0x14,
      KEY_TYPE_EEPROM_A5         = 0x15,
      KEY_TYPE_EEPROM_A6         = 0x16,
      KEY_TYPE_EEPROM_A7         = 0x17,
      KEY_TYPE_EEPROM_A8         = 0x18,
      KEY_TYPE_EEPROM_A9         = 0x19,
      KEY_TYPE_EEPROM_A10        = 0x1a,
      KEY_TYPE_EEPROM_A11        = 0x1b,
      KEY_TYPE_EEPROM_A12        = 0x1c,
      KEY_TYPE_EEPROM_A13        = 0x1d,
      KEY_TYPE_EEPROM_A14        = 0x1e,
      KEY_TYPE_EEPROM_A15        = 0x1f,

      KEY_TYPE_EEPROM_B0         = 0x20,
      KEY_TYPE_EEPROM_B1         = 0x21,
      KEY_TYPE_EEPROM_B2         = 0x22,
      KEY_TYPE_EEPROM_B3         = 0x23,
      KEY_TYPE_EEPROM_B4         = 0x24,
      KEY_TYPE_EEPROM_B5         = 0x25,
      KEY_TYPE_EEPROM_B6         = 0x26,
      KEY_TYPE_EEPROM_B7         = 0x27,
      KEY_TYPE_EEPROM_B8         = 0x28,
      KEY_TYPE_EEPROM_B9         = 0x29,
      KEY_TYPE_EEPROM_B10        = 0x2a,
      KEY_TYPE_EEPROM_B11        = 0x2b,
      KEY_TYPE_EEPROM_B12        = 0x2c,
      KEY_TYPE_EEPROM_B13        = 0x2d,
      KEY_TYPE_EEPROM_B14        = 0x2e,
      KEY_TYPE_EEPROM_B15        = 0x2f,

      KEY_TYPE_A                 = 0xaa,
      KEY_TYPE_B                 = 0xbb,

      KEY_TYPE_A_AND_TRANSPORT_F = 0xff
    } KEY_TYPES_T;

    SM130 (int uart=SM130_DEFAULT_UART, int reset=SM130_DEFAULT_RESET_PIN);

    ~SM130 ();

    mraa::Result setBaudRate(int baud=19200);

    std::string getFirmwareVersion();

    bool reset();

    void hardwareReset();

    bool select();

    bool waitForTag(uint32_t timeout);

    bool authenticate(uint8_t block, KEY_TYPES_T keyType, std::string key="");

    std::string readBlock16(uint8_t block);

    int32_t readValueBlock(uint8_t block);

    bool writeBlock16(uint8_t block, std::string contents);

    bool writeValueBlock(uint8_t block, int32_t value);

    bool writeBlock4(uint8_t block, std::string contents);

    bool writeKey(uint8_t eepromSector, KEY_TYPES_T keyType, std::string key);

    int32_t adjustValueBlock(uint8_t block, int32_t value, bool incr);

    bool setAntennaPower(bool on);

    uint8_t readPorts();

    bool writePorts(uint8_t val);

    bool haltTag();

    bool setSM130BaudRate(int baud);

    bool sleep();

    char getLastErrorCode() { return m_lastErrorCode; };

    std::string getLastErrorString() { return m_lastErrorString; };

    int getUIDLen() { return m_uidLen; };

    std::string getUID() { return m_uid; };

    TAG_TYPE_T getTagType() { return m_tagType; };

    std::string tag2String(TAG_TYPE_T tag);

    std::string string2HexString(std::string input);

  protected:
    mraa::Uart m_uart;
    mraa::Gpio m_gpioReset;

    std::string sendCommand(CMD_T cmd, std::string data);
    void initClock();
    uint32_t getMillis();

  private:
    int m_uidLen;
    std::string m_uid;

    char m_lastErrorCode;
    std::string m_lastErrorString;

    TAG_TYPE_T m_tagType;

    int m_baud;

    struct timeval m_startTime;

    void clearError()
    { 
      m_lastErrorCode = 0;
      m_lastErrorString.clear();
    }
  };

}