Raspberries/upm
Public Access
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cpp_headers: Renamed C++ headers from .h -> .hpp

Browse Source 
To make room for UPM C and C++ sensor code to coexist, all UPM
C++ headers have been renamed from h -> hpp.  This commit contains
updates to documentation, includes, cmake collateral, examples, and
swig interface files.

    * Renamed all cxx/cpp header files which contain the string
    'copyright intel' from .h -> .hpp (if not already hpp).

    * Replaced all references to .h with .hpp in documentation,
    source files, cmake collateral, example code, and swig interface
    files.

    * Replaced cmake variable module_h with module_hpp.

    * Intentionally left upm.h since this file currently does not
    contain code (documentation only).

Signed-off-by: Noel Eck <noel.eck@intel.com>
This commit is contained in:
Noel Eck
2016-04-25 14:27:51 -07:00
parent b3a8fd7172
commit 922e0cc26b
1177 changed files with 1697 additions and 1699 deletions
Download Patch File Download Diff File Expand all files Collapse all files

467
src/sm130/sm130.hpp Normal file
View File

@@ -0,0 +1,467 @@
/*
* 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 {
/**
* @brief SM130 RFID Reader Module library
* @defgroup sm130 libupm-sm130
* @ingroup sparkfun uart gpio rfid
*/
/**
* @library sm130
* @sensor sm130
* @comname SM130 RFID Reader
* @type rfid
* @man sparkfun
* @web https://www.sparkfun.com/products/10126
* @con uart gpio
*
* @brief API for the SM130 RFID Reader Module
*
* This module defines the SM130 interface for the sm130 RFID library
*
* This module was developed using an SM130 and a Sparkfun RFID
* Evaluation shield using a UART for communications. It should be
* fairly trivial to add support for I2C communication in the
* future, if you have the correct firmware on the SM130.
*
* @image html sm130.jpg
* <br><em>SM130 RFID Reader image provided by SparkFun* under
* <a href=https://creativecommons.org/licenses/by-nc-sa/3.0/>
* CC BY-NC-SA-3.0</a>.</em>
*
* @snippet sm130.cxx Interesting
*/
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;
/**
* Instantiates an SM130 object
*
* @param uart The UART port. Default is 0.
* @param reset The Reset pin. Default is 13.
*/
SM130 (int uart=SM130_DEFAULT_UART, int reset=SM130_DEFAULT_RESET_PIN);
/**
* SM130 object destructor
*/
~SM130 ();
/**
* Sets the baud rate for the device. The default is 19200.
*
* @param baud Desired baud rate, default 19200
* @return mraa::Result value
*/
mraa::Result setBaudRate(int baud=19200);
/**
* Gets the firmware version string.
*
* @return The firmware revision
*/
std::string getFirmwareVersion();
/**
* Issues a reset command to the device.
*
* @return true if successful
*/
bool reset();
/**
* Resets the device using the hardware RESET pin. This is
* required if the device has been put to sleep using the sleep()
* method.
*/
void hardwareReset();
/**
* Checks to see if a tag is in the RF field, and selects it if
* one is present.
*
* @return true if a tag was detected, false if no tag is present
* or an error was detected.
*/
bool select();
/**
* Waits for a tag to enter the RF field for up to 'timeout'
* milliseconds. It will call select() every 100ms until 'timeout'
* has been exceeded.
*
* @param timeout The number of milliseconds to wait for a tag to appear
* @return true if a tag was detected, false if no tag was
* detected within the timeout value, or an error occurred
*/
bool waitForTag(uint32_t timeout);
/**
* Set the authentication key for a block. Depending on the
* permissions on the tag, the correct key must be authenticated
* for that block in order to perform read and write operations.
*
* @param block The block to authenticate for
* @param keyType one of the KEY_TYPE_T values
* @param key The 6 byte key to use for Type A and Type B keys
* @return true if authentication was successful, false otherwise
*/
bool authenticate(uint8_t block, KEY_TYPES_T keyType, std::string key="");
/**
* Read a 16 byte block. Depending on the tag, authentication of
* the block may be required for this method to succeed.
*
* @param block The block to read
* @return The 16 byte block if successful, an empty string otherwise
*/
std::string readBlock16(uint8_t block);
/**
* Read a 4 byte value block. Depending on the tag, authentication of
* the block may be required for this method to succeed.
*
* @param block The block to read
* @return The 4 byte signed integer value block if successful, 0 otherwise
*/
int32_t readValueBlock(uint8_t block);
/**
* Write 16 bytes to a block. Depending on the tag, authentication of
* the block may be required for this method to succeed.
*
* @param block The block to write
* @param contents A 16 byte string containing the data to write
* @return true if successful, false otherwise
*/
bool writeBlock16(uint8_t block, std::string contents);
/**
* Write to a 4 byte value block. Depending on the tag,
* authentication of the block may be required for this method to
* succeed.
*
* @param block The block to write
* @param value the signed 4 byte integer to write to the value block
* @return true if successful, false otherwise
*/
bool writeValueBlock(uint8_t block, int32_t value);
/**
* Write 4 bytes to a block. This is typically used for
* Ultralight tags. Depending on the tag, authentication of the
* block may be required for this method to succeed.
*
* @param block The block to write
* @param contents A 4 byte string containing the data to write
* @return true if successful, false otherwise
*/
bool writeBlock4(uint8_t block, std::string contents);
/**
* Write a key into one of the 16 EEPROM key slots. This can be a
* Type A or Type B key. It is not possible to read these keys
* once written. Once stored, the key can be used for
* authentication without having to send the key itself. You can
* then use the appropriate KEY_TYPE_EEPROM_* keyTypes in a call
* to authenticate().
*
* @param eepromSector A number between 0 and 15, indicating the
* EEPROM sector you want to store the key in
* @param keyType Either KEY_TYPE_A or KEY_TYPE_B
* @param key The 6 byte key to store in the EEPROM
* @return true if successful, false otherwise
*/
bool writeKey(uint8_t eepromSector, KEY_TYPES_T keyType, std::string key);
/**
* Increment or decrement a value block.
*
* @param block The block to adjust
* @param value The number to increment or decrement the value block by
* @param incr true to increment, false to decrement
* @return The contents of the value block after the operation has
* completed.
*/
int32_t adjustValueBlock(uint8_t block, int32_t value, bool incr);
/**
* Turn the antenna power on or off. The power is on by default
* after a reset. If you turn off the antenna, and methods used
* for interacting with tags will fail until power is re-enabled.
*
* @param on true to enable antenna power, false to disable
* @return true if successful, false otherwise
*/
bool setAntennaPower(bool on);
/**
* Read the status of the 2 onboard GPIO input pins. Bit 0 is for
* input 0, bit 1 for input 1. All other bits will be 0.
*
* @return bitmask of input port status values
*/
uint8_t readPorts();
/**
* Set the output status of the 2 onboard gpio outputs. Bit 0 is for
* output 0, bit 1 for output 1. All other bits will be discarded.
*
* @param val bitmask of output status bits to write
* @return true if successful, false otherwise
*/
bool writePorts(uint8_t val);
/**
* Halts a tag. Once a tag is halted, it cannot be accessed until
* it is removed and reinserted into the RF field and selected.
*
* @return true if successful, false otherwise
*/
bool haltTag();
/**
* Changes the baud rate of the SM130. WARNING: This is a
* potentially dangerous command that could cause you to lose
* contact with the device. Once the command is validated and
* issued, the host baudrate will be changed to match, and this
* method will wait for a response at the new baudrate for up to 1
* second.
*
* If this response does not arrive, the old baudrate will be
* restored, though there is no way to know whether the SM130
* actually succeessfully executed the baudrate change.
*
* Once the SM130 has changed it's baudrate, the new value will be
* stored in it's EEPROM, and any further access to the device
* will need to use the new baudrate. This is true even after a
* power on reset.
*
* @param baud The new baud rate to set. Valid values are 9600,
* 19200, 38400, 57600, and 115200.
* @return true if successful, false otherwise
*/
bool setSM130BaudRate(int baud);
/**
* Put the SM130 to sleep. Once the device has been put to sleep,
* the only way to wake it is via hardwareReset() or a power
* cycle.
*
* @return true if successful, false otherwise
*/
bool sleep();
/**
* Get the last error that occurred. After a successful
* operation, this will be 0. See the datasheet for the various
* errors that can occur in various circumstances.
*
* @return The last error code, or 0 if the last operation succeeded.
*/
char getLastErrorCode() { return m_lastErrorCode; };
/**
* Get the text representation of the last error that occurred.
* The returned string is empty if the last operation completed
* successfully.
*
* @return The last error string if an error occurred, or an empty
* string if the last operation succeeded.
*/
std::string getLastErrorString() { return m_lastErrorString; };
/**
* Get the UID length of the currently selected tag.
*
* @return The UID length of the currently selected tag, or 0 if
* no tag is currently selected.
*/
int getUIDLen() { return m_uidLen; };
/**
* Get the UID of the currently selected tag.
*
* @return The UID of the currently selected tag, or an empty string if
* no tag is currently selected.
*/
std::string getUID() { return m_uid; };
/**
* Get the tag type of the currently selected tag.
*
* @return The tag type of the currently selected tag, or TAG_NONE
* if no tag is currently selected.
*/
TAG_TYPE_T getTagType() { return m_tagType; };
/**
* Convert the supplied tag type into a human readable string.
*
* @param tag One of the TAG_TYPE_T values
* @return A string representation of the supplied tag type
*/
std::string tag2String(TAG_TYPE_T tag);
/**
* This is a convenience function that converts a supplied string
* into a space separated hex formatted string. This can be
* useful for printing out binary data in a human readable format,
* like the UID.
*
* @param input The string to convert
* @return A string representation of the input in space separated
* hex values
*/
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();
}
};
}