rt_spi.h File Reference

#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <spi_command_t.hpp>
#include <spi_data_t.hpp>
#include <spi_torque_t.hpp>

Include dependency graph for rt_spi.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	spine_cmd_t
struct	spine_data_t

Macros
#define	K_EXPECTED_COMMAND_SIZE   256
#define	K_WORDS_PER_MESSAGE   66
#define	K_EXPECTED_DATA_SIZE   116
#define	K_KNEE_OFFSET_POS   4.35f
#define	BYTE_TO_BINARY_PATTERN   "%c%c%c%c%c%c%c%c"
#define	BYTE_TO_BINARY(byte)

Functions
void	init_spi ()
void	spi_send_receive (spi_command_t *command, spi_data_t *data)
void	spi_driver_run ()
spi_data_t *	get_spi_data ()
spi_command_t *	get_spi_command ()

Macro Definition Documentation

#define BYTE_TO_BINARY

(

byte

)

Value:

(byte & 0x80 ? '1' : '0'), (byte & 0x40 ? '1' : '0'),     \
      (byte & 0x20 ? '1' : '0'), (byte & 0x10 ? '1' : '0'), \
      (byte & 0x08 ? '1' : '0'), (byte & 0x04 ? '1' : '0'), \
      (byte & 0x02 ? '1' : '0'), (byte & 0x01 ? '1' : '0')

Definition at line 33 of file rt_spi.h.

#define BYTE_TO_BINARY_PATTERN   "%c%c%c%c%c%c%c%c"

Definition at line 32 of file rt_spi.h.

#define K_EXPECTED_COMMAND_SIZE   256

Definition at line 27 of file rt_spi.h.

#define K_EXPECTED_DATA_SIZE   116

Definition at line 29 of file rt_spi.h.

#define K_KNEE_OFFSET_POS   4.35f

Definition at line 30 of file rt_spi.h.

#define K_WORDS_PER_MESSAGE   66

Definition at line 28 of file rt_spi.h.

Function Documentation

spi_command_t* get_spi_command

(

)

Definition at line 332 of file rt_spi.cpp.

References spi_command_drv.

                                 {
  // printf("Get spi command\n");
  return &spi_command_drv;
}

Here is the caller graph for this function:

spi_data_t* get_spi_data

(

)

Definition at line 337 of file rt_spi.cpp.

References spi_data_drv.

{ return &spi_data_drv; }

Here is the caller graph for this function:

void init_spi

(

)

Definition at line 110 of file rt_spi.cpp.

References K_EXPECTED_COMMAND_SIZE, K_EXPECTED_DATA_SIZE, spi_command_drv, spi_data_drv, spi_mutex, and spi_open().

                {
  // check sizes:
  size_t command_size = sizeof(spi_command_t);
  size_t data_size = sizeof(spi_data_t);

  memset(&spi_command_drv, 0, sizeof(spi_command_drv));
  memset(&spi_data_drv, 0, sizeof(spi_data_drv));

  if (pthread_mutex_init(&spi_mutex, NULL) != 0)
    printf("[ERROR: RT SPI] Failed to create spi data mutex\n");

  if (command_size != K_EXPECTED_COMMAND_SIZE) {
    printf("[RT SPI] Error command size is %ld, expected %d\n", command_size,
           K_EXPECTED_COMMAND_SIZE);
  } else
    printf("[RT SPI] command size good\n");

  if (data_size != K_EXPECTED_DATA_SIZE) {
    printf("[RT SPI] Error data size is %ld, expected %d\n", data_size,
           K_EXPECTED_DATA_SIZE);
  } else
    printf("[RT SPI] data size good\n");

  printf("[RT SPI] Open\n");
  spi_open();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void spi_driver_run

(

)

Definition at line 319 of file rt_spi.cpp.

References fake_spine_control(), publish_spi_torque(), spi_command_drv, spi_data_drv, spi_mutex, spi_send_receive(), and spi_torque.

                      {
  // do spi board calculations
  for (int i = 0; i < 4; i++) {
    fake_spine_control(&spi_command_drv, &spi_data_drv, &spi_torque, i);
  }
  publish_spi_torque(&spi_torque);

  // in here, the driver is good
  pthread_mutex_lock(&spi_mutex);
  spi_send_receive(&spi_command_drv, &spi_data_drv);
  pthread_mutex_unlock(&spi_mutex);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void spi_send_receive	(	spi_command_t *	command,
		spi_data_t *	data
	)

Definition at line 260 of file rt_spi.cpp.

References K_WORDS_PER_MESSAGE, spi_1_fd, spi_2_fd, spi_bits_per_word, spi_driver_iterations, spi_to_spine(), and spine_to_spi().

                                                                {
  // update driver status flag
  spi_driver_iterations++;
  data->spi_driver_status = spi_driver_iterations << 16;

  // transmit and receive buffers
  uint16_t tx_buf[K_WORDS_PER_MESSAGE];
  uint16_t rx_buf[K_WORDS_PER_MESSAGE];

  for (int spi_board = 0; spi_board < 2; spi_board++) {
    // copy command into spine type:
    spi_to_spine(command, &g_spine_cmd, spi_board * 2);

    // pointers to command/data spine array
    uint16_t *cmd_d = (uint16_t *)&g_spine_cmd;
    uint16_t *data_d = (uint16_t *)&g_spine_data;

    // zero rx buffer
    memset(rx_buf, 0, K_WORDS_PER_MESSAGE * sizeof(uint16_t));

    // copy into tx buffer flipping bytes
    for (int i = 0; i < K_WORDS_PER_MESSAGE; i++)
      tx_buf[i] = (cmd_d[i] >> 8) + ((cmd_d[i] & 0xff) << 8);
    // tx_buf[i] = __bswap_16(cmd_d[i]);

    // each word is two bytes long
    size_t word_len = 2;  // 16 bit word

    // spi message struct
    struct spi_ioc_transfer spi_message[1];

    // zero message struct.
    memset(spi_message, 0, 1 * sizeof(struct spi_ioc_transfer));

    // set up message struct
    for (int i = 0; i < 1; i++) {
      spi_message[i].bits_per_word = spi_bits_per_word;
      spi_message[i].cs_change = 1;
      spi_message[i].delay_usecs = 0;
      spi_message[i].len = word_len * 66;
      spi_message[i].rx_buf = (uint64_t)rx_buf;
      spi_message[i].tx_buf = (uint64_t)tx_buf;
    }

    // do spi communication
    int rv = ioctl(spi_board == 0 ? spi_1_fd : spi_2_fd, SPI_IOC_MESSAGE(1),
                   &spi_message);
    (void)rv;

    // flip bytes the other way
    for (int i = 0; i < 30; i++)
      data_d[i] = (rx_buf[i] >> 8) + ((rx_buf[i] & 0xff) << 8);
    // data_d[i] = __bswap_16(rx_buf[i]);

    // copy back to data
    spine_to_spi(data, &g_spine_data, spi_board * 2);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: