Raspberries/mraa
Private
Public Access
2
0
Fork 0
Code Activity

i2cslave.h: fix line endings

Browse Source 
Signed-off-by: Brendan Le Foll <brendan.le.foll@intel.com>
This commit is contained in:
Brendan Le Foll
2014-04-23 09:28:48 +01:00
parent 173b81c206
commit 09b31759f4
1 changed files with 154 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

306
api/i2cslave.h
View File

@@ -1,152 +1,154 @@
/* /*
* Originally from mbed Microcontroller Library * Originally from mbed Microcontroller Library
* Copyright (c) 2006-2013 ARM Limited * Copyright (c) 2006-2013 ARM Limited
* Copyright (c) 2014 Intel Corporation * Copyright (c) 2014 Intel Corporation
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#pragma once #pragma once
#include <stdio.h> #include <stdio.h>
#include <fcntl.h> #include <fcntl.h>
#include "smbus.hpp" #include "smbus.hpp"
#include "gpio.h"
namespace maa {
namespace maa {
/** An I2C Slave, used for communicating with an I2C Master device
* /** An I2C Slave, used for communicating with an I2C Master device
* Example: *
* @code * Example:
* // Simple I2C responder * @code
* #include <mbed.h> * // Simple I2C responder
* * #include <mbed.h>
* I2CSlave slave(p9, p10); *
* * I2CSlave slave(p9, p10);
* int main() { *
* char buf[10]; * int main() {
* char msg[] = "Slave!"; * char buf[10];
* * char msg[] = "Slave!";
* slave.address(0xA0); *
* while (1) { * slave.address(0xA0);
* int i = slave.receive(); * while (1) {
* switch (i) { * int i = slave.receive();
* case I2CSlave::ReadAddressed: * switch (i) {
* slave.write(msg, strlen(msg) + 1); // Includes null char * case I2CSlave::ReadAddressed:
* break; * slave.write(msg, strlen(msg) + 1); // Includes null char
* case I2CSlave::WriteGeneral: * break;
* slave.read(buf, 10); * case I2CSlave::WriteGeneral:
* printf("Read G: %s\n", buf); * slave.read(buf, 10);
* break; * printf("Read G: %s\n", buf);
* case I2CSlave::WriteAddressed: * break;
* slave.read(buf, 10); * case I2CSlave::WriteAddressed:
* printf("Read A: %s\n", buf); * slave.read(buf, 10);
* break; * printf("Read A: %s\n", buf);
* } * break;
* for(int i = 0; i < 10; i++) buf[i] = 0; // Clear buffer * }
* } * for(int i = 0; i < 10; i++) buf[i] = 0; // Clear buffer
* } * }
* @endcode * }
*/ * @endcode
class I2CSlave { */
class I2CSlave {
public:
enum RxStatus { public:
NoData = 0, enum RxStatus {
ReadAddressed = 1, NoData = 0,
WriteGeneral = 2, ReadAddressed = 1,
WriteAddressed = 3 WriteGeneral = 2,
}; WriteAddressed = 3
};
/** Create an I2C Slave interface, connected to the specified pins.
* /** Create an I2C Slave interface, connected to the specified pins.
* @param sda I2C data line pin *
* @param scl I2C clock line pin * @param sda I2C data line pin
*/ * @param scl I2C clock line pin
I2CSlave(unsigned int sda, unsigned int scl); */
I2CSlave(unsigned int sda, unsigned int scl);
/** Set the frequency of the I2C interface
* /** Set the frequency of the I2C interface
* @param hz The bus frequency in hertz *
*/ * @param hz The bus frequency in hertz
void frequency(int hz); */
void frequency(int hz);
/** Checks to see if this I2C Slave has been addressed.
* /** Checks to see if this I2C Slave has been addressed.
* @returns *
* A status indicating if the device has been addressed, and how * @returns
* - NoData - the slave has not been addressed * A status indicating if the device has been addressed, and how
* - ReadAddressed - the master has requested a read from this slave * - NoData - the slave has not been addressed
* - WriteAddressed - the master is writing to this slave * - ReadAddressed - the master has requested a read from this slave
* - WriteGeneral - the master is writing to all slave * - WriteAddressed - the master is writing to this slave
*/ * - WriteGeneral - the master is writing to all slave
int receive(void); */
int receive(void);
/** Read from an I2C master.
* /** Read from an I2C master.
* @param data pointer to the byte array to read data in to *
* @param length maximum number of bytes to read * @param data pointer to the byte array to read data in to
* * @param length maximum number of bytes to read
* @returns *
* 0 on success, * @returns
* non-0 otherwise * 0 on success,
*/ * non-0 otherwise
int read(char *data, int length); */
int read(char *data, int length);
/** Read a single byte from an I2C master.
* /** Read a single byte from an I2C master.
* @returns *
* the byte read * @returns
*/ * the byte read
int read(void); */
int read(void);
/** Write to an I2C master.
* /** Write to an I2C master.
* @param data pointer to the byte array to be transmitted *
* @param length the number of bytes to transmite * @param data pointer to the byte array to be transmitted
* * @param length the number of bytes to transmite
* @returns *
* 0 on success, * @returns
* non-0 otherwise * 0 on success,
*/ * non-0 otherwise
int write(const char *data, int length); */
int write(const char *data, int length);
/** Write a single byte to an I2C master.
* /** Write a single byte to an I2C master.
* @data the byte to write *
* * @data the byte to write
* @returns *
* '1' if an ACK was received, * @returns
* '0' otherwise * '1' if an ACK was received,
*/ * '0' otherwise
int write(int data); */
int write(int data);
/** Sets the I2C slave address.
* /** Sets the I2C slave address.
* @param address The address to set for the slave (ignoring the least *
* signifcant bit). If set to 0, the slave will only respond to the * @param address The address to set for the slave (ignoring the least
* general call address. * signifcant bit). If set to 0, the slave will only respond to the
*/ * general call address.
void address(int address); */
void address(int address);
/** Reset the I2C slave back into the known ready receiving state.
*/ /** Reset the I2C slave back into the known ready receiving state.
void stop(void); */
void stop(void);
protected:
int _hz; protected:
int i2c_handle; int _hz;
int _addr; int i2c_handle;
}; int _addr;
gpio_t gpio;
} };
}