Dhruv Bhatt
Bank Account Security System
Dependencies: FatFileSystemSD mbed
Revision 0:7e4786a3584b, committed 2012-10-11
- Comitter:
- Dhruv_Varun
- Date:
- Thu Oct 11 20:49:25 2012 +0000
- Commit message:
- Code For Bank Account Security System
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Camera_LS_Y201.cpp Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,449 @@
+/**
+ * =============================================================================
+ * LS-Y201 device driver class (Version 0.0.1)
+ * Reference documents: LinkSprite JPEG Color Camera Serial UART Interface
+ * January 2010
+ * =============================================================================
+ * Copyright (c) 2010 Shinichiro Nakamura (CuBeatSystems)
+ *
+ * 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.
+ * =============================================================================
+ */
+
+#include "Camera_LS_Y201.h"
+
+/**
+ * Create.
+ *
+ * @param tx Transmitter.
+ * @param rx Receiver.
+ */
+Camera_LS_Y201::Camera_LS_Y201(PinName tx, PinName rx) : serial(tx, rx) {
+ serial.baud(38400);
+}
+
+/**
+ * Dispose.
+ */
+Camera_LS_Y201::~Camera_LS_Y201() {
+}
+
+/**
+ * Reset module.
+ *
+ * @return Error code.
+ */
+Camera_LS_Y201::ErrorCode Camera_LS_Y201::reset() {
+ uint8_t send[4] = {
+ 0x56,
+ 0x00,
+ 0x26,
+ 0x00
+ };
+ uint8_t recv[4];
+
+ waitIdle();
+ if (!sendBytes(send, sizeof(send), 200 * 1000)) {
+ return SendError;
+ }
+ if (!recvBytes(recv, sizeof(recv), 200 * 1000)) {
+ return RecvError;
+ }
+ if ((recv[0] == 0x76)
+ && (recv[1] == 0x00)
+ && (recv[2] == 0x26)
+ && (recv[3] == 0x00)) {
+ ErrorCode r = waitInitEnd();
+ if (r != NoError) {
+ return r;
+ }
+ wait(4);
+ return NoError;
+ } else {
+ return UnexpectedReply;
+ }
+}
+
+/**
+ * Set image size.
+ *
+ * @param is Image size.
+ * @return Error code.
+ */
+Camera_LS_Y201::ErrorCode Camera_LS_Y201::setImageSize(ImageSize is) {
+ uint8_t send[9] = {
+ 0x56,
+ 0x00,
+ 0x31,
+ 0x05,
+ 0x04,
+ 0x01,
+ 0x00,
+ 0x19,
+ 0x00 // 0x11:320x240, 0x00:640x480, 0x22:160x120
+ };
+ uint8_t recv[5];
+ switch (is) {
+ case ImageSize160x120:
+ send[8] = 0x22;
+ break;
+ case ImageSize320x280:
+ send[8] = 0x11;
+ break;
+ case ImageSize640x480:
+ send[8] = 0x00;
+ break;
+ default:
+ return InvalidArguments;
+ }
+ if (!sendBytes(send, sizeof(send), 200 * 1000)) {
+ return SendError;
+ }
+ if (!recvBytes(recv, sizeof(recv), 200 * 1000)) {
+ return RecvError;
+ }
+ if ((recv[0] == 0x76)
+ && (recv[1] == 0x00)
+ && (recv[2] == 0x31)
+ && (recv[3] == 0x00)
+ && (recv[4] == 0x00)) {
+ wait(1);
+ return reset();
+ } else {
+ return UnexpectedReply;
+ }
+}
+
+/**
+ * Take picture.
+ *
+ * @return Error code.
+ */
+Camera_LS_Y201::ErrorCode Camera_LS_Y201::takePicture() {
+ uint8_t send[5] = {
+ 0x56,
+ 0x00,
+ 0x36,
+ 0x01,
+ 0x00
+ };
+ uint8_t recv[5];
+
+ if (!sendBytes(send, sizeof(send), 200 * 1000)) {
+ return SendError;
+ }
+ if (!recvBytes(recv, sizeof(recv), 200 * 1000)) {
+ return RecvError;
+ }
+
+ if ((recv[0] == 0x76)
+ && (recv[1] == 0x00)
+ && (recv[2] == 0x36)
+ && (recv[3] == 0x00)
+ && (recv[4] == 0x00)) {
+ /*
+ * I think the camera need a time for operating.
+ * But there is no any comments on the documents.
+ */
+ wait_ms(100);
+ return NoError;
+ } else {
+ return UnexpectedReply;
+ }
+}
+
+/**
+ * Read jpeg file size.
+ *
+ * @param fileSize File size.
+ * @return Error code.
+ */
+Camera_LS_Y201::ErrorCode Camera_LS_Y201::readJpegFileSize(int *fileSize) {
+ uint8_t send[5] = {
+ 0x56,
+ 0x00,
+ 0x34,
+ 0x01,
+ 0x00
+ };
+ uint8_t recv[9];
+
+ if (!sendBytes(send, sizeof(send), 200 * 1000)) {
+ return SendError;
+ }
+ if (!recvBytes(recv, sizeof(recv), 200 * 1000)) {
+ return RecvError;
+ }
+
+ if ((recv[0] == 0x76)
+ && (recv[1] == 0x00)
+ && (recv[2] == 0x34)
+ && (recv[3] == 0x00)
+ && (recv[4] == 0x04)
+ && (recv[5] == 0x00)
+ && (recv[6] == 0x00)) {
+ *fileSize = ((recv[7] & 0x00ff) << 8)
+ | ((recv[8] & 0x00ff) << 0);
+ return NoError;
+ } else {
+ return UnexpectedReply;
+ }
+}
+
+/**
+ * Read jpeg file content.
+ *
+ * @param func A pointer to a call back function.
+ * @return Error code.
+ */
+Camera_LS_Y201::ErrorCode Camera_LS_Y201::readJpegFileContent(void (*func)(int done, int total, uint8_t *buf, size_t siz)) {
+ uint8_t send[16] = {
+ 0x56,
+ 0x00,
+ 0x32,
+ 0x0C,
+ 0x00,
+ 0x0A,
+ 0x00,
+ 0x00,
+ 0x00, // MH
+ 0x00, // ML
+ 0x00,
+ 0x00,
+ 0x00, // KH
+ 0x00, // KL
+ 0x00, // XX
+ 0x00 // XX
+ };
+ uint8_t body[32];
+ uint16_t m = 0; // Staring address.
+ uint16_t k = sizeof(body); // Packet size.
+ uint16_t x = 10; // Interval time. XX XX * 0.01m[sec]
+ bool end = false;
+
+ /*
+ * Get the data size.
+ */
+ int siz_done = 0;
+ int siz_total = 0;
+ ErrorCode r = readJpegFileSize(&siz_total);
+ if (r != NoError) {
+ return r;
+ }
+
+ do {
+ send[8] = (m >> 8) & 0xff;
+ send[9] = (m >> 0) & 0xff;
+ send[12] = (k >> 8) & 0xff;
+ send[13] = (k >> 0) & 0xff;
+ send[14] = (x >> 8) & 0xff;
+ send[15] = (x >> 0) & 0xff;
+ /*
+ * Send a command.
+ */
+ if (!sendBytes(send, sizeof(send), 200 * 1000)) {
+ return SendError;
+ }
+ /*
+ * Read the header of the response.
+ */
+ uint8_t header[5];
+ if (!recvBytes(header, sizeof(header), 2 * 1000 * 1000)) {
+ return RecvError;
+ }
+ /*
+ * Check the response and fetch an image data.
+ */
+ if ((header[0] == 0x76)
+ && (header[1] == 0x00)
+ && (header[2] == 0x32)
+ && (header[3] == 0x00)
+ && (header[4] == 0x00)) {
+ if (!recvBytes(body, sizeof(body), 2 * 1000 * 1000)) {
+ return RecvError;
+ }
+ siz_done += sizeof(body);
+ if (func != NULL) {
+ if (siz_done > siz_total) {
+ siz_done = siz_total;
+ }
+ func(siz_done, siz_total, body, sizeof(body));
+ }
+ for (int i = 1; i < sizeof(body); i++) {
+ if ((body[i - 1] == 0xFF) && (body[i - 0] == 0xD9)) {
+ end = true;
+ }
+ }
+ } else {
+ return UnexpectedReply;
+ }
+ /*
+ * Read the footer of the response.
+ */
+ uint8_t footer[5];
+ if (!recvBytes(footer, sizeof(footer), 2 * 1000 * 1000)) {
+ return RecvError;
+ }
+
+ m += sizeof(body);
+ } while (!end);
+ return NoError;
+}
+
+/**
+ * Stop taking pictures.
+ *
+ * @return Error code.
+ */
+Camera_LS_Y201::ErrorCode Camera_LS_Y201::stopTakingPictures() {
+ uint8_t send[5] = {
+ 0x56,
+ 0x00,
+ 0x36,
+ 0x01,
+ 0x03
+ };
+ uint8_t recv[5];
+
+ if (!sendBytes(send, sizeof(send), 200 * 1000)) {
+ return SendError;
+ }
+ if (!recvBytes(recv, sizeof(recv), 200 * 1000)) {
+ return RecvError;
+ }
+
+ if ((recv[0] == 0x76)
+ && (recv[1] == 0x00)
+ && (recv[2] == 0x36)
+ && (recv[3] == 0x00)
+ && (recv[4] == 0x00)) {
+ /*
+ * I think the camera need a time for operating.
+ * But there is no any comments on the documents.
+ */
+ wait_ms(100);
+ return NoError;
+ } else {
+ return UnexpectedReply;
+ }
+}
+
+/**
+ * Wait init end codes.
+ *
+ * @return True if the data sended.
+ */
+Camera_LS_Y201::ErrorCode Camera_LS_Y201::waitInitEnd() {
+ static const char *PWR_ON_MSG = "Init end\x0d\x0a";
+ for (int i = 0; i < strlen(PWR_ON_MSG); i++) {
+ static const int MAXCNT = 128;
+ int cnt = 0;
+ uint8_t c = 0x00;
+ do {
+ if (!recvBytes(&c, sizeof(c), 500 * 1000)) {
+ return Timeout;
+ }
+
+ /*
+ * What is the version of the camera.
+ * You can check the version with this code.
+ *
+ * VC0703 1.00
+ * 3o ctrl in
+ * Init end
+ */
+#if 0
+ printf("%c", c);
+#endif
+
+ cnt++;
+ if (MAXCNT < cnt) {
+ return UnexpectedReply;
+ }
+ } while (c != PWR_ON_MSG[i]);
+ }
+ return NoError;
+}
+
+/**
+ * Send bytes to camera module.
+ *
+ * @param buf Pointer to the data buffer.
+ * @param len Length of the data buffer.
+ *
+ * @return True if the data sended.
+ */
+bool Camera_LS_Y201::sendBytes(uint8_t *buf, size_t len, int timeout_us) {
+ for (uint32_t i = 0; i < (uint32_t)len; i++) {
+ int cnt = 0;
+ while (!serial.writeable()) {
+ wait_us(1);
+ cnt++;
+ if (timeout_us < cnt) {
+ return false;
+ }
+ }
+ serial.putc(buf[i]);
+ }
+ return true;
+}
+
+/**
+ * Receive bytes from camera module.
+ *
+ * @param buf Pointer to the data buffer.
+ * @param len Length of the data buffer.
+ *
+ * @return True if the data received.
+ */
+bool Camera_LS_Y201::recvBytes(uint8_t *buf, size_t len, int timeout_us) {
+ for (uint32_t i = 0; i < (uint32_t)len; i++) {
+ int cnt = 0;
+ while (!serial.readable()) {
+ wait_us(1);
+ cnt++;
+ if (timeout_us < cnt) {
+ return false;
+ }
+ }
+ buf[i] = serial.getc();
+ }
+ return true;
+}
+
+/**
+ * Wait received.
+ *
+ * @return True if the data received.
+ */
+bool Camera_LS_Y201::waitRecv() {
+ while (!serial.readable()) {
+ }
+ return true;
+}
+
+/**
+ * Wait idle state.
+ */
+bool Camera_LS_Y201::waitIdle() {
+ while (serial.readable()) {
+ serial.getc();
+ }
+ return true;
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Camera_LS_Y201.h Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,166 @@
+/**
+ * =============================================================================
+ * LS-Y201 device driver class (Version 0.0.1)
+ * Reference documents: LinkSprite JPEG Color Camera Serial UART Interface
+ * January 2010
+ * =============================================================================
+ * Copyright (c) 2010 Shinichiro Nakamura (CuBeatSystems)
+ *
+ * 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 LS_Y201_H
+#define LS_Y201_H
+
+#include "mbed.h"
+#include "SerialBuffered.h"
+
+/**
+ * Camera
+ */
+class Camera_LS_Y201 {
+public:
+
+ /**
+ * Create.
+ *
+ * @param tx Transmitter.
+ * @param rx Receiver.
+ */
+ Camera_LS_Y201(PinName tx, PinName rx);
+
+ /**
+ * Dispose.
+ */
+ ~Camera_LS_Y201();
+
+ /**
+ * Error code.
+ */
+ enum ErrorCode {
+ NoError = 0,
+ UnexpectedReply,
+ Timeout,
+ SendError,
+ RecvError,
+ InvalidArguments
+ };
+
+ /**
+ * Image size.
+ */
+ enum ImageSize {
+ ImageSize160x120, /**< 160x120. */
+ ImageSize320x280, /**< 320x280. */
+ ImageSize640x480 /**< 640x480. */
+ };
+
+ /**
+ * Reset module.
+ *
+ * @return Error code.
+ */
+ ErrorCode reset();
+
+ /**
+ * Set image size.
+ *
+ * @param is Image size.
+ * @return Error code.
+ */
+ ErrorCode setImageSize(ImageSize is);
+
+ /**
+ * Take picture.
+ *
+ * @return Error code.
+ */
+ ErrorCode takePicture();
+
+ /**
+ * Read jpeg file size.
+ *
+ * @param fileSize File size.
+ * @return Error code.
+ */
+ ErrorCode readJpegFileSize(int *fileSize);
+
+ /**
+ * Read jpeg file content.
+ *
+ * @param func A pointer to a call back function.
+ * @return Error code.
+ */
+ ErrorCode readJpegFileContent(void (*func)(int done, int total, uint8_t *buf, size_t siz));
+
+ /**
+ * Stop taking pictures.
+ *
+ * @return Error code.
+ */
+ ErrorCode stopTakingPictures();
+
+private:
+ SerialBuffered serial;
+
+ /**
+ * Wait init end codes.
+ *
+ * @return Error code.
+ */
+ ErrorCode waitInitEnd();
+
+ /**
+ * Send bytes to camera module.
+ *
+ * @param buf Pointer to the data buffer.
+ * @param len Length of the data buffer.
+ *
+ * @return True if the data sended.
+ */
+ bool sendBytes(uint8_t *buf, size_t len, int timeout_us);
+
+ /**
+ * Receive bytes from camera module.
+ *
+ * @param buf Pointer to the data buffer.
+ * @param len Length of the data buffer.
+ *
+ * @return True if the data received.
+ */
+ bool recvBytes(uint8_t *buf, size_t len, int timeout_us);
+
+ /**
+ * Wait received.
+ *
+ * @return True if the data received.
+ */
+ bool waitRecv();
+
+ /**
+ * Wait idle state.
+ *
+ * @return True if it succeed.
+ */
+ bool waitIdle();
+
+};
+
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/FatFileSystemSD.lib Thu Oct 11 20:49:25 2012 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/carlos_nascimento08/code/FatFileSystemSD/#6ce49c16703c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ID12RFID.cpp Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,53 @@
+/* mbed ID12 RFID Library
+ * Copyright (c) 2007-2010, sford, http://mbed.org
+ *
+ * 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.
+ */
+
+#include "ID12RFID.h"
+
+#include "mbed.h"
+
+ID12RFID::ID12RFID(PinName rx)
+ : _rfid(NC, rx) {
+}
+
+int ID12RFID::readable() {
+ return _rfid.readable();
+}
+
+int ID12RFID::read() {
+ while (_rfid.getc() != 2);
+
+ int v = 0;
+ _rfid.getc(); // drop 1st 2 bytes - we actually only read the lower 32-bits of the code
+ _rfid.getc();
+
+ for (int i=7; i>=0; i--) {
+ char c = _rfid.getc(); // a ascii hex char
+ int part = c - '0';
+ v |= part << (i * 4);
+ }
+
+ for (int i=0; i<5; i++) {
+ _rfid.getc();
+ }
+
+ return v;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ID12RFID.h Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,73 @@
+/* mbed ID12 RFID Library
+ * Copyright (c) 2007-2010, sford, http://mbed.org
+ *
+ * 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 MBED_ID12RFID_H
+#define MBED_ID12RFID_H
+
+#include "mbed.h"
+
+/** An interface for the ID-12 RFID reader device
+ *
+ * @code
+ * // Print RFID tag numbers
+ *
+ * #include "mbed.h"
+ * #include "ID12RFID.h"
+ *
+ * ID12RFID rfid(p10); // serial rx
+ *
+ * int main() {
+ * while(1) {
+ * if(rfid.readable()) {
+ * printf("RFID Tag number : %d\n", rfid.read());
+ * }
+ * }
+ * }
+ * @endcode
+ */
+class ID12RFID {
+
+public:
+ /** Create an ID12 RFID interface, connected to the specified Serial rx port
+ *
+ * @param rx Recieve pin
+ */
+ ID12RFID(PinName rx);
+
+ /** Non blocking function to determine if an ID has been received
+ *
+ * @return Non zero value when the device is readable
+ */
+ int readable();
+
+ /** A blocking function that will return a tag ID when available
+ *
+ * @return The ID tag value
+ */
+ int read();
+
+private:
+ Serial _rfid;
+
+};
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SDFileSystem.cpp Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,457 @@
+/* mbed SDFileSystem Library, for providing file access to SD cards
+ * Copyright (c) 2008-2010, sford
+ *
+ * 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.
+ */
+
+/* Introduction
+ * ------------
+ * SD and MMC cards support a number of interfaces, but common to them all
+ * is one based on SPI. This is the one I'm implmenting because it means
+ * it is much more portable even though not so performant, and we already
+ * have the mbed SPI Interface!
+ *
+ * The main reference I'm using is Chapter 7, "SPI Mode" of:
+ * http://www.sdcard.org/developers/tech/sdcard/pls/Simplified_Physical_Layer_Spec.pdf
+ *
+ * SPI Startup
+ * -----------
+ * The SD card powers up in SD mode. The SPI interface mode is selected by
+ * asserting CS low and sending the reset command (CMD0). The card will
+ * respond with a (R1) response.
+ *
+ * CMD8 is optionally sent to determine the voltage range supported, and
+ * indirectly determine whether it is a version 1.x SD/non-SD card or
+ * version 2.x. I'll just ignore this for now.
+ *
+ * ACMD41 is repeatedly issued to initialise the card, until "in idle"
+ * (bit 0) of the R1 response goes to '0', indicating it is initialised.
+ *
+ * You should also indicate whether the host supports High Capicity cards,
+ * and check whether the card is high capacity - i'll also ignore this
+ *
+ * SPI Protocol
+ * ------------
+ * The SD SPI protocol is based on transactions made up of 8-bit words, with
+ * the host starting every bus transaction by asserting the CS signal low. The
+ * card always responds to commands, data blocks and errors.
+ *
+ * The protocol supports a CRC, but by default it is off (except for the
+ * first reset CMD0, where the CRC can just be pre-calculated, and CMD8)
+ * I'll leave the CRC off I think!
+ *
+ * Standard capacity cards have variable data block sizes, whereas High
+ * Capacity cards fix the size of data block to 512 bytes. I'll therefore
+ * just always use the Standard Capacity cards with a block size of 512 bytes.
+ * This is set with CMD16.
+ *
+ * You can read and write single blocks (CMD17, CMD25) or multiple blocks
+ * (CMD18, CMD25). For simplicity, I'll just use single block accesses. When
+ * the card gets a read command, it responds with a response token, and then
+ * a data token or an error.
+ *
+ * SPI Command Format
+ * ------------------
+ * Commands are 6-bytes long, containing the command, 32-bit argument, and CRC.
+ *
+ * +---------------+------------+------------+-----------+----------+--------------+
+ * | 01 | cmd[5:0] | arg[31:24] | arg[23:16] | arg[15:8] | arg[7:0] | crc[6:0] | 1 |
+ * +---------------+------------+------------+-----------+----------+--------------+
+ *
+ * As I'm not using CRC, I can fix that byte to what is needed for CMD0 (0x95)
+ *
+ * All Application Specific commands shall be preceded with APP_CMD (CMD55).
+ *
+ * SPI Response Format
+ * -------------------
+ * The main response format (R1) is a status byte (normally zero). Key flags:
+ * idle - 1 if the card is in an idle state/initialising
+ * cmd - 1 if an illegal command code was detected
+ *
+ * +-------------------------------------------------+
+ * R1 | 0 | arg | addr | seq | crc | cmd | erase | idle |
+ * +-------------------------------------------------+
+ *
+ * R1b is the same, except it is followed by a busy signal (zeros) until
+ * the first non-zero byte when it is ready again.
+ *
+ * Data Response Token
+ * -------------------
+ * Every data block written to the card is acknowledged by a byte
+ * response token
+ *
+ * +----------------------+
+ * | xxx | 0 | status | 1 |
+ * +----------------------+
+ * 010 - OK!
+ * 101 - CRC Error
+ * 110 - Write Error
+ *
+ * Single Block Read and Write
+ * ---------------------------
+ *
+ * Block transfers have a byte header, followed by the data, followed
+ * by a 16-bit CRC. In our case, the data will always be 512 bytes.
+ *
+ * +------+---------+---------+- - - -+---------+-----------+----------+
+ * | 0xFE | data[0] | data[1] | | data[n] | crc[15:8] | crc[7:0] |
+ * +------+---------+---------+- - - -+---------+-----------+----------+
+ */
+
+#include "SDFileSystem.h"
+
+#define SD_COMMAND_TIMEOUT 5000
+
+SDFileSystem::SDFileSystem(PinName mosi, PinName miso, PinName sclk, PinName cs, const char* name) :
+ FATFileSystem(name), _spi(mosi, miso, sclk), _cs(cs) {
+ _cs = 1;
+}
+
+#define R1_IDLE_STATE (1 << 0)
+#define R1_ERASE_RESET (1 << 1)
+#define R1_ILLEGAL_COMMAND (1 << 2)
+#define R1_COM_CRC_ERROR (1 << 3)
+#define R1_ERASE_SEQUENCE_ERROR (1 << 4)
+#define R1_ADDRESS_ERROR (1 << 5)
+#define R1_PARAMETER_ERROR (1 << 6)
+
+// Types
+// - v1.x Standard Capacity
+// - v2.x Standard Capacity
+// - v2.x High Capacity
+// - Not recognised as an SD Card
+
+#define SDCARD_FAIL 0
+#define SDCARD_V1 1
+#define SDCARD_V2 2
+#define SDCARD_V2HC 3
+
+int SDFileSystem::initialise_card() {
+ // Set to 100kHz for initialisation, and clock card with cs = 1
+ _spi.frequency(100000);
+ _cs = 1;
+ for(int i=0; i<16; i++) {
+ _spi.write(0xFF);
+ }
+
+ // send CMD0, should return with all zeros except IDLE STATE set (bit 0)
+ if(_cmd(0, 0) != R1_IDLE_STATE) {
+ fprintf(stderr, "No disk, or could not put SD card in to SPI idle state\n");
+ return SDCARD_FAIL;
+ }
+
+ // send CMD8 to determine whther it is ver 2.x
+ int r = _cmd8();
+ if(r == R1_IDLE_STATE) {
+ return initialise_card_v2();
+ } else if(r == (R1_IDLE_STATE | R1_ILLEGAL_COMMAND)) {
+ return initialise_card_v1();
+ } else {
+ fprintf(stderr, "Not in idle state after sending CMD8 (not an SD card?)\n");
+ return SDCARD_FAIL;
+ }
+}
+
+int SDFileSystem::initialise_card_v1() {
+ for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
+ _cmd(55, 0);
+ if(_cmd(41, 0) == 0) {
+ return SDCARD_V1;
+ }
+ }
+
+ fprintf(stderr, "Timeout waiting for v1.x card\n");
+ return SDCARD_FAIL;
+}
+
+int SDFileSystem::initialise_card_v2() {
+
+ for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
+ _cmd(55, 0);
+ if(_cmd(41, 0) == 0) {
+ _cmd58();
+ return SDCARD_V2;
+ }
+ }
+
+ fprintf(stderr, "Timeout waiting for v2.x card\n");
+ return SDCARD_FAIL;
+}
+
+int SDFileSystem::disk_initialize() {
+
+ int i = initialise_card();
+// printf("init card = %d\n", i);
+// printf("OK\n");
+
+ _sectors = _sd_sectors();
+
+ // Set block length to 512 (CMD16)
+ if(_cmd(16, 512) != 0) {
+ fprintf(stderr, "Set 512-byte block timed out\n");
+ return 1;
+ }
+
+ _spi.frequency(1000000); // Set to 1MHz for data transfer
+ return 0;
+}
+
+int SDFileSystem::disk_write(const char *buffer, int block_number) {
+ // set write address for single block (CMD24)
+ if(_cmd(24, block_number * 512) != 0) {
+ return 1;
+ }
+
+ // send the data block
+ _write(buffer, 512);
+ return 0;
+}
+
+int SDFileSystem::disk_read(char *buffer, int block_number) {
+ // set read address for single block (CMD17)
+ if(_cmd(17, block_number * 512) != 0) {
+ return 1;
+ }
+
+ // receive the data
+ _read(buffer, 512);
+ return 0;
+}
+
+int SDFileSystem::disk_status() { return 0; }
+int SDFileSystem::disk_sync() { return 0; }
+int SDFileSystem::disk_sectors() { return _sectors; }
+
+// PRIVATE FUNCTIONS
+
+int SDFileSystem::_cmd(int cmd, int arg) {
+ _cs = 0;
+
+ // send a command
+ _spi.write(0x40 | cmd);
+ _spi.write(arg >> 24);
+ _spi.write(arg >> 16);
+ _spi.write(arg >> 8);
+ _spi.write(arg >> 0);
+ _spi.write(0x95);
+
+ // wait for the repsonse (response[7] == 0)
+ for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
+ int response = _spi.write(0xFF);
+ if(!(response & 0x80)) {
+ _cs = 1;
+ _spi.write(0xFF);
+ return response;
+ }
+ }
+ _cs = 1;
+ _spi.write(0xFF);
+ return -1; // timeout
+}
+int SDFileSystem::_cmdx(int cmd, int arg) {
+ _cs = 0;
+
+ // send a command
+ _spi.write(0x40 | cmd);
+ _spi.write(arg >> 24);
+ _spi.write(arg >> 16);
+ _spi.write(arg >> 8);
+ _spi.write(arg >> 0);
+ _spi.write(0x95);
+
+ // wait for the repsonse (response[7] == 0)
+ for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
+ int response = _spi.write(0xFF);
+ if(!(response & 0x80)) {
+ return response;
+ }
+ }
+ _cs = 1;
+ _spi.write(0xFF);
+ return -1; // timeout
+}
+
+
+int SDFileSystem::_cmd58() {
+ _cs = 0;
+ int arg = 0;
+
+ // send a command
+ _spi.write(0x40 | 58);
+ _spi.write(arg >> 24);
+ _spi.write(arg >> 16);
+ _spi.write(arg >> 8);
+ _spi.write(arg >> 0);
+ _spi.write(0x95);
+
+ // wait for the repsonse (response[7] == 0)
+ for(int i=0; i<SD_COMMAND_TIMEOUT; i++) {
+ int response = _spi.write(0xFF);
+ if(!(response & 0x80)) {
+ int ocr = _spi.write(0xFF) << 24;
+ ocr |= _spi.write(0xFF) << 16;
+ ocr |= _spi.write(0xFF) << 8;
+ ocr |= _spi.write(0xFF) << 0;
+// printf("OCR = 0x%08X\n", ocr);
+ _cs = 1;
+ _spi.write(0xFF);
+ return response;
+ }
+ }
+ _cs = 1;
+ _spi.write(0xFF);
+ return -1; // timeout
+}
+
+int SDFileSystem::_cmd8() {
+ _cs = 0;
+
+ // send a command
+ _spi.write(0x40 | 8); // CMD8
+ _spi.write(0x00); // reserved
+ _spi.write(0x00); // reserved
+ _spi.write(0x01); // 3.3v
+ _spi.write(0xAA); // check pattern
+ _spi.write(0x87); // crc
+
+ // wait for the repsonse (response[7] == 0)
+ for(int i=0; i<SD_COMMAND_TIMEOUT * 1000; i++) {
+ char response[5];
+ response[0] = _spi.write(0xFF);
+ if(!(response[0] & 0x80)) {
+ for(int j=1; j<5; j++) {
+ response[i] = _spi.write(0xFF);
+ }
+ _cs = 1;
+ _spi.write(0xFF);
+ return response[0];
+ }
+ }
+ _cs = 1;
+ _spi.write(0xFF);
+ return -1; // timeout
+}
+
+int SDFileSystem::_read(char *buffer, int length) {
+ _cs = 0;
+
+ // read until start byte (0xFF)
+ while(_spi.write(0xFF) != 0xFE);
+
+ // read data
+ for(int i=0; i<length; i++) {
+ buffer[i] = _spi.write(0xFF);
+ }
+ _spi.write(0xFF); // checksum
+ _spi.write(0xFF);
+
+ _cs = 1;
+ _spi.write(0xFF);
+ return 0;
+}
+
+int SDFileSystem::_write(const char *buffer, int length) {
+ _cs = 0;
+
+ // indicate start of block
+ _spi.write(0xFE);
+
+ // write the data
+ for(int i=0; i<length; i++) {
+ _spi.write(buffer[i]);
+ }
+
+ // write the checksum
+ _spi.write(0xFF);
+ _spi.write(0xFF);
+
+ // check the repsonse token
+ if((_spi.write(0xFF) & 0x1F) != 0x05) {
+ _cs = 1;
+ _spi.write(0xFF);
+ return 1;
+ }
+
+ // wait for write to finish
+ while(_spi.write(0xFF) == 0);
+
+ _cs = 1;
+ _spi.write(0xFF);
+ return 0;
+}
+
+static int ext_bits(char *data, int msb, int lsb) {
+ int bits = 0;
+ int size = 1 + msb - lsb;
+ for(int i=0; i<size; i++) {
+ int position = lsb + i;
+ int byte = 15 - (position >> 3);
+ int bit = position & 0x7;
+ int value = (data[byte] >> bit) & 1;
+ bits |= value << i;
+ }
+ return bits;
+}
+
+int SDFileSystem::_sd_sectors() {
+
+ // CMD9, Response R2 (R1 byte + 16-byte block read)
+ if(_cmdx(9, 0) != 0) {
+ fprintf(stderr, "Didn't get a response from the disk\n");
+ return 0;
+ }
+
+ char csd[16];
+ if(_read(csd, 16) != 0) {
+ fprintf(stderr, "Couldn't read csd response from disk\n");
+ return 0;
+ }
+
+ // csd_structure : csd[127:126]
+ // c_size : csd[73:62]
+ // c_size_mult : csd[49:47]
+ // read_bl_len : csd[83:80] - the *maximum* read block length
+
+ int csd_structure = ext_bits(csd, 127, 126);
+ int c_size = ext_bits(csd, 73, 62);
+ int c_size_mult = ext_bits(csd, 49, 47);
+ int read_bl_len = ext_bits(csd, 83, 80);
+
+// printf("CSD_STRUCT = %d\n", csd_structure);
+
+ if(csd_structure != 0) {
+ fprintf(stderr, "This disk tastes funny! I only know about type 0 CSD structures\n");
+ return 0;
+ }
+
+ // memory capacity = BLOCKNR * BLOCK_LEN
+ // where
+ // BLOCKNR = (C_SIZE+1) * MULT
+ // MULT = 2^(C_SIZE_MULT+2) (C_SIZE_MULT < 8)
+ // BLOCK_LEN = 2^READ_BL_LEN, (READ_BL_LEN < 12)
+
+ int block_len = 1 << read_bl_len;
+ int mult = 1 << (c_size_mult + 2);
+ int blocknr = (c_size + 1) * mult;
+ int capacity = blocknr * block_len;
+
+ int blocks = capacity / 512;
+
+ return blocks;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SDFileSystem.h Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,81 @@
+/* mbed SDFileSystem Library, for providing file access to SD cards
+ * Copyright (c) 2008-2010, sford
+ *
+ * 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 MBED_SDFILESYSTEM_H
+#define MBED_SDFILESYSTEM_H
+
+#include "mbed.h"
+#include "FATFileSystem.h"
+
+/** Access the filesystem on an SD Card using SPI
+ *
+ * @code
+ * #include "mbed.h"
+ * #include "SDFileSystem.h"
+ *
+ * SDFileSystem sd(p5, p6, p7, p12, "sd"); // mosi, miso, sclk, cs
+ *
+ * int main() {
+ * FILE *fp = fopen("/sd/myfile.txt", "w");
+ * fprintf(fp, "Hello World!\n");
+ * fclose(fp);
+ * }
+ */
+class SDFileSystem : public FATFileSystem {
+public:
+
+ /** Create the File System for accessing an SD Card using SPI
+ *
+ * @param mosi SPI mosi pin connected to SD Card
+ * @param miso SPI miso pin conencted to SD Card
+ * @param sclk SPI sclk pin connected to SD Card
+ * @param cs DigitalOut pin used as SD Card chip select
+ * @param name The name used to access the virtual filesystem
+ */
+ SDFileSystem(PinName mosi, PinName miso, PinName sclk, PinName cs, const char* name);
+ virtual int disk_initialize();
+ virtual int disk_write(const char *buffer, int block_number);
+ virtual int disk_read(char *buffer, int block_number);
+ virtual int disk_status();
+ virtual int disk_sync();
+ virtual int disk_sectors();
+
+protected:
+
+ int _cmd(int cmd, int arg);
+ int _cmdx(int cmd, int arg);
+ int _cmd8();
+ int _cmd58();
+ int initialise_card();
+ int initialise_card_v1();
+ int initialise_card_v2();
+
+ int _read(char *buffer, int length);
+ int _write(const char *buffer, int length);
+ int _sd_sectors();
+ int _sectors;
+
+ SPI _spi;
+ DigitalOut _cs;
+};
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SerialBuffered.cpp Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,127 @@
+/**
+ * =============================================================================
+ * LS-Y201 device driver class (Version 0.0.1)
+ * Reference documents: LinkSprite JPEG Color Camera Serial UART Interface
+ * January 2010
+ * =============================================================================
+ * Copyright (c) 2010 Shinichiro Nakamura (CuBeatSystems)
+ *
+ * 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.
+ * =============================================================================
+ */
+
+#include "mbed.h"
+#include "SerialBuffered.h"
+
+/**
+ * Create a buffered serial class.
+ *
+ * @param tx A pin for transmit.
+ * @param rx A pin for receive.
+ */
+SerialBuffered::SerialBuffered(PinName tx, PinName rx) : Serial(tx, rx) {
+ indexContentStart = 0;
+ indexContentEnd = 0;
+ timeout = 1;
+ attach(this, &SerialBuffered::handleInterrupt);
+}
+
+/**
+ * Destroy.
+ */
+SerialBuffered::~SerialBuffered() {
+}
+
+/**
+ * Set timeout for getc().
+ *
+ * @param ms milliseconds. (-1:Disable timeout)
+ */
+void SerialBuffered::setTimeout(int ms) {
+ timeout = ms;
+}
+
+/**
+ * Read requested bytes.
+ *
+ * @param bytes A pointer to a buffer.
+ * @param requested Length.
+ *
+ * @return Readed byte length.
+ */
+size_t SerialBuffered::readBytes(uint8_t *bytes, size_t requested) {
+ int i = 0;
+ while (i < requested) {
+ int c = getc();
+ if (c < 0) {
+ break;
+ }
+ bytes[i] = c;
+ i++;
+ }
+ return i;
+}
+
+/**
+ * Get a character.
+ *
+ * @return A character. (-1:timeout)
+ */
+int SerialBuffered::getc() {
+ timer.reset();
+ timer.start();
+ while (indexContentStart == indexContentEnd) {
+ wait_ms(1);
+ if ((timeout > 0) && (timer.read_ms() > timeout)) {
+ /*
+ * Timeout occured.
+ */
+ // printf("Timeout occured.\n");
+ return EOF;
+ }
+ }
+ timer.stop();
+
+ uint8_t result = buffer[indexContentStart++];
+ indexContentStart = indexContentStart % BUFFERSIZE;
+
+ return result;
+}
+
+/**
+ * Returns 1 if there is a character available to read, 0 otherwise.
+ */
+int SerialBuffered::readable() {
+ return indexContentStart != indexContentEnd;
+}
+
+void SerialBuffered::handleInterrupt() {
+ while (Serial::readable()) {
+ if (indexContentStart == ((indexContentEnd + 1) % BUFFERSIZE)) {
+ /*
+ * Buffer overrun occured.
+ */
+ // printf("Buffer overrun occured.\n");
+ Serial::getc();
+ } else {
+ buffer[indexContentEnd++] = Serial::getc();
+ indexContentEnd = indexContentEnd % BUFFERSIZE;
+ }
+ }
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SerialBuffered.h Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,89 @@
+/**
+ * =============================================================================
+ * LS-Y201 device driver class (Version 0.0.1)
+ * Reference documents: LinkSprite JPEG Color Camera Serial UART Interface
+ * January 2010
+ * =============================================================================
+ * Copyright (c) 2010 Shinichiro Nakamura (CuBeatSystems)
+ *
+ * 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 _SERIAL_BUFFERED_H_
+#define _SERIAL_BUFFERED_H_
+
+/**
+ * Buffered serial class.
+ */
+class SerialBuffered : public Serial {
+public:
+ /**
+ * Create a buffered serial class.
+ *
+ * @param tx A pin for transmit.
+ * @param rx A pin for receive.
+ */
+ SerialBuffered(PinName tx, PinName rx);
+
+ /**
+ * Destroy.
+ */
+ virtual ~SerialBuffered();
+
+ /**
+ * Get a character.
+ *
+ * @return A character. (-1:timeout)
+ */
+ int getc();
+
+ /**
+ * Returns 1 if there is a character available to read, 0 otherwise.
+ */
+ int readable();
+
+ /**
+ * Set timeout for getc().
+ *
+ * @param ms milliseconds. (-1:Disable timeout)
+ */
+ void setTimeout(int ms);
+
+ /**
+ * Read requested bytes.
+ *
+ * @param bytes A pointer to a buffer.
+ * @param requested Length.
+ *
+ * @return Readed byte length.
+ */
+ size_t readBytes(uint8_t *bytes, size_t requested);
+
+private:
+ void handleInterrupt();
+ static const int BUFFERSIZE = 4096;
+ uint8_t buffer[BUFFERSIZE]; // points at a circular buffer, containing data from m_contentStart, for m_contentSize bytes, wrapping when you get to the end
+ uint16_t indexContentStart; // index of first bytes of content
+ uint16_t indexContentEnd; // index of bytes after last byte of content
+ int timeout;
+ Timer timer;
+};
+
+#endif
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/TextLCD.cpp Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,159 @@
+/* mbed TextLCD Library, for a 4-bit LCD based on HD44780
+ * Copyright (c) 2007-2010, sford, http://mbed.org
+ *
+ * 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.
+ */
+
+#include "TextLCD.h"
+#include "mbed.h"
+
+TextLCD::TextLCD(PinName rs, PinName e, PinName d0, PinName d1,
+ PinName d2, PinName d3, LCDType type) : _rs(rs),
+ _e(e), _d(d0, d1, d2, d3),
+ _type(type) {
+
+ _e = 1;
+ _rs = 0; // command mode
+
+ wait(0.015); // Wait 15ms to ensure powered up
+
+ // send "Display Settings" 3 times (Only top nibble of 0x30 as we've got 4-bit bus)
+ for (int i=0; i<3; i++) {
+ writeByte(0x3);
+ wait(0.00164); // this command takes 1.64ms, so wait for it
+ }
+ writeByte(0x2); // 4-bit mode
+ wait(0.000040f); // most instructions take 40us
+
+ writeCommand(0x28); // Function set 001 BW N F - -
+ writeCommand(0x0C);
+ writeCommand(0x6); // Cursor Direction and Display Shift : 0000 01 CD S (CD 0-left, 1-right S(hift) 0-no, 1-yes
+ cls();
+}
+
+void TextLCD::character(int column, int row, int c) {
+ int a = address(column, row);
+ writeCommand(a);
+ writeData(c);
+}
+
+void TextLCD::cls() {
+ writeCommand(0x01); // cls, and set cursor to 0
+ wait(0.00164f); // This command takes 1.64 ms
+ locate(0, 0);
+}
+
+void TextLCD::locate(int column, int row) {
+ _column = column;
+ _row = row;
+}
+
+int TextLCD::_putc(int value) {
+ if (value == '\n') {
+ _column = 0;
+ _row++;
+ if (_row >= rows()) {
+ _row = 0;
+ }
+ } else {
+ character(_column, _row, value);
+ _column++;
+ if (_column >= columns()) {
+ _column = 0;
+ _row++;
+ if (_row >= rows()) {
+ _row = 0;
+ }
+ }
+ }
+ return value;
+}
+
+int TextLCD::_getc() {
+ return -1;
+}
+
+void TextLCD::writeByte(int value) {
+ _d = value >> 4;
+ wait(0.000040f); // most instructions take 40us
+ _e = 0;
+ wait(0.000040f);
+ _e = 1;
+ _d = value >> 0;
+ wait(0.000040f);
+ _e = 0;
+ wait(0.000040f); // most instructions take 40us
+ _e = 1;
+}
+
+void TextLCD::writeCommand(int command) {
+ _rs = 0;
+ writeByte(command);
+}
+
+void TextLCD::writeData(int data) {
+ _rs = 1;
+ writeByte(data);
+}
+
+int TextLCD::address(int column, int row) {
+ switch (_type) {
+ case LCD20x4:
+ switch (row) {
+ case 0:
+ return 0x80 + column;
+ case 1:
+ return 0xc0 + column;
+ case 2:
+ return 0x94 + column;
+ case 3:
+ return 0xd4 + column;
+ }
+ case LCD16x2B:
+ return 0x80 + (row * 40) + column;
+ case LCD16x2:
+ case LCD20x2:
+ default:
+ return 0x80 + (row * 0x40) + column;
+ }
+}
+
+int TextLCD::columns() {
+ switch (_type) {
+ case LCD20x4:
+ case LCD20x2:
+ return 20;
+ case LCD16x2:
+ case LCD16x2B:
+ default:
+ return 16;
+ }
+}
+
+int TextLCD::rows() {
+ switch (_type) {
+ case LCD20x4:
+ return 4;
+ case LCD16x2:
+ case LCD16x2B:
+ case LCD20x2:
+ default:
+ return 2;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/TextLCD.h Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,111 @@
+/* mbed TextLCD Library, for a 4-bit LCD based on HD44780
+ * Copyright (c) 2007-2010, sford, http://mbed.org
+ *
+ * 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 MBED_TEXTLCD_H
+#define MBED_TEXTLCD_H
+
+#include "mbed.h"
+
+/** A TextLCD interface for driving 4-bit HD44780-based LCDs
+ *
+ * Currently supports 16x2, 20x2 and 20x4 panels
+ *
+ * @code
+ * #include "mbed.h"
+ * #include "TextLCD.h"
+ *
+ * TextLCD lcd(p10, p12, p15, p16, p29, p30); // rs, e, d0-d3
+ *
+ * int main() {
+ * lcd.printf("Hello World!\n");
+ * }
+ * @endcode
+ */
+class TextLCD : public Stream {
+public:
+
+ /** LCD panel format */
+ enum LCDType {
+ LCD16x2 /**< 16x2 LCD panel (default) */
+ , LCD16x2B /**< 16x2 LCD panel alternate addressing */
+ , LCD20x2 /**< 20x2 LCD panel */
+ , LCD20x4 /**< 20x4 LCD panel */
+ };
+
+ /** Create a TextLCD interface
+ *
+ * @param rs Instruction/data control line
+ * @param e Enable line (clock)
+ * @param d0-d3 Data lines
+ * @param type Sets the panel size/addressing mode (default = LCD16x2)
+ */
+ TextLCD(PinName rs, PinName e, PinName d0, PinName d1, PinName d2, PinName d3, LCDType type = LCD16x2);
+
+#if DOXYGEN_ONLY
+ /** Write a character to the LCD
+ *
+ * @param c The character to write to the display
+ */
+ int putc(int c);
+
+ /** Write a formated string to the LCD
+ *
+ * @param format A printf-style format string, followed by the
+ * variables to use in formating the string.
+ */
+ int printf(const char* format, ...);
+#endif
+
+ /** Locate to a screen column and row
+ *
+ * @param column The horizontal position from the left, indexed from 0
+ * @param row The vertical position from the top, indexed from 0
+ */
+ void locate(int column, int row);
+
+ /** Clear the screen and locate to 0,0 */
+ void cls();
+
+ int rows();
+ int columns();
+
+protected:
+
+ // Stream implementation functions
+ virtual int _putc(int value);
+ virtual int _getc();
+
+ int address(int column, int row);
+ void character(int column, int row, int c);
+ void writeByte(int value);
+ void writeCommand(int command);
+ void writeData(int data);
+
+ DigitalOut _rs, _e;
+ BusOut _d;
+ LCDType _type;
+
+ int _column;
+ int _row;
+};
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,474 @@
+# include <mbed.h>
+#include <mpr121.h>
+#include <string>
+#include <list>
+#include <mpr121.h>
+#include "TextLCD.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <sstream>
+#include <iostream>
+#include "ID12RFID.h"
+#include "Camera_LS_Y201.h"
+#include "SDFileSystem.h"
+
+
+
+TextLCD lcd(p15, p16, p17, p18, p19, p20);
+//ID12RFID rfid(p14);
+DigitalOut led1(LED1);
+DigitalOut led2(LED2);
+DigitalOut led3(LED3);
+DigitalOut led4(LED4);
+bool test1 = false;
+bool test2 = false;
+//int a=0;
+int counter1=0;
+int Code[4]= {0,0,0,0};
+int Code2[4];
+int flag=0;
+int a=0;
+int b=0;
+int enter=0;
+int end=0;
+int c=0;
+int chk1=0;
+int a1=0;
+int r=0;
+InterruptIn interrupt(p26);
+// Setup the i2c bus on pins 9 and 10
+I2C i2c(p9, p10);
+// Setup the Mpr121:
+// constructor(i2c object, i2c address of the mpr121)
+Mpr121 mpr121(&i2c, Mpr121::ADD_VSS);
+ID12RFID rfid(p14); // uart rx
+
+
+
+
+#define USE_SDCARD 1
+
+#if USE_SDCARD
+#define FILENAME "/sd/IMG_%04d.jpg"
+SDFileSystem fs(p5, p6, p7, p8, "sd");
+#else
+#define FILENAME "/local/IMG_%04d.jpg"
+LocalFileSystem fs("local");
+#endif
+Camera_LS_Y201 cam1(p28, p27);
+typedef struct work {
+ FILE *fp;
+} work_t;
+
+work_t work;
+
+/**
+ * Callback function for readJpegFileContent.
+ *
+ * @param buf A pointer to a buffer.
+ * @param siz A size of the buffer.
+ */
+void callback_func(int done, int total, uint8_t *buf, size_t siz) {
+ fwrite(buf, siz, 1, work.fp);
+
+ static int n = 0;
+ int tmp = done * 100 / total;
+ if (n != tmp) {
+ n = tmp;
+ lcd.cls();
+ lcd.printf("Writing...: %3d%%", n);
+ //wait(3);
+ // ////newline();
+ }
+}
+
+/**
+ * Capture.
+ *
+ * @param cam A pointer to a camera object.
+ * @param filename The file name.
+ *
+ * @return Return 0 if it succeed.
+ */
+int capture(Camera_LS_Y201 *cam, char *filename) {
+ /*
+ * Take a picture.
+ */
+ if (cam->takePicture() != 0) {
+ return -1;
+ }
+ lcd.cls();
+ lcd.printf("Captured.");
+ wait(3);
+ // //newline();
+
+ /*
+ * Open file.
+ */
+
+ work.fp = fopen(filename, "wb");
+ if (work.fp == NULL) {
+ return -2;
+ }
+
+ /*
+ * Read the content.
+ */
+ lcd.printf("%s", filename);
+ wait(3);
+ ////newline();
+ if (cam->readJpegFileContent(callback_func) != 0) {
+ fclose(work.fp);
+ return -3;
+ }
+ fclose(work.fp);
+
+ /*
+ * Stop taking pictures.
+ */
+ cam->stopTakingPictures();
+
+ return 0;
+}
+//DigitalOut led1(LED1);
+
+//TextLCD lcd(p15, p16, p17, p18, p19, p20); // rs, e, d4-d7
+// Key hit/release interrupt routine
+void fallInterrupt() {
+ int key_code=0;
+ int i=0;
+ int value=mpr121.read(0x00);
+ value +=mpr121.read(0x01)<<8;
+ // LED demo mod
+ i=0;
+ // puts key number out to LEDs for demo
+ for (i=0; i<12; i++) {
+ if (((value>>i)&0x01)==1)
+ {
+// led4=0;
+ b=1;
+
+ key_code=i+1;
+ if(key_code==12)
+ {
+ end=1;
+ c=0;
+ }
+ else if(key_code==11)
+ {
+ enter=1;
+ c=0;
+ }
+ else
+ {
+ //a=i;
+ if(counter1 < 4)
+ {
+ Code[counter1] = i;
+ counter1++;
+ }
+ if(counter1==4)
+ {
+ Code2[0]=Code[0];
+ Code2[1]=Code[1];
+ Code2[2]=Code[2];
+ Code2[3]=Code[3];
+ Code[0]=0;
+ Code[1]=0;
+ Code[2]=0;
+ Code[3]=0;
+ counter1=0; }
+ c++;
+ }
+
+ /* led4=key_code & 0x01;
+ led3=(key_code>>1) & 0x01;
+ led2=(key_code>>2) & 0x01;
+ led1=(key_code>>3) & 0x01;*/
+ led4=1;
+
+}
+//if(led4)
+//led4=0;
+}
+}
+int main()
+{
+ interrupt.fall(&fallInterrupt);
+ interrupt.mode(PullUp);
+
+ while(1) {
+ //Code[4]={0,0,0,0};
+ lcd.cls();
+ lcd.printf("Welcome to Chase Bank");
+ wait(4);
+ lcd.cls();
+ lcd.printf("Please tap your card");
+ wait(3);
+ if(rfid.readable()) {
+ lcd.cls();
+ a=rfid.read();
+ a1=a;
+ lcd.printf("RFID Tag number : %d\n", a);
+ wait(3);
+ led1=1;
+ } else {
+ lcd.cls();
+ lcd.printf("card not read properly");
+ wait(3);
+ a=0;
+ }
+ if(a==36905538 || a==36910393) {
+ test1=true;
+ lcd.cls();
+ lcd.printf("Valid Card detected\n");
+ wait(3);
+ lcd.printf("Card ID:- %d",a);
+ wait(3);
+ lcd.cls();
+ lcd.printf("Level 1 cleared");
+ wait(2);
+ lcd.cls();
+ lcd.printf("test1--%d",test1);
+ wait(2);
+ }
+ if(test1 && a!=0) {
+ lcd.cls();
+ lcd.printf("Enter 4 digit pin code");
+ wait(10);
+ if(b==1) {
+ //lcd.cls();
+ if(c==1)
+ {
+ lcd.cls();
+ lcd.printf("one key pressed");
+ wait(2);
+ }
+ else if(c==2)
+ {
+ lcd.cls();
+ lcd.printf("second key pressed");
+ wait(2);
+ }
+ else if(c==3)
+ {
+ lcd.cls();
+ lcd.printf("third key pressed");
+ wait(2);
+ }
+ else if(c==4)
+ {
+ lcd.cls();
+ lcd.printf("fourth key pressed");
+ wait(2);
+ lcd.cls();
+ lcd.printf("press enter to submit");
+ wait(3);
+ }
+ if(enter)
+ {
+ lcd.cls();
+ lcd.printf("checking");
+ wait(2);
+ /*lcd.printf("%d",Code2[3]);
+ wait(3);
+ lcd.printf("a=",a1);
+ wait(2);*/
+ if(a1==36905538)
+ chk1=40;
+ else if (a1==36910393)
+ chk1=41;
+
+ if(chk1==40)
+ {
+
+ if(Code2[0]==1 && Code2[1]==2 && Code2[2]==3 && Code2[3]==4) {
+ lcd.cls();
+ lcd.printf("PINCODE ACCEPTED");
+ wait(5);
+ test2=true;
+ lcd.cls();
+ lcd.printf("LEVEL 2 Cleared");
+ wait(3);
+ lcd.cls();
+ lcd.printf("Welcome MR. Db");
+ wait(4);
+ lcd.cls();
+ lcd.printf("your amount is 125$");
+ wait(3);
+ //break;
+ } else {
+ lcd.cls();
+ lcd.printf("Intruder Alert");
+ wait(5);
+ ////////////////////start of capture
+ lcd.cls();
+ lcd.printf("Camera module");
+ wait(1);
+ //newline();
+ lcd.cls();
+ lcd.printf("Resetting...");
+ wait(1);
+ //newline();
+ wait(1);
+
+ if (cam1.reset() == 0) {
+ lcd.cls();
+ lcd.printf("Reset OK.");
+ wait(1);
+ //////newline();
+ } else {
+ lcd.cls();
+ lcd.printf("Reset fail.");
+ wait(2);
+ ////////newline();
+ error("Reset fail.");
+ }
+ wait(1);
+
+ int cnt = 0;
+
+ char fname[64];
+ snprintf(fname, sizeof(fname) - 1, FILENAME, cnt);
+ int r = capture(&cam1, fname);
+ if (r == 0) {
+ lcd.cls();
+ lcd.printf("[%04d]:OK.", cnt);
+ ////newline();
+ led1=1;
+ } else {
+ lcd.cls();
+ lcd.printf("[%04d]:NG. (code=%d)", cnt, r);
+ ////newline();
+ error("Failure.");
+ led2=1;
+ }
+ cnt++;
+ ////////////////end of capture
+ while(r!=10)
+ {
+ if(r%2!=0)
+ {
+ led1=1;
+ led2=0;
+ led3=1;
+ led4=0;
+ }
+ if(r%2==0)
+ {
+ led1=0;
+ led2=1;
+ led3=0;
+ led4=1;
+ }
+
+ r++;
+ wait(1);
+ }
+ if(r==10)
+ r=0;
+ // } break;
+ }
+ }
+ else if(chk1==41)
+ {
+ if(Code2[0]==5 && Code2[1]==6 && Code2[2]==7 && Code2[3]==8) {
+ lcd.cls();
+ lcd.printf("PINCODE ACCEPTED");
+ wait(5);
+ test2=true;
+ lcd.printf("LEVEL 2 Cleared");
+ wait(3);
+ lcd.cls();
+ lcd.printf("Welcome MR. Db");
+ wait(4);
+ lcd.printf("your amount is 125$");
+ wait(3);
+ //break;
+ } else {
+ lcd.cls();
+ lcd.printf("Intruder Alert");
+ wait(5);
+ ////////start of capture
+ lcd.cls();
+ lcd.printf("Camera module");
+ //newline();
+ lcd.cls();
+ lcd.printf("Resetting...");
+ //newline();
+ wait(1);
+
+ if (cam1.reset() == 0) {
+
+ lcd.cls();
+ lcd.printf("Reset OK.");
+ wait(2);////newline();
+ } else {
+ lcd.cls();
+ lcd.printf("Reset fail.");
+ wait(2);////newline();
+ error("Reset fail.");
+ }
+ wait(1);
+
+ int cnt = 0;
+ char fname[64];
+ snprintf(fname, sizeof(fname) - 1, FILENAME, cnt);
+ int r = capture(&cam1, fname);
+ if (r == 0) {
+ lcd.cls();
+ lcd.printf("[%04d]:OK.", cnt);
+ wait(2);////newline();
+ led1=1;
+ } else {
+ lcd.cls();
+ lcd.printf("[%04d]:NG. (code=%d)", cnt, r);
+ wait(2);////newline();
+ error("Failure.");
+ led2=1;
+ }
+ cnt++;
+ /////////////end of capture
+
+ while(r!=10)
+ {
+ if(r%2!=0)
+ {
+ led1=1;
+ led2=0;
+ led3=1;
+ led4=0;
+ }
+ if(r%2==0)
+ {
+ led1=0;
+ led2=1;
+ led3=0;
+ led4=1;
+ }
+
+ r++;
+ wait(1);
+ }
+ if(r==10)
+ r=0;
+ //break;
+ }
+ }
+
+ enter=0;
+ } //end of enter
+ else if(end)
+ {
+ lcd.cls();
+ lcd.printf("ending");
+ wait(3);
+ end=0;
+ } //end of end
+ }//end of b==1
+
+
+ }
+ }
+
+ }
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed.bld Thu Oct 11 20:49:25 2012 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/mbed_official/code/mbed/builds/cd19af002ccc \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mpr121.cpp Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,221 @@
+/*
+Copyright (c) 2011 Anthony Buckton (abuckton [at] blackink [dot} net {dot} au)
+
+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.
+*/
+
+#include <mbed.h>
+#include <sstream>
+#include <string>
+#include <list>
+
+#include <mpr121.h>
+
+Mpr121::Mpr121(I2C *i2c, Address i2cAddress)
+{
+ this->i2c = i2c;
+
+ address = i2cAddress;
+
+ // Configure the MPR121 settings to default
+ this->configureSettings();
+}
+
+
+void Mpr121::configureSettings()
+{
+ // Put the MPR into setup mode
+ this->write(ELE_CFG,0x00);
+
+ // Electrode filters for when data is > baseline
+ unsigned char gtBaseline[] = {
+ 0x01, //MHD_R
+ 0x01, //NHD_R
+ 0x00, //NCL_R
+ 0x00 //FDL_R
+ };
+
+ writeMany(MHD_R,gtBaseline,4);
+
+ // Electrode filters for when data is < baseline
+ unsigned char ltBaseline[] = {
+ 0x01, //MHD_F
+ 0x01, //NHD_F
+ 0xFF, //NCL_F
+ 0x02 //FDL_F
+ };
+
+ writeMany(MHD_F,ltBaseline,4);
+
+ // Electrode touch and release thresholds
+ unsigned char electrodeThresholds[] = {
+ E_THR_T, // Touch Threshhold
+ E_THR_R // Release Threshold
+ };
+
+ for(int i=0; i<12; i++){
+ int result = writeMany((ELE0_T+(i*2)),electrodeThresholds,2);
+ }
+
+ // Proximity Settings
+ unsigned char proximitySettings[] = {
+ 0xff, //MHD_Prox_R
+ 0xff, //NHD_Prox_R
+ 0x00, //NCL_Prox_R
+ 0x00, //FDL_Prox_R
+ 0x01, //MHD_Prox_F
+ 0x01, //NHD_Prox_F
+ 0xFF, //NCL_Prox_F
+ 0xff, //FDL_Prox_F
+ 0x00, //NHD_Prox_T
+ 0x00, //NCL_Prox_T
+ 0x00 //NFD_Prox_T
+ };
+ writeMany(MHDPROXR,proximitySettings,11);
+
+ unsigned char proxThresh[] = {
+ PROX_THR_T, // Touch Threshold
+ PROX_THR_R // Release Threshold
+ };
+ writeMany(EPROXTTH,proxThresh,2);
+
+ this->write(FIL_CFG,0x04);
+
+ // Set the electrode config to transition to active mode
+ this->write(ELE_CFG,0x0c);
+}
+
+void Mpr121::setElectrodeThreshold(int electrode, unsigned char touch, unsigned char release){
+
+ if(electrode > 11) return;
+
+ // Get the current mode
+ unsigned char mode = this->read(ELE_CFG);
+
+ // Put the MPR into setup mode
+ this->write(ELE_CFG,0x00);
+
+ // Write the new threshold
+ this->write((ELE0_T+(electrode*2)), touch);
+ this->write((ELE0_T+(electrode*2)+1), release);
+
+ //Restore the operating mode
+ this->write(ELE_CFG, mode);
+}
+
+
+unsigned char Mpr121::read(int key){
+
+ unsigned char data[2];
+
+ //Start the command
+ i2c->start();
+
+ // Address the target (Write mode)
+ int ack1= i2c->write(address);
+
+ // Set the register key to read
+ int ack2 = i2c->write(key);
+
+ // Re-start for read of data
+ i2c->start();
+
+ // Re-send the target address in read mode
+ int ack3 = i2c->write(address+1);
+
+ // Read in the result
+ data[0] = i2c->read(0);
+
+ // Reset the bus
+ i2c->stop();
+
+ return data[0];
+}
+
+
+int Mpr121::write(int key, unsigned char value){
+
+ //Start the command
+ i2c->start();
+
+ // Address the target (Write mode)
+ int ack1= i2c->write(address);
+
+ // Set the register key to write
+ int ack2 = i2c->write(key);
+
+ // Read in the result
+ int ack3 = i2c->write(value);
+
+ // Reset the bus
+ i2c->stop();
+
+ return (ack1+ack2+ack3)-3;
+}
+
+
+int Mpr121::writeMany(int start, unsigned char* dataSet, int length){
+ //Start the command
+ i2c->start();
+
+ // Address the target (Write mode)
+ int ack= i2c->write(address);
+ if(ack!=1){
+ return -1;
+ }
+
+ // Set the register key to write
+ ack = i2c->write(start);
+ if(ack!=1){
+ return -1;
+ }
+
+ // Write the date set
+ int count = 0;
+ while(ack==1 && (count < length)){
+ ack = i2c->write(dataSet[count]);
+ count++;
+ }
+ // Stop the cmd
+ i2c->stop();
+
+ return count;
+}
+
+
+bool Mpr121::getProximityMode(){
+ if(this->read(ELE_CFG) > 0x0c)
+ return true;
+ else
+ return false;
+}
+
+void Mpr121::setProximityMode(bool mode){
+ this->write(ELE_CFG,0x00);
+ if(mode){
+ this->write(ELE_CFG,0x30); //Sense proximity from ALL pads
+ } else {
+ this->write(ELE_CFG,0x0c); //Sense touch, all 12 pads active.
+ }
+}
+
+
+int Mpr121::readTouchData(){
+ return this->read(0x00);
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mpr121.h Thu Oct 11 20:49:25 2012 +0000
@@ -0,0 +1,157 @@
+/*
+Copyright (c) 2011 Anthony Buckton (abuckton [at] blackink [dot} net {dot} au)
+
+
+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.
+
+ Parts written by Jim Lindblom of Sparkfun
+ Ported to mbed by A.Buckton, Feb 2011
+*/
+
+#ifndef MPR121_H
+#define MPR121_H
+
+//using namespace std;
+
+class Mpr121
+{
+
+public:
+ // i2c Addresses, bit-shifted
+ enum Address { ADD_VSS = 0xb4,// ADD->VSS = 0x5a <-wiring on Sparkfun board
+ ADD_VDD = 0xb6,// ADD->VDD = 0x5b
+ ADD_SCL = 0xb8,// ADD->SDA = 0x5c
+ ADD_SDA = 0xba // ADD->SCL = 0x5d
+ };
+
+ // Real initialiser, takes the i2c address of the device.
+ Mpr121(I2C *i2c, Address i2cAddress);
+
+ bool getProximityMode();
+
+ void setProximityMode(bool mode);
+
+ int readTouchData();
+
+ unsigned char read(int key);
+
+ int write(int address, unsigned char value);
+ int writeMany(int start, unsigned char* dataSet, int length);
+
+ void setElectrodeThreshold(int electrodeId, unsigned char touchThreshold, unsigned char releaseThreshold);
+
+protected:
+ // Configures the MPR with standard settings. This is permitted to be overwritten by sub-classes.
+ void configureSettings();
+
+private:
+ // The I2C bus instance.
+ I2C *i2c;
+
+ // i2c address of this mpr121
+ Address address;
+};
+
+
+// MPR121 Register Defines
+#define MHD_R 0x2B
+#define NHD_R 0x2C
+#define NCL_R 0x2D
+#define FDL_R 0x2E
+#define MHD_F 0x2F
+#define NHD_F 0x30
+#define NCL_F 0x31
+#define FDL_F 0x32
+#define NHDT 0x33
+#define NCLT 0x34
+#define FDLT 0x35
+// Proximity sensing controls
+#define MHDPROXR 0x36
+#define NHDPROXR 0x37
+#define NCLPROXR 0x38
+#define FDLPROXR 0x39
+#define MHDPROXF 0x3A
+#define NHDPROXF 0x3B
+#define NCLPROXF 0x3C
+#define FDLPROXF 0x3D
+#define NHDPROXT 0x3E
+#define NCLPROXT 0x3F
+#define FDLPROXT 0x40
+// Electrode Touch/Release thresholds
+#define ELE0_T 0x41
+#define ELE0_R 0x42
+#define ELE1_T 0x43
+#define ELE1_R 0x44
+#define ELE2_T 0x45
+#define ELE2_R 0x46
+#define ELE3_T 0x47
+#define ELE3_R 0x48
+#define ELE4_T 0x49
+#define ELE4_R 0x4A
+#define ELE5_T 0x4B
+#define ELE5_R 0x4C
+#define ELE6_T 0x4D
+#define ELE6_R 0x4E
+#define ELE7_T 0x4F
+#define ELE7_R 0x50
+#define ELE8_T 0x51
+#define ELE8_R 0x52
+#define ELE9_T 0x53
+#define ELE9_R 0x54
+#define ELE10_T 0x55
+#define ELE10_R 0x56
+#define ELE11_T 0x57
+#define ELE11_R 0x58
+// Proximity Touch/Release thresholds
+#define EPROXTTH 0x59
+#define EPROXRTH 0x5A
+// Debounce configuration
+#define DEB_CFG 0x5B
+// AFE- Analogue Front End configuration
+#define AFE_CFG 0x5C
+// Filter configuration
+#define FIL_CFG 0x5D
+// Electrode configuration - transistions to "active mode"
+#define ELE_CFG 0x5E
+
+#define GPIO_CTRL0 0x73
+#define GPIO_CTRL1 0x74
+#define GPIO_DATA 0x75
+#define GPIO_DIR 0x76
+#define GPIO_EN 0x77
+#define GPIO_SET 0x78
+#define GPIO_CLEAR 0x79
+#define GPIO_TOGGLE 0x7A
+// Auto configration registers
+#define AUTO_CFG_0 0x7B
+#define AUTO_CFG_U 0x7D
+#define AUTO_CFG_L 0x7E
+#define AUTO_CFG_T 0x7F
+
+// Threshold defaults
+// Electrode touch threshold
+#define E_THR_T 0x0F
+// Electrode release threshold
+#define E_THR_R 0x0A
+// Prox touch threshold
+#define PROX_THR_T 0x02
+// Prox release threshold
+#define PROX_THR_R 0x02
+
+#endif