alexey.zholtikov/upm
1
0
Fork 0
mirror of https://github.com/eclipse/upm.git synced 2025-03-15 04:57:30 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

M24LR64E: Add C Source

Browse Source 
Signed-off-by: Abhishek Malik <abhishek.malik@intel.com>
This commit is contained in:
Abhishek Malik 2016-09-09 19:13:32 -07:00 committed by Noel Eck
parent 25f4cb0be1
commit 980d10d1a4
4 changed files with 659 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/m24lr64e/CMakeLists.txt
View File

@ -1,5 +1,9 @@
set (libname "m24lr64e")
set (libdescription "upm m24lr64e grove NFC tag")
set (module_src ${libname}.cxx)
set (module_hpp ${libname}.hpp)
upm_module_init()
upm_mixed_module_init (NAME m24lr64e
DESCRIPTION "upm m24lr64esensor module"
C_HDR m24lr64e.h
C_SRC m24lr64e.c
CPP_HDR m24lr64e.hpp
CPP_SRC m24lr64e.cxx
FTI_SRC m24lr64e_fti.c
CPP_WRAPS_C
REQUIRES mraa)

301
src/m24lr64e/m24lr64e.c Normal file
View File

@ -0,0 +1,301 @@
#include "m24lr64e.h"
// forward declarations - these were protected methods in original C++
// code. Might need to expose them?
upm_result_t m24lr64e_eeprom_read_byte(m24lr64e_context dev,
uint32_t address, uint8_t* data);
upm_result_t m24lr64e_eeprom_read_bytes(m24lr64e_context dev,
uint32_t address,
uint8_t* data, int len);
upm_result_t m24lr64e_eeprom_write_byte(m24lr64e_context dev,
uint32_t address, uint8_t data);
upm_result_t m24lr64e_eeprom_write_bytes(m24lr64e_context dev,
uint32_t address,
uint8_t* data, int len);
m24lr64e_context m24lr64e_init(int bus, m24lr64e_access_mode mode){
m24lr64e_context dev =
(m24lr64e_context)malloc(sizeof(struct _m24lr64e_context));
if (!dev)
return NULL;
dev->bus = bus;
dev->mode = mode;
if (dev->mode == M24LR64E_USER_MODE)
dev->address = M24LR64E_DEFAULT_I2C_ADDR;
else
dev->address = M24LR64E_DEFAULT_I2C_ADDR_E2;
dev->i2c = mraa_i2c_init(dev->bus);
if (mraa_i2c_address(dev->i2c, dev->address) != MRAA_SUCCESS) {
return NULL;
}
return dev;
}
void m24lr64e_close(m24lr64e_context dev){
mraa_i2c_stop(dev->i2c);
free(dev);
}
upm_result_t m24lr64e_submit_password(m24lr64e_context dev,
uint32_t password){
// this device actually uses two bytes to address a register
const int pktLen = 11;
uint8_t buf[pktLen];
buf[0] = 0x09;
buf[1] = 0x00;
buf[2] = ((password >> 24) & 0xff);
buf[3] = ((password >> 16) & 0xff);
buf[4] = ((password >> 8) & 0xff);
buf[5] = (password & 0xff);
buf[6] = 0x09;
// the password is written twice
buf[7] = ((password >> 24) & 0xff);
buf[8] = ((password >> 16) & 0xff);
buf[9] = ((password >> 8) & 0xff);
buf[10] = (password & 0xff);
if (mraa_i2c_write(dev->i2c, buf, pktLen) != MRAA_SUCCESS){
return UPM_ERROR_OPERATION_FAILED;
}
return UPM_SUCCESS;
}
upm_result_t m24lr64e_write_password(m24lr64e_context dev, uint32_t password){
const int pktLen = 11;
uint8_t buf[pktLen];
buf[0] = 0x09;
buf[1] = 0x00;
buf[2] = ((password >> 24) & 0xff);
buf[3] = ((password >> 16) & 0xff);
buf[4] = ((password >> 8) & 0xff);
buf[5] = (password & 0xff);
buf[6] = 0x07;
// the password is written twice
buf[7] = ((password >> 24) & 0xff);
buf[8] = ((password >> 16) & 0xff);
buf[9] = ((password >> 8) & 0xff);
buf[10] = (password & 0xff);
if(mraa_i2c_write(dev->i2c, buf, pktLen) != MRAA_SUCCESS){
return UPM_ERROR_OPERATION_FAILED;
}
return UPM_SUCCESS;
}
upm_result_t m24lr64e_sector_protect_config(m24lr64e_context dev,
uint32_t sector_number,
bool protect_enable,
sector_access_right access_right,
sector_select_password password){
if(!protect_enable){
m24lr64e_write_byte(dev, sector_number, 0x0);
}
else{
m24lr64e_write_byte(dev, sector_number,
(protect_enable | (access_right << 1) |
(password << 2)));
}
return UPM_SUCCESS;
}
upm_result_t m24lr64e_clear_sector_protect(m24lr64e_context dev){
uint8_t buf[64]={0x0};
return m24lr64e_eeprom_write_bytes(dev, 0, buf, 64);
}
upm_result_t m24lr64e_sector_write_lock_bit(m24lr64e_context dev,
uint32_t sector_number,
bool sock_enable){
uint32_t sector_address = M24LR64E_SECTOR_SECURITY_STATUS_BASE_ADDR
+ (sector_number/8);
uint8_t sector_bit = sector_number % 8;
// byte read from the EEPROM into pre_status
uint8_t pre_status;
m24lr64e_eeprom_read_byte(dev, sector_address, &pre_status);
bool status = (pre_status >> sector_bit) & 0x01;
if(status != sock_enable){
if(status == true){
// Call to write byte function
m24lr64e_write_byte(dev, sector_address, pre_status&(~(1<<sector_bit)));
}
else{
// another call to write byte function
m24lr64e_write_byte(dev, sector_address, pre_status|(1<<sector_bit));
}
}
return UPM_SUCCESS;
}
upm_result_t m24lr64e_get_dsfid(m24lr64e_context dev, uint8_t* dsfid){
// EEPROM read byte function call
return m24lr64e_eeprom_read_byte(dev, M24LR64E_DSFID_ADDRESS, dsfid);
}
upm_result_t m24lr64e_get_afi(m24lr64e_context dev, uint8_t* afi){
// call to EEPROM read byte
return m24lr64e_eeprom_read_byte(dev, M24LR64E_AFI_ADDRESS, afi);
}
upm_result_t m24lr64e_get_uid(m24lr64e_context dev, uint8_t* uid){
//uint8_t* buffer;
//uint8_t arr[M24LR64E_UID_LENGTH];
//buffer = arr;
// call to EEPROM read bytes
m24lr64e_eeprom_read_bytes(dev, M24LR64E_UID_ADDRESS, uid,
M24LR64E_UID_LENGTH);
// not so sure about this
//#warning "THIS NEEDS FIXING"
//*uid = *buffer;
return UPM_SUCCESS;
}
upm_result_t m24lr64e_get_memory_size(m24lr64e_context dev,
uint32_t* memory_size){
uint32_t volume = 0x0;
uint8_t temp_vol = 0x0;
// us the EEPROM read byte function to calculate the volume
if (m24lr64e_eeprom_read_byte(dev, M24LR64E_MEM_SIZE_ADDRESS,
&temp_vol) != UPM_SUCCESS){
return UPM_ERROR_OPERATION_FAILED;
}
volume = temp_vol;
if (m24lr64e_eeprom_read_byte(dev, M24LR64E_MEM_SIZE_ADDRESS+1,
&temp_vol) != UPM_SUCCESS){
return UPM_ERROR_OPERATION_FAILED;
}
volume = volume<<8|temp_vol;
temp_vol = 0x0;
if (m24lr64e_eeprom_read_byte(dev, M24LR64E_MEM_SIZE_ADDRESS+2,
&temp_vol) != UPM_SUCCESS){
return UPM_ERROR_OPERATION_FAILED;
}
volume = volume << 8 | temp_vol;
*memory_size = volume;
return UPM_SUCCESS;
}
upm_result_t m24lr64e_clear_memory(m24lr64e_context dev){
int i=0;
for(i = 0; i < M24LR64E_EEPROM_I2C_LENGTH; i++){
// call to write byte function
m24lr64e_write_byte(dev, i, 0x0);
}
return UPM_SUCCESS;
}
upm_result_t m24lr64e_write_byte(m24lr64e_context dev, uint32_t address,
uint8_t data){
// call to EEPROM write byte
return m24lr64e_eeprom_write_byte(dev, address, data);
}
upm_result_t m24lr64e_write_bytes(m24lr64e_context dev,
uint32_t address, uint8_t* buffer, int len){
// call to EEPROM write bytes
return m24lr64e_eeprom_write_bytes(dev, address, buffer, len);
}
upm_result_t m24lr64e_read_byte(m24lr64e_context dev, uint32_t address,
uint8_t* data){
// call to EEPROM read byte
return m24lr64e_eeprom_read_byte(dev, address, data);
}
upm_result_t m24lr64e_read_bytes(m24lr64e_context dev, uint32_t address,
uint8_t* buffer, int len){
// call to EEPROM read bytes
return m24lr64e_eeprom_write_bytes(dev, address, buffer, len);
}
upm_result_t m24lr64e_eeprom_write_byte(m24lr64e_context dev, uint32_t address,
uint8_t data){
int pkt_len = 3;
uint8_t buf[pkt_len];
buf[0] = ((address >> 8) & 0xff);
buf[1] = (address & 0xff);
buf[2] = data;
if (mraa_i2c_write(dev->i2c, buf, pkt_len) != MRAA_SUCCESS){
return UPM_ERROR_OPERATION_FAILED;
}
upm_delay_us(M24LR64E_I2C_WRITE_TIME*1000);
return UPM_SUCCESS;
}
upm_result_t m24lr64e_eeprom_write_bytes(m24lr64e_context dev,
uint32_t address, uint8_t* data,
int len){
uint32_t pkt_len = 2 + len;
uint8_t buf[pkt_len];
buf[0] = ((address >> 8) & 0xff);
buf[1] = (address & 0xff);
int i = 0;
for (i=0; i<len; i++)
buf[2+i] = data[i];
if (mraa_i2c_write(dev->i2c, buf, pkt_len) != MRAA_SUCCESS){
return UPM_ERROR_OPERATION_FAILED;
}
upm_delay_us(M24LR64E_I2C_WRITE_TIME*1000);
return UPM_SUCCESS;
}
upm_result_t m24lr64e_eeprom_read_byte(m24lr64e_context dev, uint32_t address,
uint8_t* data){
uint32_t pkt_len = 2;
uint8_t buf[pkt_len];
buf[0] = ((address >> 8) & 0xff);
buf[1] = (address & 0xff);
if (mraa_i2c_write(dev->i2c, buf, pkt_len) != MRAA_SUCCESS){
return UPM_ERROR_OPERATION_FAILED;
}
pkt_len = 1;
uint8_t abuf[pkt_len];
abuf[0] = 0;
if (mraa_i2c_read(dev->i2c, abuf, pkt_len) != pkt_len){
return UPM_ERROR_OPERATION_FAILED;
}
*data = abuf[0];
return UPM_SUCCESS;
}
upm_result_t m24lr64e_eeprom_read_bytes(m24lr64e_context dev, uint32_t address,
uint8_t* data, int len){
uint32_t pkt_len = 2;
uint8_t buf[pkt_len];
buf[0] = ((address >> 8) & 0xff);
buf[1] = (address & 0xff);
if (mraa_i2c_write(dev->i2c, buf, pkt_len) != MRAA_SUCCESS){
return UPM_ERROR_OPERATION_FAILED;
}
if(mraa_i2c_read(dev->i2c, data, len) != len){
return UPM_ERROR_OPERATION_FAILED;
}
return UPM_SUCCESS;
}

300
src/m24lr64e/m24lr64e.h Normal file
View File

@ -0,0 +1,300 @@
/*
* Author: Jon Trulson <jtrulson@ics.com>
* Abhishek Malik <abhishek.malik@intel.com>
* Copyright (c) 2016 Intel Corporation.
*
*
* This code was adapted from the Seeed Studio code at:
* https://github.com/Seeed-Studio/NFC_Tag_M24LR6E
*
* Copyright (c) 2014 seeed technology inc.
* Website : www.seeed.cc
* Author : lawliet zou
* Create Time: March 2014
*
* 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 M24LR64E_H_
#define M24LR64E_H_
#include "upm.h"
#include "mraa/i2c.h"
#define M24LR64E_I2C_BUS 0
#define M24LR64E_DEFAULT_I2C_ADDR 0x53
#define M24LR64E_DEFAULT_I2C_ADDR_E2 (M24LR64E_DEFAULT_I2C_ADDR | 0x04)
#define M24LR64E_EEPROM_I2C_LENGTH 8192
#define M24LR64E_PASSWORD_LENGTH 4
#define M24LR64E_SECTOR_SECURITY_STATUS_BASE_ADDR 0x800
#define M24LR64E_LOCK_PROTECT_BIT 0x01
#define M24LR64E_WRITE_READ_PROTECT_BIT 0x02
#define M24LR64E_PASSWORD_CTRL_BIT 0x04
#define M24LR64E_UID_LENGTH 8
#define M24LR64E_I2C_WRITE_TIME 5
/**
* @brief Grove NFC Tag
* @defgroup m24lr64e libupm-m24lr64e
* @ingroup seeed i2c other
*/
/**
* @library m24lr64e
* @sensor m24lr64e
* @comname Grove NFC Tag
* @type other
* @man seeed
* @web http://www.seeedstudio.com/wiki/Grove_-_NFC_Tag
* @con i2c
*
* @brief C++ API for the M24LR64E-based Grove NFC Tag
*
* Grove NFC tag is an 8KB electrically erasable programmable read-only memory (EEPROM)
* that can be written to or read from using I2C and NFC-equipped devices.
*
* The user mode (default) allows read and write access to all 8KB
* of space, provided the sector security status (SSS) allows it.
* The root mode allows modification of the SSS data and other
* information, provided the proper password is submitted. The
* default password for a new tag is 0x00000000. See the datasheet
* for more details.
*
* The Seeed Studio* wiki page for this device includes a link to an
* Android* application that can be used to also read and write the
* device via NFC, as well as set NFC passwords, which cannot be
* done via I2C.
*
* @image html m24lr64e.jpg
* @snippet m24lr64e.cxx Interesting
*/
#include <stdint.h>
typedef enum {
M24LR64E_I2C_PASSWORD_ADDRESS = 2304,
M24LR64E_RF_PASSWORD_1_ADDRESS = 2308, // RF pwds not available in
M24LR64E_RF_PASSWORD_2_ADDRESS = 2312, // I2C access modes
M24LR64E_RF_PASSWORD_3_ADDRESS = 2316,
M24LR64E_DSFID_ADDRESS = 2320, // 1 byte
M24LR64E_AFI_ADDRESS = 2321, // 1 byte
M24LR64E_RESV_ADDRESS = 2322, // 1 bytes
M24LR64E_CONFIG_ADDRESS = 2323, // 1 bytes
M24LR64E_UID_ADDRESS = 2324, // 8 bytes
M24LR64E_MEM_SIZE_ADDRESS = 2332, // 3 bytes
M24LR64E_IC_REF_ADDRESS = 2335, // 1 byte
M24LR64E_PROG_COMP_ENERGY_HARVEST_ADDRESS = 2339 // 1 byte
} M24LR64E_ADDR_T;
typedef enum {
M24LR64E_USER_MODE = 0x0, // offers simple read/write access right
M24LR64E_ROOT_MODE = 0x1 // offers password change access right
} m24lr64e_access_mode;
typedef enum {
// **********************************
// * submit passWd * no submit *
//b2,b1 * Read * Write * Read * Write *
// 00 * 1 1 1 0 *
// 01 * 1 1 1 1 *
// 10 * 1 1 0 0 *
// 11 * 0 1 0 0 *
// **********************************
m24lr64e_access_1110 = 0,
m24lr64e_access_1111 = 1,
m24lr64e_access_1100 = 2,
m24lr64e_access_0111 = 3,
} sector_access_right;
typedef enum {
//00 => no passwd protect
//01 => passWd 1
//10 => passWd 2
//11 => passwd 3
m24lr64e_no_password = 0,
m24lr64e_password_1 = 1,
m24lr64e_password_2 = 2,
m24lr64e_password_3 = 3,
} sector_select_password;
/*
* device context
*/
typedef struct _m24lr64e_context {
mraa_i2c_context i2c;
uint8_t bus;
uint8_t address;
m24lr64e_access_mode mode;
} *m24lr64e_context;
/**
* M24LR64E Init function
*
* @param bus I2C bus to use
* @param mode Access mode (user or root) to use
*/
m24lr64e_context m24lr64e_init(int bus, m24lr64e_access_mode mode);
/**
* M24LR64E close function
*
* @param dev void pointer to sensor struct
*/
void m24lr64e_close(m24lr64e_context dev);
/**
* Submits an I2C access password
*
* @param dev void pointer to sensor struct
* @param passwd 4-byte access password
*/
upm_result_t m24lr64e_submit_password(m24lr64e_context dev, uint32_t password);
/**
* Writes a new I2C password
*
* @param dev void pointer to sensor struct
* @param passwd 4-byte access password
*/
upm_result_t m24lr64e_write_password(m24lr64e_context dev, uint32_t password);
/**
* Sets a protection bit for a sector. Must be in the root mode
*
* @param dev void pointer to sensor struct
* @param sectorNumber Sector whose protection you are modifying
* @param protectEnable True if you are enabling protection
* @param accessRight Access rights to set
* @param passwd Password number to enable, if any
*/
upm_result_t m24lr64e_sector_protect_config(m24lr64e_context dev,
uint32_t sector_number,
bool protect_enable,
sector_access_right access_right,
sector_select_password password);
/**
* Clears sector protection bits. Must be in the root mode.
*
* @param dev void pointer to sensor struct
*/
upm_result_t m24lr64e_clear_sector_protect(m24lr64e_context dev);
/**
* Sets or clears a sector security status lock bit for a sector.
* Must be in the root mode.
*
* @param dev void pointer to sensor struct
* @param sectorNumber Sector whose SSS you want to modify
* @param sockEnable True to set the bit, false to clear it
*/
upm_result_t m24lr64e_sector_write_lock_bit(m24lr64e_context dev,
uint32_t sector_number,
bool sock_enable);
/**
* Returns a data storage family identifier (DSFID)
* Must be in the root mode.
*
* @param dev void pointer to sensor struct
* @param dsfid pointer to hold return value
*/
upm_result_t m24lr64e_get_dsfid(m24lr64e_context dev, uint8_t* dsfid);
/**
* Returns an application family identifier (AFI)
* Must be in the root mode.
*
* @param dev void pointer to sensor struct
* @param afi pointer to hold return value
*/
upm_result_t m24lr64e_get_afi(m24lr64e_context dev, uint8_t* afi);
/**
* Returns a unique ID.
* Must be in the root mode.
* Maintained to preserve compatibility with older code.
*
* @param dev void pointer to sensor struct
* @param uid pointer to hold return value
*/
upm_result_t m24lr64e_get_uid(m24lr64e_context dev, uint8_t* uid);
/**
* Returns the memory size
* Must be in the root mode.
*
* @param dev void pointer to sensor struct
* @param memory_size pointer to hold return value
*/
upm_result_t m24lr64e_get_memory_size(m24lr64e_context dev, uint32_t* memory_size);
/**
* Sets all memory to 0, if permissions allow
*
* @param dev void pointer to sensor struct
*/
upm_result_t m24lr64e_clear_memory(m24lr64e_context dev);
/**
* Writes a byte to the EEPROM
*
* @param dev void pointer to sensor struct
* @param address Address to write to
* @param data Data to write
*/
upm_result_t m24lr64e_write_byte(m24lr64e_context dev, uint32_t address,
uint8_t data);
/**
* Writes bytes to the EEPROM
*
* @param dev void pointer to sensor struct
* @param address Address to write to
* @param data Data to write
* @param data Length of the data buffer
*/
upm_result_t m24lr64e_write_bytes(m24lr64e_context dev, uint32_t address,
uint8_t* buffer, int len);
/**
* Reads a byte from the EEPROM
*
* @param dev void pointer to sensor struct
* @param address Address to read from
* @param data holds return value
*/
upm_result_t m24lr64e_read_byte(m24lr64e_context dev, uint32_t address,
uint8_t* data);
/**
* Reads multiple bytes from the EEPROM
*
* @param dev void pointer to sensor struct
* @param address Address to read from
* @param buffer Buffer to store data
* @param len Number of bytes to read
*/
upm_result_t m24lr64e_read_bytes(m24lr64e_context dev, uint32_t address,
uint8_t* buffer, int len);
#endif /* M24LR64E_H_ */

49
src/m24lr64e/m24lr64e_fti.c Normal file
View File

@ -0,0 +1,49 @@
#include "m24lr64e.h"
#include "upm_fti.h"
/**
* This file implements the Function Table Interface (FTI) for this sensor
*/
const char upm_m24lr64e_name[] = "M24LR64E";
const char upm_m24lr64e_description[] = "Grove NFC Tag";
const upm_protocol_t upm_m24lr64e_protocol[] = {UPM_I2C};
const upm_sensor_t upm_m24lr64e_category[] = {UPM_NFC};
// forward declarations
const void* upm_m24lr64e_get_ft(upm_sensor_t sensor_type);
void* upm_m24lr64e_init_name();
void upm_m24lr64e_close(void* dev);
const upm_sensor_descriptor_t upm_m24lr64e_get_descriptor(){
upm_sensor_descriptor_t usd;
usd.name = upm_m24lr64e_name;
usd.description = upm_m24lr64e_description;
usd.protocol_size = 1;
usd.protocol = upm_m24lr64e_protocol;
usd.category_size = 1;
usd.category = upm_m24lr64e_category;
return usd;
}
static const upm_sensor_ft ft =
{
.upm_sensor_init_name = &upm_m24lr64e_init_name,
.upm_sensor_close = &upm_m24lr64e_close,
.upm_sensor_get_descriptor = &upm_m24lr64e_get_descriptor
};
const void* upm_m24lr64e_get_ft(upm_sensor_t sensor_type){
if(sensor_type == UPM_SENSOR){
return &ft;
}
return NULL;
}
void* upm_m24lr64e_init_name(){
return NULL;
}
void upm_m24lr64e_close(void* dev){
m24lr64e_close((m24lr64e_context)dev);
}