spi_functions.h File Reference

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>

Include dependency graph for spi_functions.h:

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

Go to the source code of this file.

Macros
#define	ARRAY_SIZE(a)   (sizeof(a) / sizeof((a)[0]))
#define	ENCODER_NO_OP   0x00
#define	ENCODER_RD_POS   0x10
#define	ENCODER_SET_ZERO_PT   0x70
#define	ENCODER_EEPROM_WR   0x80
#define	ENCODER_EEPROM_RD   0x90

Functions
int	spi_init (uint8_t mode, uint32_t speed, uint8_t cs)
	spi Functions to deal communication by SPI protocol More...
void	spi_end (int spi_dev)
	TERMINATES SPI DEVICE. More...
int	adc_read (int spi_dev, uint8_t ch, uint8_t sgl, short int *data)
	READ DATA FROM A/D CONVERTER MCP3208. More...
int	dac_write (int spi_dev, uint8_t ch, uint8_t _shdn, unsigned short int data)
	WRITE DATA TO D/A CONVERTER MCP3922. More...
int	spi_trans_bytes (int spi_dev, uint8_t *send, uint8_t *receive, int n)
	TRANSFER N BYTES. More...

Macro Definition Documentation

#define ARRAY_SIZE

(

a

)

(sizeof(a) / sizeof((a)[0]))

Definition at line 29 of file spi_functions.h.

Referenced by adc_read(), dac_write(), enc_read_pos(), and spi_trans_bytes().

#define ENCODER_EEPROM_RD   0x90

Definition at line 36 of file spi_functions.h.

#define ENCODER_EEPROM_WR   0x80

Definition at line 35 of file spi_functions.h.

#define ENCODER_NO_OP   0x00

Definition at line 32 of file spi_functions.h.

#define ENCODER_RD_POS   0x10

Definition at line 33 of file spi_functions.h.

#define ENCODER_SET_ZERO_PT   0x70

Definition at line 34 of file spi_functions.h.

Function Documentation

int adc_read	(	int	spi_dev,
		uint8_t	ch,
		uint8_t	sgl,
		short int *	data
	)

READ DATA FROM A/D CONVERTER MCP3208.

Parameters

ch	Set Channel (0 .. 7)
sgl	(0: to single or 1: to pseudo-differencial)

Definition at line 172 of file spi_functions.c.

References ARRAY_SIZE, delay, FAILURE, and SUCCESS.

Referenced by read_all_data().

{
        int ret;
        if( ch<0 || ch>7 ) return FAILURE;
        uint8_t tx[] = {(ch>>1)|(sgl<<2)|0x08, ch<<7, 0x00,};
        union rxunion{
          int8_t rxs[ARRAY_SIZE(tx)];
          uint8_t rx[ARRAY_SIZE(tx)];
        }rxunion;
        //rxunion.rx={0, };
        struct spi_ioc_transfer tr = {
                .tx_buf = (unsigned long)tx,
                .rx_buf = (unsigned long)rxunion.rx,
                .len = ARRAY_SIZE(tx),
                .delay_usecs = delay,
                .speed_hz = 0,
                .bits_per_word = 0,
        };

        ret = ioctl(spi_dev, SPI_IOC_MESSAGE(1), &tr);
        if (ret == 1) return FAILURE;
//printf("\nRx = 0x%X 0x%X 0x%X\n",rx[0],rx[1],rx[2]);
//printf("\nValor retornado pelo conversor AD: %d\n\n",rx[2]+((rx[1]&0x0F)<<8));
        //*data=(short int)(rx[2]+((rxs[1]&0x1F)<<8));
        *data=(short int)(rxunion.rx[2]+( (int8_t)( ((int8_t)(rxunion.rxs[1]&0x1F)) <<3)<<5));
        return SUCCESS;
}

Here is the caller graph for this function:

int dac_write	(	int	spi_dev,
		uint8_t	ch,
		uint8_t	_shdn,
		unsigned short int	data
	)

WRITE DATA TO D/A CONVERTER MCP3922.

Definition at line 200 of file spi_functions.c.

References ARRAY_SIZE, delay, FAILURE, and SUCCESS.

Referenced by actuate().

{
        int ret;
        union txunion{
        unsigned short int data16;
        uint8_t data8[2];
        }txunion;
        if( ch<0 || ch>1 ) return FAILURE;//pabort("Wrong channel value for DAC");
        if( data>4095 ) return FAILURE;//pabort("Value exceeded for DAC"); 
        txunion.data16 = 0x6000|(ch<<15)|(_shdn<<12)|(data&0x0FFF);
        uint8_t tx[] = {txunion.data8[1], txunion.data8[0]};
        uint8_t rx[ARRAY_SIZE(tx)] = {0, };
        struct spi_ioc_transfer tr = {
                .tx_buf = (unsigned long)tx,
                .rx_buf = (unsigned long)rx,
                .len = ARRAY_SIZE(tx),
                .delay_usecs = delay,
                .speed_hz = 0,
                .bits_per_word = 0,
        };

        ret = ioctl(spi_dev, SPI_IOC_MESSAGE(1), &tr);
        if (ret == 1) return FAILURE;//pabort("can't send spi message");
//printf("\nRx = 0x%X 0x%X 0x%X\n",rx[0],rx[1],rx[2]);
//printf("\nValor retornado pelo conversor AD: %d\n\n",rx[2]+((rx[1]&0x0F)<<8));
        return SUCCESS;
}

Here is the caller graph for this function:

void spi_end

(

int

spi_dev

)

TERMINATES SPI DEVICE.

Definition at line 166 of file spi_functions.c.

{
  close(spi_dev);
  return;
}

int spi_init	(	uint8_t	mode,
		uint32_t	speed,
		uint8_t	cs
	)

spi Functions to deal communication by SPI protocol

INITIALIZE SPI DEVICE

Definition at line 100 of file spi_functions.c.

References bits, and pabort().

Referenced by devices_init().

{
        int ret = 0;
        int spi_dev;
        char *device;

        //parse_opts(argc, argv);
        /*
         * chose chipselect:
         */
        switch(cs){
          case 0:
            device = "/dev/spidev1.0";
            break;
          case 1:
            device = "/dev/spidev1.1";
            break;
          default:
            return pabort("invalid chip select value");
        }
            
        
        spi_dev = open(device, O_RDWR);
        if (spi_dev < 0)
                return pabort("can't open device");
//printf("\nspi_dev = %d\n",spi_dev);
        /*
         * spi mode
         */
        ret = ioctl(spi_dev, SPI_IOC_WR_MODE, &mode);
        if (ret == -1)
                return pabort("can't set spi mode");

        ret = ioctl(spi_dev, SPI_IOC_RD_MODE, &mode);
        if (ret == -1)
                return pabort("can't get spi mode");

        /*
         * bits per word
         */
        ret = ioctl(spi_dev, SPI_IOC_WR_BITS_PER_WORD, &bits);
        if (ret == -1)
                return pabort("can't set bits per word");

        ret = ioctl(spi_dev, SPI_IOC_RD_BITS_PER_WORD, &bits);
        if (ret == -1)
                return pabort("can't get bits per word");

        /*
         * max speed hz
         */
        ret = ioctl(spi_dev, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
        if (ret == -1)
                return pabort("can't set max speed hz");

        ret = ioctl(spi_dev, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
        if (ret == -1)
                return pabort("can't get max speed hz");

        //printf("spi mode: %d\n", mode);
        //printf("bits per word: %d\n", bits);
        //printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);

        return spi_dev;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int spi_trans_bytes	(	int	spi_dev,
		uint8_t *	send,
		uint8_t *	receive,
		int	n
	)

TRANSFER N BYTES.

Fix this to show all data

Definition at line 228 of file spi_functions.c.

References ARRAY_SIZE, delay, FAILURE, and SUCCESS.

Referenced by enc_read_pos(), enc_wait_for_ack(), and enc_zero_set().

                                                                      {

         //< define send data 
        uint8_t *tx;
        tx = send;
        uint8_t rx[ARRAY_SIZE(tx)] = {0, };
        //rx[0] = 0;
        int i;

        if(ARRAY_SIZE(tx)<n)
                return FAILURE;

        /*
        * Transmitting data (full duplex):
        */
        struct spi_ioc_transfer tr = {
                .tx_buf = (unsigned long)tx,
                .rx_buf = (unsigned long)rx,
                .len = ARRAY_SIZE(tx),
                .delay_usecs = delay,
                .speed_hz = 0,
                .bits_per_word = 0,
        };
        int ret = ioctl(spi_dev, SPI_IOC_MESSAGE(1), &tr);

        //Check transmittion:
        if(ret == 1) return FAILURE;//pabort("can't send spi message");
        for( i=0; i<n; i++)
                receive[i] = rx[i];//get the received data

        return SUCCESS;
}

Here is the caller graph for this function: