communication.c File Reference

Communication Routines. More...

#include <stdio.h>
#include "communication.h"

Include dependency graph for communication.c:

Go to the source code of this file.

Functions
int	devices_init (IMU_PARAM_STRUCT *imu_param, SPI_PARAM_STRUCT *spi_param, MRA_DATA_STRUCT *mra_data)
	INITIALIZATION OF SENSORS AND DEVICES. More...
int	devices_close (IMU_PARAM_STRUCT *imu_param, SPI_PARAM_STRUCT *spi_param, MRA_DATA_STRUCT *mra_data)
	Fuction to close all communication with the sensors and devices. More...
int	read_all_data (int i2c_dev, int spi_dev, IMU_DATA_STRUCT *imu_data, EFF_DATA_STRUCT *eff_data, MRA_DATA_STRUCT *mra_data, ENC_DATA_STRUCT *enc_data)
	READ ALL DATA FROM SENSORS AND ADC. More...
void	actuate (int spi_dev, MRA_DATA_STRUCT *mra_data)
	Applies the control signal to the actuator. More...
void	dac_shut_down (void)

Variables
int	status

Detailed Description

Communication Routines.

Definition in file communication.c.

Function Documentation

void actuate	(	int	spi_dev,
		MRA_DATA_STRUCT *	mra_data
	)

Applies the control signal to the actuator.

Parameters

spi_dev	Containing SPI variable ID
mra_data	Struct containing the control signal

Returns

nothing

Definition at line 179 of file communication.c.

References dac_write(), FAILURE, GPIO_CS_S0, GPIO_CS_S1, GPIO_CS_S2, GPIO_CS_S3, GPIO_DAC_SHDN, gpio_write(), MRA_DATA_STRUCT::new_ctl, SUCCESS, and MRA_DATA_STRUCT::v_ctl.

Referenced by control_task(), devices_close(), devices_init(), and periodic_task_1().

{
  //printf("i = %d\n",i);
  //i++;
  if( gpio_write(GPIO_DAC_SHDN,1)==FAILURE )
        mra_data->new_ctl=FAILURE; else
  if( (gpio_write(GPIO_CS_S3,1)==FAILURE) || (gpio_write(GPIO_CS_S2,0)==FAILURE) || (gpio_write(GPIO_CS_S1,1)==FAILURE) || (gpio_write(GPIO_CS_S0,0)==FAILURE) )
        mra_data->new_ctl=FAILURE;
  else if( (dac_write(spi_dev,0,1,mra_data->v_ctl))==FAILURE )
        mra_data->new_ctl=FAILURE;
//  else if( (dac_write(spi_dev,1,1,mra_data->???))==FAILURE )
//      mra_data->success=FAILURE;
  else mra_data->new_ctl=SUCCESS;
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void dac_shut_down

(

void

)

Definition at line 195 of file communication.c.

References GPIO_DAC_SHDN, gpio_read(), and gpio_write().

{
  while( (gpio_read(GPIO_DAC_SHDN))==0 )
    gpio_write(GPIO_DAC_SHDN,0);
  return;
}

Here is the call graph for this function:

int devices_close	(	IMU_PARAM_STRUCT *	imu_param,
		SPI_PARAM_STRUCT *	spi_param,
		MRA_DATA_STRUCT *	mra_data
	)

Fuction to close all communication with the sensors and devices.

[long description]

Todo:

Complete and test this function

Parameters

imu_param	[description]
spi_param	[description]
mra_data	[description]

Returns

[description]

Definition at line 82 of file communication.c.

References actuate(), IMU_PARAM_STRUCT::i2c_dev, SPI_PARAM_STRUCT::spi_dev, SUCCESS, and MRA_DATA_STRUCT::v_ctl.

Referenced by main().

{
  //Writing 0 and Disable DAC
  mra_data->v_ctl=0;
  actuate(spi_param->spi_dev, mra_data);

  close(imu_param->i2c_dev);
  close(spi_param->spi_dev);

  return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int devices_init	(	IMU_PARAM_STRUCT *	imu_param,
		SPI_PARAM_STRUCT *	spi_param,
		MRA_DATA_STRUCT *	mra_data
	)

INITIALIZATION OF SENSORS AND DEVICES.

Parameters

*imu_param	Structure with IMU parameters
*spi_param	Structure with SPI parameters
*mra_data	Structure to control MRA

Returns

flag with SUCCESS or FAILURE

Definition at line 12 of file communication.c.

References IMU_PARAM_STRUCT::acc, acc_init(), IMU_PARAM_STRUCT::param_gyr::act, actuate(), ADD_ADXL345, ADD_HMC5883, ADD_ITG3200, IMU_PARAM_STRUCT::param_gyr::clk_source, SPI_PARAM_STRUCT::cs, FAILURE, IMU_PARAM_STRUCT::param_acc::full_res, IMU_PARAM_STRUCT::gyr, gyr_init(), IMU_PARAM_STRUCT::i2c_dev, IMU_PARAM_STRUCT::param_gyr::lpf_bw, IMU_PARAM_STRUCT::mag, mag_init(), IMU_PARAM_STRUCT::param_mag::meas_mode, SPI_PARAM_STRUCT::mode, MRA_DATA_STRUCT::new_ctl, IMU_PARAM_STRUCT::param_mag::op_mode, IMU_PARAM_STRUCT::param_acc::range, IMU_PARAM_STRUCT::param_mag::range, IMU_PARAM_STRUCT::param_acc::rate, IMU_PARAM_STRUCT::param_gyr::rate, IMU_PARAM_STRUCT::param_mag::rate, IMU_PARAM_STRUCT::param_mag::samples_avg, SPI_PARAM_STRUCT::speed, SPI_PARAM_STRUCT::spi_dev, spi_init(), SUCCESS, and MRA_DATA_STRUCT::v_ctl.

Referenced by main(), and periodic_task_2().

{
#if USE_IMU

  if( (imu_param->i2c_dev = open("/dev/i2c-3", O_RDWR))<0 )
  {
    perror("Failed to open i2c_dev");
    return FAILURE;
  }

  if ((ioctl(imu_param->i2c_dev, I2C_SLAVE, ADD_HMC5883)) < 0) {
                perror("ioctl(I2C_SLAVE) mag");
                return FAILURE;
  }

  if( (mag_init(imu_param->i2c_dev, imu_param->mag.rate, imu_param->mag.range, imu_param->mag.samples_avg, imu_param->mag.meas_mode, imu_param->mag.op_mode))< 0)
  {
      perror("Error in magnetometer initialization");
      return FAILURE;
      }

  if( ioctl(imu_param->i2c_dev, I2C_SLAVE, ADD_ITG3200) < 0) {
                perror("ioctl(I2C_SLAVE) gyr");
                return FAILURE;
  } 

  if( gyr_init(imu_param->i2c_dev, imu_param->gyr.rate, imu_param->gyr.lpf_bw, imu_param->gyr.clk_source, imu_param->gyr.act)<0 )
  {
      perror("Error in gyrometer initialization");
      //return FAILURE;
  }

  if ( (ioctl(imu_param->i2c_dev, I2C_SLAVE, ADD_ADXL345)) < 0) {
        perror("ioctl(I2C_SLAVE) acc");
        return FAILURE;
  }  

  if( acc_init(imu_param->i2c_dev, imu_param->acc.full_res, imu_param->acc.rate, imu_param->acc.range)<0)
  {
        perror("Error in accelerometer initialization");
        return FAILURE;
  }

#endif

  if ((spi_param->spi_dev=spi_init(spi_param->mode,spi_param->speed,spi_param->cs))<0) 
  {
    perror("Error in SPI device initialization");
    return FAILURE;
  }

  //Enable DAC and writing 0
  mra_data->v_ctl=0;
//  mra_data->Out_1=0;gpio_write(GPIO_CS_S3,1)==FAILURE

  actuate(spi_param->spi_dev, mra_data);
  if( mra_data->new_ctl == FAILURE )
  {
        perror("Error in MRA initialization");
        return FAILURE;
  }
 // if( gpio_write(GPIO_DAC_SHDN,1)==FAILURE )
 // {
//      perror("Error in SHDN initialization");
//      return FAILURE;
//  }
  
  return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int read_all_data	(	int	i2c_dev,
		int	spi_dev,
		IMU_DATA_STRUCT *	imu_data,
		EFF_DATA_STRUCT *	eff_data,
		MRA_DATA_STRUCT *	mra_data,
		ENC_DATA_STRUCT *	enc_data
	)

READ ALL DATA FROM SENSORS AND ADC.

Parameters

i2c_dev
spi_dev
*imu_data
*eff_data
*mra_data

Returns

flag with SUCCESS or FAILURE

Definition at line 94 of file communication.c.

References IMU_DATA_STRUCT::acc, acc_read_all_data(), adc_read(), ADD_ADXL345, ADD_HMC5883, ADD_ITG3200, ENC_DATA_STRUCT::calib, enc_read_pos(), EFF_DATA_STRUCT::F, FAILURE, GPIO_CS_S0, GPIO_CS_S1, GPIO_CS_S2, GPIO_CS_S3, gpio_write(), IMU_DATA_STRUCT::gyr, gyr_read_all_data(), IMU_DATA_STRUCT::mag, mag_read_all_data(), ENC_DATA_STRUCT::new_data, IMU_DATA_STRUCT::new_data, EFF_DATA_STRUCT::new_data, MRA_DATA_STRUCT::new_data, ENC_DATA_STRUCT::position, ENC_DATA_STRUCT::calibrate::position, ENC_DATA_STRUCT::spi_dev, SUCCESS, IMU_DATA_STRUCT::temp, MRA_DATA_STRUCT::v_ctl_read, DATA_XYZ::x, DATA_XYZ::y, and DATA_XYZ::z.

Referenced by control_task(), periodic_task_1(), and ui_task().

{
  short int data[4];
  int f=0;
  // Read IMU data
  imu_data->new_data=SUCCESS;
#if USE_IMU
  if ( (ioctl(i2c_dev, I2C_SLAVE, ADD_ADXL345))<0) 
        imu_data->new_data=0;
  else if( (acc_read_all_data(i2c_dev,data))==FAILURE )
  {
        imu_data->new_data=0;
        //printf("\nimu_data->new_data = %d\n",imu_data->new_data);
        //f=1;
  }
  else{
    imu_data->acc.x=data[0];
    imu_data->acc.y=data[1];
    imu_data->acc.z=data[2];  
  }
  
  if ( (ioctl(i2c_dev, I2C_SLAVE, ADD_ITG3200)) < 0) 
        imu_data->new_data=0;
  else if( (gyr_read_all_data(i2c_dev,data))==FAILURE )
        imu_data->new_data=0;
  else{
    imu_data->gyr.x=data[0];
    imu_data->gyr.y=data[1];
    imu_data->gyr.z=data[2];
    imu_data->temp=data[3];
  }
  
  if ( (ioctl(i2c_dev, I2C_SLAVE, ADD_HMC5883)) < 0) 
        imu_data->new_data=0;
  else if( (mag_read_all_data(i2c_dev,data))==FAILURE )
        imu_data->new_data=0;
  else{
    imu_data->mag.x=data[0];
    imu_data->mag.y=data[1];
    imu_data->mag.z=data[2];
  }
#endif
  //Read Efforts data
  eff_data->new_data=SUCCESS;
  
  if( (gpio_write(GPIO_CS_S3,1)==FAILURE) || (gpio_write(GPIO_CS_S2,1)==FAILURE) || (gpio_write(GPIO_CS_S1,1)==FAILURE) || (gpio_write(GPIO_CS_S0,0)==FAILURE))
        eff_data->new_data=FAILURE;
  else{ 
    if( (adc_read(spi_dev,0,1,data))==FAILURE )
        eff_data->new_data=FAILURE;
    else eff_data->F.x=data[0];
  //Read MR actuator voltage control
    if( (adc_read(spi_dev,7,1,data))==SUCCESS )
    {
            mra_data->v_ctl_read=data[0];
      mra_data->new_data=SUCCESS;
    }
  }
  //if( f==1 )
    //printf("imu_data->new_data antes do return= %d\n",imu_data->new_data);

  //Read Encoder data
  enc_data->new_data = SUCCESS;
#if USE_ENCODER
  enc_data->spi_dev = spi_dev;
  if( (gpio_write(GPIO_CS_S3,1)==FAILURE) || (gpio_write(GPIO_CS_S2,1)==FAILURE) || (gpio_write(GPIO_CS_S1,1)==FAILURE) || (gpio_write(GPIO_CS_S0,1)==FAILURE))
        enc_data->new_data=FAILURE;
  if(enc_read_pos(enc_data->spi_dev,&(enc_data->position))==FAILURE)
    enc_data->new_data = FAILURE;
    enc_data->calib.position = ((4096 - enc_data->position)/11.37778);
#endif

  if( imu_data->new_data==FAILURE || eff_data->new_data==FAILURE || mra_data->new_data==FAILURE || enc_data->new_data == FAILURE)
    return FAILURE;
    
  return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

int status

Definition at line 10 of file communication.c.

Referenced by gDataLogger_Init(), main(), threads_linux_init(), threads_linux_timer_function_task_1(), threads_linux_timer_function_task_2(), timer_function_task(), timer_function_task_1(), and timer_function_task_2().