1
0
mirror of https://github.com/MarlinFirmware/Marlin.git synced 2024-12-15 06:51:40 +00:00
MarlinFirmware/Marlin/src/HAL/HAL_LPC1768/include/Wire.cpp

219 lines
5.8 KiB
C++
Raw Normal View History

2017-11-10 03:46:26 +00:00
/*
TwoWire.cpp - TWI/I2C library for Wiring & Arduino
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifdef TARGET_LPC1768
extern "C" {
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <lpc17xx_i2c.h>
#include <lpc17xx_pinsel.h>
#include <lpc17xx_libcfg_default.h>
}
#include <Wire.h>
2017-11-10 03:46:26 +00:00
#define USEDI2CDEV_M 1
#if (USEDI2CDEV_M == 0)
#define I2CDEV_M LPC_I2C0
#elif (USEDI2CDEV_M == 1)
#define I2CDEV_M LPC_I2C1
#elif (USEDI2CDEV_M == 2)
#define I2CDEV_M LPC_I2C2
#else
#error "Master I2C device not defined!"
#endif
// Initialize Class Variables //////////////////////////////////////////////////
uint8_t TwoWire::rxBuffer[BUFFER_LENGTH];
uint8_t TwoWire::rxBufferIndex = 0;
uint8_t TwoWire::rxBufferLength = 0;
uint8_t TwoWire::txAddress = 0;
uint8_t TwoWire::txBuffer[BUFFER_LENGTH];
uint8_t TwoWire::txBufferIndex = 0;
uint8_t TwoWire::txBufferLength = 0;
uint8_t TwoWire::transmitting = 0;
// Constructors ////////////////////////////////////////////////////////////////
TwoWire::TwoWire() {
}
// Public Methods //////////////////////////////////////////////////////////////
void TwoWire::begin(void) {
rxBufferIndex = 0;
rxBufferLength = 0;
txBufferIndex = 0;
txBufferLength = 0;
/*
* Init I2C pin connect
*/
PINSEL_CFG_Type PinCfg;
PinCfg.OpenDrain = 0;
PinCfg.Pinmode = 0;
2018-02-02 09:15:01 +00:00
#if USEDI2CDEV_M == 0
2017-11-10 03:46:26 +00:00
PinCfg.Funcnum = 1;
PinCfg.Pinnum = 27;
PinCfg.Portnum = 0;
PINSEL_ConfigPin(&PinCfg); // SDA0 / D57 AUX-1
PinCfg.Pinnum = 28;
PINSEL_ConfigPin(&PinCfg); // SCL0 / D58 AUX-1
#endif
2018-02-02 09:15:01 +00:00
#if USEDI2CDEV_M == 1
2017-11-10 03:46:26 +00:00
PinCfg.Funcnum = 3;
PinCfg.Pinnum = 0;
PinCfg.Portnum = 0;
PINSEL_ConfigPin(&PinCfg); // SDA1 / D20 SCA
PinCfg.Pinnum = 1;
PINSEL_ConfigPin(&PinCfg); // SCL1 / D21 SCL
#endif
2018-02-02 09:15:01 +00:00
#if USEDI2CDEV_M == 2
2017-11-10 03:46:26 +00:00
PinCfg.Funcnum = 2;
PinCfg.Pinnum = 10;
PinCfg.Portnum = 0;
PINSEL_ConfigPin(&PinCfg); // SDA2 / D38 X_ENABLE_PIN
PinCfg.Pinnum = 11;
PINSEL_ConfigPin(&PinCfg); // SCL2 / D55 X_DIR_PIN
#endif
// Initialize I2C peripheral
I2C_Init(I2CDEV_M, 100000);
2018-02-02 09:15:01 +00:00
2017-11-10 03:46:26 +00:00
// Enable Master I2C operation
I2C_Cmd(I2CDEV_M, I2C_MASTER_MODE, ENABLE);
}
uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity) {
// clamp to buffer length
2018-02-02 09:15:01 +00:00
if (quantity > BUFFER_LENGTH)
2017-11-10 03:46:26 +00:00
quantity = BUFFER_LENGTH;
2018-02-02 09:15:01 +00:00
2017-11-10 03:46:26 +00:00
// perform blocking read into buffer
I2C_M_SETUP_Type transferMCfg;
transferMCfg.sl_addr7bit = address >> 1; // not sure about the right shift
transferMCfg.tx_data = NULL;
transferMCfg.tx_length = 0;
transferMCfg.rx_data = rxBuffer;
transferMCfg.rx_length = quantity;
transferMCfg.retransmissions_max = 3;
I2C_MasterTransferData(I2CDEV_M, &transferMCfg, I2C_TRANSFER_POLLING);
// set rx buffer iterator vars
rxBufferIndex = 0;
rxBufferLength = transferMCfg.rx_count;
return transferMCfg.rx_count;
}
uint8_t TwoWire::requestFrom(int address, int quantity) {
return requestFrom((uint8_t)address, (uint8_t)quantity);
}
void TwoWire::beginTransmission(uint8_t address) {
// indicate that we are transmitting
transmitting = 1;
// set address of targeted slave
txAddress = address;
// reset tx buffer iterator vars
txBufferIndex = 0;
txBufferLength = 0;
}
void TwoWire::beginTransmission(int address) {
beginTransmission((uint8_t)address);
}
uint8_t TwoWire::endTransmission(void) {
// transmit buffer (blocking)
I2C_M_SETUP_Type transferMCfg;
transferMCfg.sl_addr7bit = txAddress >> 1; // not sure about the right shift
transferMCfg.tx_data = txBuffer;
transferMCfg.tx_length = txBufferLength;
transferMCfg.rx_data = NULL;
transferMCfg.rx_length = 0;
transferMCfg.retransmissions_max = 3;
Status status = I2C_MasterTransferData(I2CDEV_M, &transferMCfg, I2C_TRANSFER_POLLING);
2018-02-02 09:15:01 +00:00
2017-11-10 03:46:26 +00:00
// reset tx buffer iterator vars
txBufferIndex = 0;
txBufferLength = 0;
// indicate that we are done transmitting
transmitting = 0;
2018-02-02 09:15:01 +00:00
return status == SUCCESS ? 0 : 4;
2017-11-10 03:46:26 +00:00
}
// must be called after beginTransmission(address)
size_t TwoWire::write(uint8_t data) {
if (transmitting) {
// don't bother if buffer is full
2018-02-02 09:15:01 +00:00
if (txBufferLength >= BUFFER_LENGTH) return 0;
2017-11-10 03:46:26 +00:00
// put byte in tx buffer
2018-02-02 09:15:01 +00:00
txBuffer[txBufferIndex++] = data;
2017-11-10 03:46:26 +00:00
2018-02-02 09:15:01 +00:00
// update amount in buffer
2017-11-10 03:46:26 +00:00
txBufferLength = txBufferIndex;
}
return 1;
}
// must be called after beginTransmission(address)
size_t TwoWire::write(const uint8_t *data, size_t quantity) {
size_t sent = 0;
if (transmitting)
2018-02-02 09:15:01 +00:00
for (sent = 0; sent < quantity; ++sent)
if (!write(data[sent])) break;
2017-11-10 03:46:26 +00:00
return sent;
}
2018-02-02 09:15:01 +00:00
// Must be called after requestFrom(address, numBytes)
2017-11-10 03:46:26 +00:00
int TwoWire::available(void) {
return rxBufferLength - rxBufferIndex;
}
2018-02-02 09:15:01 +00:00
// Must be called after requestFrom(address, numBytes)
2017-11-10 03:46:26 +00:00
int TwoWire::read(void) {
2018-02-02 09:15:01 +00:00
return rxBufferIndex < rxBufferLength ? rxBuffer[rxBufferIndex++] : -1;
2017-11-10 03:46:26 +00:00
}
2018-02-02 09:15:01 +00:00
// Must be called after requestFrom(address, numBytes)
2017-11-10 03:46:26 +00:00
int TwoWire::peek(void) {
2018-02-02 09:15:01 +00:00
return rxBufferIndex < rxBufferLength ? rxBuffer[rxBufferIndex] : -1;
2017-11-10 03:46:26 +00:00
}
// Preinstantiate Objects //////////////////////////////////////////////////////
TwoWire Wire = TwoWire();
#endif // TARGET_LPC1768