/**
* \brief Receive a sequence of 16-bit words from an SPI device.
*
* All bytes sent out on SPI bus are sent as value 0xff.
*
* \param p_spi Base address of the SPI instance.
* \param data Data buffer to read.
* \param len Number of words of data to be read.
*
* \pre SPI device must be selected with spi_select_device() first.
*/
spi_status_t spi_read_packet16(Spi *p_spi, uint16_t *data, size_t len)
{
if (len-- == 0)
return SPI_OK;
for (uint16_t i = 0; i < len; i++)
{
uint32_t timeout = SPI_TIMEOUT;
while (!spi_is_tx_ready(p_spi)) {
if (!timeout--) {
return SPI_ERROR_TIMEOUT;
}
}
p_spi->SPI_TDR = 0x0000FFFF;
timeout = SPI_TIMEOUT;
while (!spi_is_rx_ready(p_spi)) {
if (!timeout--) {
return SPI_ERROR_TIMEOUT;
}
}
data[i] = (uint16_t)(p_spi->SPI_RDR);
}
return spi_read_single16(p_spi, &data[len]);
}
/**
* \brief Receive a sequence of bytes from an SPI device.
*
* All bytes sent out on SPI bus are sent as value 0.
*
* \param p_spi Base address of the SPI instance.
* \param data Data buffer to read.
* \param len Length of data to be read.
*
* \pre SPI device must be selected with spi_select_device() first.
*/
status_code_t spi_read_packet(Spi *p_spi, uint8_t *data, size_t len)
{
uint32_t timeout = SPI_TIMEOUT;
uint8_t val;
uint32_t i = 0;
while (len) {
timeout = SPI_TIMEOUT;
while (!spi_is_tx_ready(p_spi)) {
if (!timeout--) {
return ERR_TIMEOUT;
}
}
spi_write_single(p_spi, CONFIG_SPI_MASTER_DUMMY);
timeout = SPI_TIMEOUT;
while (!spi_is_rx_ready(p_spi)) {
if (!timeout--) {
return ERR_TIMEOUT;
}
}
spi_read_single(p_spi, &val);
data[i] = val;
i++;
len--;
}
return STATUS_OK;
}
/**
* \brief Send and receive a sequence of bytes from an SPI device.
*
* \param p_spi Base address of the SPI instance.
* \param tx_data Data buffer to send.
* \param rx_data Data buffer to read.
* \param len Length of data to be read.
*
* \pre SPI device must be selected with spi_select_device() first.
*/
spi_status_t spi_transceive_packet(Spi *p_spi, uint8_t *tx_data, uint8_t *rx_data, size_t len)
{
uint32_t timeout = SPI_TIMEOUT;
uint8_t val;
uint32_t i = 0;
while (len) {
timeout = SPI_TIMEOUT;
while (!spi_is_tx_ready(p_spi)) {
if (!timeout--) {
return SPI_ERROR_TIMEOUT;
}
}
spi_write_single(p_spi, tx_data[i]);
timeout = SPI_TIMEOUT;
while (!spi_is_rx_ready(p_spi)) {
if (!timeout--) {
return SPI_ERROR_TIMEOUT;
}
}
spi_read_single(p_spi, &val);
rx_data[i] = val;
i++;
len--;
}
return SPI_OK;
}
/**
* \brief Put one data to a SPI peripheral.
*
* \param p_spi Base address of the SPI instance.
* \param data The data byte to be loaded
*
*/
spi_status_t spi_write_single(Spi *p_spi, uint8_t data)
{
// p_spi->SPI_TDR = SPI_TDR_TD(data);
// wait for transmit register empty
uint32_t timeout = SPI_TIMEOUT;
while (!spi_is_tx_ready(p_spi)) {
if (!timeout--)
{
return SPI_ERROR_TIMEOUT;
}
}
// write byte with address and end transmission flag
p_spi->SPI_TDR = (uint32_t)data | SPI_TDR_LASTXFER;
// wait for receive register
timeout = SPI_TIMEOUT;
while (!spi_is_rx_ready(p_spi)) {
if (--timeout == 0) {
return SPI_ERROR_TIMEOUT;
}
}
// clear status
p_spi->SPI_RDR;
return SPI_OK;
}
/**
* \brief Send a sequence of bytes to an SPI device.
*
* Received bytes on the SPI bus are discarded.
*
* \param p_spi Base address of the SPI instance.
* \param data Data buffer to write.
* \param len Length of data to be written.
*
* \pre SPI device must be selected with spi_select_device() first.
*/
spi_status_t spi_write_packet(Spi *p_spi, const uint8_t *data, size_t len)
{
if (len == 0)
return SPI_OK;
for (size_t i = 0; i < len-1; i++)
{
uint32_t timeout = SPI_TIMEOUT;
while (!spi_is_tx_ready(p_spi)) {
if (!timeout--) {
return SPI_ERROR_TIMEOUT;
}
}
p_spi->SPI_TDR = (uint32_t)data[i];
while (!spi_is_rx_ready(p_spi)) {
if (!timeout--) {
return SPI_ERROR_TIMEOUT;
}
}
p_spi->SPI_RDR;
}
return spi_write_single(p_spi, data[len-1]);
}
/** \brief Get one data to a SPI peripheral.
*
* \param p_spi Base address of the SPI instance.
* \return The data byte
*
*/
spi_status_t spi_read_single16(Spi *p_spi, uint16_t *b)
{
// wait for transmit register empty
uint32_t timeout = SPI_TIMEOUT;
while (!spi_is_tx_ready(p_spi)) {
if (--timeout == 0) {
return SPI_ERROR_TIMEOUT;
}
}
// write dummy byte with address and end transmission flag
p_spi->SPI_TDR = 0x0000FFFF | SPI_TDR_LASTXFER;
// wait for receive register
timeout = SPI_TIMEOUT;
while (!spi_is_rx_ready(p_spi)) {
if (--timeout == 0) {
return SPI_ERROR_TIMEOUT;
}
}
// get byte from receive register
*b = (uint16_t)p_spi->SPI_RDR;
return SPI_OK;
}
/*! \brief Sets the number of filter taps of the IMU internal low pass filter.
\details
*/
void low_pass_filter_setting(uint8_t nr_filter_taps){
uint8_t log2_nr_filter_taps = nr_filter_taps;
if (log2_nr_filter_taps>MAX_LOG2_NR_FILTER_TAPS){
log2_nr_filter_taps=MAX_LOG2_NR_FILTER_TAPS;}
uint16_t tx_word = log2_nr_filter_taps + (1<<8)*SET_NR_FILTER_TAPS;
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,tx_word);
}
void ENC28J60_WriteOp(uint8_t op, uint8_t address, uint8_t data)
{
uint8_t cmd;
spi_select_device(avr32SPI, &spiDevice);
cmd = op | GET_REGISTERADDRESS(address);
spi_write_single(avr32SPI, cmd);
for(;;)
{
if(spi_is_tx_ready(avr32SPI))
break;
}
spi_write_single(avr32SPI, data);
for(;;)
{
if(spi_is_tx_ready(avr32SPI))
break;
}
spi_deselect_device(avr32SPI, &spiDevice);
}
void ENC28J60_WriteBuffer(uint16_t len, uint8_t* data)
{
status_code_t ret = STATUS_OK;
spi_select_device(avr32SPI, &spiDevice);
spi_write_single(avr32SPI, ENC28J60_WRITE_BUF_MEM);
for(;;)
{
if(spi_is_tx_ready(avr32SPI))
break;
}
ret = spi_write_packet(avr32SPI, data, len);
spi_deselect_device(avr32SPI, &spiDevice);
}
uint8_t ENC28J60_ReadOp(uint8_t op, uint8_t address)
{
uint8_t cmd;
uint8_t data = 0;
spi_select_device(avr32SPI, &spiDevice);
cmd = op | GET_REGISTERADDRESS(address);
spi_write_packet(avr32SPI, &cmd, 1);
for(;;)
{
if(spi_is_tx_ready(avr32SPI))
break;
}
spi_read_packet(avr32SPI, &data, 1);
spi_deselect_device(avr32SPI, &spiDevice);
return data;
}
/**
* \brief Send a command to the ADS7843 touch controller.
*
* \param uc_cmd command to send.
*
* \return Command result.
*/
static uint32_t ads7843_send_cmd(uint8_t uc_cmd)
{
uint32_t uResult = 0;
volatile uint32_t i;
uint8_t data;
uint32_t timeout = SPI_TIMEOUT;
/* (volatile declaration needed for code optimisation by compiler) */
volatile uint8_t bufferRX[ADS7843_BUFSIZE];
volatile uint8_t bufferTX[ADS7843_BUFSIZE];
bufferRX[0] = 0;
bufferRX[1] = 0;
bufferRX[2] = 0;
bufferTX[0] = uc_cmd;
bufferTX[1] = 0;
bufferTX[2] = 0;
for(i = 0; i < ADS7843_BUFSIZE; i++){
timeout = SPI_TIMEOUT;
while (!spi_is_tx_ready(BOARD_ADS7843_SPI_BASE)) {
if (!timeout--) {
return SPI_ERROR_TIMEOUT;
}
}
spi_write_single(BOARD_ADS7843_SPI_BASE, bufferTX[i]);
}
for(i = 0; i < ADS7843_BUFSIZE; i++){
timeout = SPI_TIMEOUT;
while (!spi_is_rx_full(BOARD_ADS7843_SPI_BASE)) {
if (!timeout--) {
return SPI_ERROR_TIMEOUT;
}
}
spi_read_single(BOARD_ADS7843_SPI_BASE, &data);
bufferRX[i] = data;
}
uResult = (uint32_t)bufferRX[1] << 8;
uResult |= (uint32_t)bufferRX[2];
uResult = uResult >> 4;
return uResult;
}
status_code_t spi_write_packet(volatile avr32_spi_t *spi, const uint8_t *data,
size_t len)
{
unsigned int timeout = SPI_TIMEOUT;
size_t i=0;
uint8_t val;
while(len) {
timeout = SPI_TIMEOUT;
while (!spi_is_tx_ready(spi)) {
if (!timeout--) {
return ERR_TIMEOUT;
}
}
val = data[i];
spi_write_single(spi,val);
i++;
len--;
}
return STATUS_OK;
}
/**
* \brief Send a sequence of bytes to an SPI device.
*
* Received bytes on the SPI bus are discarded.
*
* \param p_spi Base address of the SPI instance.
* \param data Data buffer to write.
* \param len Length of data to be written.
*
* \pre SPI device must be selected with spi_select_device() first.
*/
status_code_t spi_write_packet(Spi *p_spi, const uint8_t *data,
size_t len)
{
uint32_t timeout = SPI_TIMEOUT;
uint32_t i = 0;
uint8_t val;
while (len) {
timeout = SPI_TIMEOUT;
while (!spi_is_tx_ready(p_spi)) {
if (!timeout--) {
return ERR_TIMEOUT;
}
}
val = data[i];
spi_write_single(p_spi, val);
i++;
len--;
}
return STATUS_OK;
}
/*! \brief Initializes the internal IMU gyro calibration routine.
\details The internal gyro calibration routine will take the mean gyro
value over approx. 15s. During this time the IMU will be off-line (not
sending out any interrupts). During this period the IMU should be kept
statinarry.
*/
void precision_gyro_bias_null_calibration(void){
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,PRECISION_GYRO_BIAS_CALIBRATION);
// After this the IMU will be off-line for ~15s
}
/*! \brief Request and reads all sensor output data from IMU.
\details This function uses the IMU burst read functionallity in which all
IMU sensor data (rotation, specific force, temperature, and supply voltage)
is output by the IMU after a single request. This way only two clock
cycles are required between each read operation. This is faster than only
reading out rotation and specific force.
The functions first reads in the values in 16-bit intermediate variables
and then call the help functions convert_inert_readings() and
convert_auxiliary_data() to shift out status bits and scale to SI units.
@param[out] angular_rates_in Vector containing the 3 (x,y,z) angular rates in [rad/sec].
@param[out] accelerations_in Vector containing the 3 (x,y,z) specific force in [m/s^2].
@param[out] imu_temperatures Vector containing the 3 (x,y,z) temperatur readings in [C].
@param[out] imu_supply_voltage Supply voltage measurement in [V].
*/
void imu_burst_read(void){
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,BURST_READ);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
supply = spi_get(SPI_IMU);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
xgyro = spi_get(SPI_IMU);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
ygyro = spi_get(SPI_IMU);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
zgyro = spi_get(SPI_IMU);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
xacc = spi_get(SPI_IMU);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
yacc = spi_get(SPI_IMU);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
zacc = spi_get(SPI_IMU);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
xtemp = spi_get(SPI_IMU);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
ytemp = spi_get(SPI_IMU);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
ztemp = spi_get(SPI_IMU);
while (!spi_is_tx_ready(SPI_IMU)) {;}
spi_put(SPI_IMU,CONFIG_SPI_MASTER_DUMMY);
while (!spi_is_rx_ready(SPI_IMU)) {;}
aux_adc = spi_get(SPI_IMU);
convert_inert_readings();
convert_auxiliary_data();
}
