Published February 14, 2020

MiniZed Motor Control with I2C Feature

Control MM10 motor using MiniZed's onboard accelerometer

BeginnerFull instructions provided1 hour760

Things used in this project

Hardware components

Avnet MiniZed

Digilent Pmod HB3

MM10 3V DC Motor

Jumper wires (generic)

Software apps and online services

Xilinx Vivado Design Suite HLx Editions

Xilinx - Vitis Unified Software Platform

Story

Intro

This build extends Adam Taylor's project Mini But Mighty, the MiniZed and Vitis for Motor Control. Completing that project is necessary before adding the feature described in this one. After Vivado processing system edits, experienced users can skip to the end for the application source code.

The MiniZed hardware user guide (p31) gives specifications for the MiniZed's onboard accelerometer, the ST Micro LIS2DS12. The accelerometer's datasheet provides details for interfacing with it using SPI or I2C. This build uses I2C to fetch accelerometer readings for controlling the MM10 motor.

Hardware Build: Zynq Configuration

In order to implement an I2C interface for communicating with the LIS2DS12, we must revisit the Vivado IP integrator flow from Adam's project. This is his configuration which we begin from:

Baseline Zynq Configuration from the Motor Control project

The minized.org website provides tutorials for creating SPI and I2C interfaces in the Zynq PS and PL. This build incorporates instructions from the PL I2C tutorial into Adam's Zynq IP configuration. We start by deleting the IIC_0 interface; this build will leverage the AXI IIC IP instead.

Now add an AXI IIC interface from the IP catalog:

Now click "Run Connection Automation" in the IP canvas popup banner, then check "All automation" for mapping the IIC and S_AXI interfaces of the AXI IIC IP.

Regenerate the IP canvas layout using this button:

Our finished I2C motor control block design should appear as follows:

Revised Zynq Configuration for I2C motor control

Hardware Build: Pin Specification & Constraints

The minized.org website provides baseline pin constraints for the MiniZed rev 1 board. We can see from the XDC file that Zynq pins G15 and F15 are mapped to the I2C pins of the ST Micro LIS2DS12TR.

So we must map G15 and F15 to the AXI IIC's block design interface port (code attached). Lines 1-4 were used in Adam's baseline, lines 6-10 specify the IIC ports.

Hardware Build: Final Export

Click Generate Bitstream to re-run the full synthesis, implementation, and bitstream flows.

Once complete, re-export the XSA hardware specification (File>Export). We'll use this in Vitis.

Software Build: Application Project Initialization

Click Tools>Launch Vitis and set a workspace directory. Create a new application project.

As in Adam's project, we must create the hardware platform from our Vivado XSA:

Select the correct domain options:

And begin with the hello world application.

Software Build: Vitis Setup & Another Hello World

Now navigate to BSP Settings

In "standalone, " modify BSP settings:

Ensure stdin and stdout are mapped to uart1:

Back on the board support package page, verify that the IIC driver has been included as a peripheral driver:

Clicking Documentation will bring you to the SDK IIC drivers API documentation. Navigate the dropdown menu to APIs>Functions, then scroll to the index for -X-. We are interested in XIic_Recv() and XIic_Send(). We will return to this later.

Back in Vitis, select both items from the explorer pane. Right click>Build Projects. The console should report "Build Finished"

Software Build: Linux Issue

If running Linux, the build step may fail with an error such as "Program "make" not found in PATH." If so, ensure you have the make package:

sudo apt-get install make and/or sudo apt-get install build-essential

Then create a link with gmake:

sudo ln -s /usr/bin/make /usr/bin/gmake

See this forum thread for reference.

Software Build: Hello World Application Run

With MiniZed connected, open a serial terminal at 115200 baud, e.g.

screen /dev/ttyUSB1 115200

Back in Vitis, right click the application project:

Select "Single Application Debug" and from the Application tab, verify that the Application points to the.elf file in the Debug directory:

Verify in the Target Setup tab that the bitstream and psinit files are sourced from the _ide directory.

Now click Run and observe the Hello World output in the serial terminal session.

Software Build: I2C Project Initial Steps

If hello world was successful, navigate back to the application source code in Vitis:

Revisit the IIC driver API documentation to see the IIC functions we need to implement:

Software Build: I2C Motor Control Application Code

Now return to the Avnet Tutorial 8 documentation. I2C source code is provided in the ZIP package: ./Supporting Documents/I2C/PL_PMOD/MiniZed/main.c

Note the i2c write and read functions:

We can leverage these functions to read & write the LIS2DS12 accelerometer.

Udhay Kumar has also written about using the MiniZed's LIS2DS12. I've made use of his provided code as a baseline for the I2C motor control application.

See attached i2c_mtrctrl.c for the final I2C motor control application code.

Explanations of the code will follow.

App Code: Context

Adam's main and supporting functions begin after line 200. Note display_menu() on line 284: an 8th option is added for running the motor from an accelerometer read. Therefore we add an entry to the motor speed control lookup table in the main() function (see line 266).

App Code: Sensor Init

The main function first calls Udhay's sensor_init() function on line 128. Sensor init sets the IIC device address of the LIS2DS12 to SA0_HI_ADDR. The address for SA0_HI_ADDR is sourced from page 35 of the LIS2DS12 accelerometer datasheet (binary 0001_1101, hex 0x1D).

First, an IIC read is requested at the WHOAMI register address 0x0F (see datasheet p40). IIC data is read into who_am_i, such that who_am_i can be compared with a known, fixed value 0x43 which is provided in datasheet p43. If who_am_i doesn't match 0x43, another read is requested to see if who_am_i instead matches the address SA0_LO_ADDR (datasheet p35).

The init step is completed once who_am_i is matched and the correct LIS2DS12 control registers have been written to. Revisit datasheet p45 to see that control register 2 must be written 0x00 for initialization. Then Table 42 shows operation modes which are set by writing to control register 1. We write 0x60 to select 14-bit operation at 400 Hz. The init step is now complete.

App Code: Reading the Accelerometer

In the while() portion of main(), starting in line 230, accelerometer data is read into acc_din using Udhay's acc_read() function (line 148). acc_read() fetches accelerometer data beginning in line 162. You should experiment with changing the return of this function between directions x, y, z, or an average of them.

Scroll to datasheet p50. Raw accelerometer data must be read in groups of 2 bytes (2 for x, 2 for y, 2 for z). For each direction, the most significant and least significant bytes should be concatenated to form a 16-bit word, expressed in 2's complement. Lines 164, 169, and 173 perform the concatenations.

Lines 175-177 call Udhay's signed_to_int() function (see line 109). If required, the 2's complement conversion is performed. Now recall that we are operating the accelerometer in 14-bit resolution (datasheet 44). The two's complement number is left-aligned in the 16-bit word, therefore we're only interested in bits 15 downto 2. Shift the bits 2 positions to the right and convert to integer.

App Code: Reading the Accelerometer

Back in the main fucntion, I call a scaling function for mapping the returned accelerometer data into a suitable duty cycle (range 0-100). I do this with scale() in line 185.

Software Build: Targeting the MiniZed

Back in Vitis, add the final application code instead of the hello world code. Build the project. Now reconnect to MiniZed with a serial session.

Launch the I2C application on the MiniZed using "Run As" in the same manner as we did for the hello world application run.

You should see the application menu display in the serial terminal:

Hit the 8 key and observe the motor speed.
Tilt the MiniZed and hit the 8 key again to observe the change (Be careful tilting; I would recommend soldering the jumpers to the MM10 motor if possible).
Optional: strap a contact microphone to the motor and do something weird.

Cheers

Code

set_property PACKAGE_PIN M15 [get_ports {TTC0_WAVE0_OUT_0     }];  
set_property PACKAGE_PIN L15 [get_ports {GPIO_O_0     }];  
set_property IOSTANDARD LVCMOS33 [get_ports TTC0_WAVE0_OUT_0]
set_property IOSTANDARD LVCMOS33 [get_ports GPIO_O_0]

set_property PACKAGE_PIN G15 [get_ports iic_rtl_scl_io]
set_property PACKAGE_PIN F15 [get_ports iic_rtl_sda_io]

set_property IOSTANDARD LVCMOS33 [get_ports iic_rtl_scl_io]
set_property IOSTANDARD LVCMOS33 [get_ports iic_rtl_sda_io]

#include <stdio.h>
#include <unistd.h>
#include "platform.h"
#include "xil_printf.h"
#include "xparameters.h"
#include "xiic.h"
#include "xgpiops.h"
#include "xil_exception.h"
#include "xttcps.h" // triple timer counter
#include "xscugic.h" // generic input controller

// LIS2DS12 data sheet pp35
#define SA0_HI_ADDR  		0x1D
#define SA0_LO_ADDR  		0x1E

// LIS2DS12 data sheet pp40
#define CTRL_REG_1_ADDR  	0X20
#define CTRL_REG_2_ADDR  	0X21
#define CTRL_REG_4_ADDR  	0X23
		
#define ACC_STATUS_REG_ADDR 0X27
#define ACC_X_LSB_REG_ADDR  0X28
#define ACC_X_MSB_REG_ADDR  0X29
#define ACC_Y_LSB_REG_ADDR  0X2A
#define ACC_Y_MSB_REG_ADDR  0X2B
#define ACC_Z_LSB_REG_ADDR  0X2C
#define ACC_Z_MSB_REG_ADDR  0X2D

// LIS2DS12 data sheet pp43
#define WHOAMI_ID_REG_ADDR	0X0F
#define WHO_AM_I_FIXED		0x43

// XPAR params from xparameters.h
#define IIC_BASE_ADDR	XPAR_IIC_0_BASEADDR
u8 		IIC_DEV_ADDR = SA0_HI_ADDR; //by default

// defs for mtr ctrl PS input locations
#define GPIO_DEVICE_ID  	XPAR_XGPIOPS_0_DEVICE_ID
#define INTC_DEVICE_ID		XPAR_SCUGIC_0_DEVICE_ID
#define	TICK_TIMER_FREQ_HZ	100
#define TTC_TICK_DEVICE_ID	XPAR_XTTCPS_0_DEVICE_ID
#define TTC_TICK_INTR_ID	XPAR_XTTCPS_0_INTR

int byte_idx;
u8 send_byte;
u8 w_reg_addr [256];

// motor ctrl function setups
static void TickHandler(void *CallBackRef);
int SetupTicker(XTtcPs *TtcPsInst,u16 DeviceID,u16 TtcTickIntrID,XScuGic *InterruptController);
static int SetupInterruptSystem(u16 IntcDeviceID,XScuGic *IntcInstancePtr);
int SetupTimer(u16 DeviceID,XTtcPs *TtcPsInst);
void set_pwm(u32 cycle);
void display_menu();

typedef struct {
u32 OutputHz;	/* Output frequency */
XInterval Interval;	/* Interval value */
u8 Prescaler;	/* Prescaler value */
u16 Options;	/* Option settings */
} TmrCntrSetup;

XIic IicInstance;	// IIC device inst
XGpioPs Gpio;
XGpioPs_Config *ConfigPtr;
XTtcPs_Config *TtcConfig;
XTtcPs ttcTimer;
TmrCntrSetup *TimerSetup;
XScuGic InterruptController;  	/* Interrupt controller instance */
XTtcPs TtcPsInst;
u32 MatchValue;
static TmrCntrSetup SettingsTable={TICK_TIMER_FREQ_HZ, 0, 0, 0};

// -------------------------IIC---------------------------------

int iic_wr(u8 reg_offst, u8 d_wr) {
	int status = XST_SUCCESS;
	u8 tx_buf[2];
	int tx_len = sizeof(tx_buf);
	int ByteCount = 0;

	tx_buf[0]=reg_offst;
	tx_buf[1]=d_wr;

	ByteCount = XIic_Send(IIC_BASE_ADDR, IIC_DEV_ADDR, tx_buf, tx_len, XIIC_STOP);
	if (ByteCount != tx_len) status = XST_FAILURE;

	return (status);
}

int iic_rd(u8 reg_offst, u8 *d_rd){
	int status = XST_SUCCESS;
	u8 tx_buf[1];
	int tx_len = sizeof(tx_buf);
	u8 rx_buf[1];
	int rx_len = sizeof(rx_buf);
	int ByteCount;

	tx_buf[0] = reg_offst;
	ByteCount = XIic_Send(IIC_BASE_ADDR, IIC_DEV_ADDR, tx_buf, tx_len, XIIC_STOP); // send register offst
	if (ByteCount != tx_len) status = XST_FAILURE;

	ByteCount = XIic_Recv(IIC_BASE_ADDR, IIC_DEV_ADDR, rx_buf, rx_len, XIIC_STOP); // receive 1 byte into rx_buf
	if (ByteCount != rx_len) status = XST_FAILURE;
	if (status == XST_SUCCESS) *d_rd = rx_buf[0];
	return(status);
}

int signed_to_int(u16 din)
{
	u16 dout_16b;
	int dout_14b;
	int sign;

	// check if MSB 1000_000
	if (din & 0x8000) {
		sign = -1;
		dout_16b = (~din) + 1; // bit-wise invert, add 1
	} else {
		sign = 1;
		dout_16b = din;
	}

	dout_14b = sign * (int)(dout_16b >> 2); // data is left-aligned; convert 16-bit to 14-bit
	return(dout_14b);
}

void sensor_init (void) {
	u8 who_am_i;
	IIC_DEV_ADDR = SA0_HI_ADDR; //default

	iic_rd(WHOAMI_ID_REG_ADDR, &who_am_i); // reads data pointer into who_am_i
	printf("With I2C device address 0x%02x received WhoAmI = 0x%02x\r\n", IIC_DEV_ADDR, who_am_i);

	if (who_am_i != WHO_AM_I_FIXED) {
		IIC_DEV_ADDR = SA0_LO_ADDR;
		iic_rd(WHOAMI_ID_REG_ADDR, &who_am_i); // try the other address
		printf("With I2C device address 0x%02x received WhoAmI = 0x%02x\r\n", IIC_DEV_ADDR, who_am_i);
	}

	iic_wr(CTRL_REG_2_ADDR, 0x00);
	iic_wr(CTRL_REG_1_ADDR, 0x60); // Turn on the accelerometer.  14-bit mode, ODR = 400 Hz, FS = 2g
	printf("CTL1 = 0x60 written\r\n");
	iic_wr(CTRL_REG_4_ADDR, 0x01); // Acc data-ready interrupt on INT1
	printf("CTL4 = 0x01 written\r\n");
}

int acc_read() {

	u8 acc_status, d_rdy, d_rd_lsb, d_rd_msb;
	u16 x, y, z;
	int i_x, i_y, i_z, avg;

	d_rdy = 0;

	// data not ready
	while (!d_rdy) {
		iic_rd(ACC_STATUS_REG_ADDR, &acc_status);
		d_rdy = acc_status & 0x01; // bit 0 = d_rdy
	}

	iic_rd(ACC_X_LSB_REG_ADDR, &d_rd_lsb); // fetch reading
	iic_rd(ACC_X_MSB_REG_ADDR, &d_rd_msb); // fetch reading
	x = (d_rd_msb << 8) + d_rd_lsb; // shift d_rd_msb to [15:8]; add lsb to [7:0]
	// result is 16-bit signed word

	iic_rd(ACC_Y_LSB_REG_ADDR, &d_rd_lsb);
	iic_rd(ACC_Y_MSB_REG_ADDR, &d_rd_msb);
	y = (d_rd_msb << 8) + d_rd_lsb;

	iic_rd(ACC_Z_LSB_REG_ADDR, &d_rd_lsb);
	iic_rd(ACC_Z_MSB_REG_ADDR, &d_rd_msb);
	z = (d_rd_msb << 8) + d_rd_lsb;

	i_x = signed_to_int(x);
	i_y = signed_to_int(y);
	i_z = signed_to_int(z);

	//avg = (i_x + i_y + i_z)/3;
	return i_x;
	// printf("Avg acceleration (x,y,z) = %+5d\r\n", avg);
	// printf("  Acceleration = X: %+5d, Y: %+5d, Z: %+5d\r\n",i_x, i_y, i_z);
}

int scale (int acc_din){
	int max = 2600;
	int min = -2600;
	int scaled_read = abs(((acc_din - max)*100)/(max-min));
	int acc_dout;
	
	// limiter
	if (scaled_read>100){
		acc_dout = 100;
	} else {
		acc_dout = scaled_read;
	}
	
	return (acc_dout);
}

// -------------------------IIC---------------------------------

int main()
{
sensor_init();
int acc_din;
int avg_scaled;
int dc_adj;

u8 DutyCycle;
char key_input;
init_platform();
TmrCntrSetup SettingsTable= {TICK_TIMER_FREQ_HZ, 0, 0, 0};
	// lookup config
	ConfigPtr = XGpioPs_LookupConfig(GPIO_DEVICE_ID);
	// initialize cfg
	XGpioPs_CfgInitialize(&Gpio, ConfigPtr,ConfigPtr->BaseAddr);
	// directionality
	XGpioPs_SetDirectionPin(&Gpio, 54, 1);
	XGpioPs_SetOutputEnablePin(&Gpio, 54, 1);
	// write constant value
	XGpioPs_WritePin(&Gpio, 54, 0x1);

// serial terminal application output
printf("www.adiuvoengineering.com\n\r");
printf("DC Motor Control Example\n\r");
SetupInterruptSystem(INTC_DEVICE_ID, &InterruptController);
SetupTicker(&ttcTimer,TTC_TICK_DEVICE_ID,TTC_TICK_INTR_ID,&InterruptController);

while(1){
display_menu();
read(1, (char*)&key_input, 1);
printf("Echo %c\n\r",key_input);

// set speed LUT
switch (key_input) {
case '1': //stop
set_pwm(0);
break;
case '2': //25%
printf("25%\n\r");
DutyCycle = 25;
set_pwm(DutyCycle);
break;
case '3': //33%
DutyCycle = 33;
set_pwm(DutyCycle);
break;
case '4': //50%
DutyCycle = 50;
set_pwm(DutyCycle);
break;
case '5': //66%
DutyCycle = 66;
set_pwm(DutyCycle);
break;
case '6': //75%
DutyCycle = 75;
set_pwm(DutyCycle);
break;
case '7': //100%
DutyCycle = 100;
set_pwm(DutyCycle);
break;

case '8': //100%
acc_din = acc_read();
DutyCycle = scale(acc_din);
set_pwm(DutyCycle);
sleep(1);
break;

}
}
cleanup_platform();
return 0;
}

void display_menu()
{
//Clear the screen
printf("\033[2J");
//Display the main menu
printf("*******************************************\n");
printf("****      www.adiuvoengineering.com    ****\n");
printf("****      Motor Control Example        ****\n");
printf("*******************************************\n");
printf("\n");
printf("   MM10 Motor Control   \n");
printf("------------------------------------------\n");
printf("\n");
printf("Select a Speed:\n");
printf("  (1)   - Stop\n");
printf("  (2)   - 25%\n");
printf("  (3)   - 33%\n");
printf("  (4)   - 50%\n");
printf("  (5)   - 66%\n");
printf("  (6)   - 75%\n");
printf("  (7)   - 100%\n");
printf("  (8)   - accelerometer\n");
printf("\n");
}


// set speed function
void set_pwm(u32 cycle)
{
u32 MatchValue;
MatchValue = (TimerSetup->Interval * cycle) / 100;
XTtcPs_SetMatchValue(&ttcTimer, 0, MatchValue);
}


// setup timer
int SetupTicker(XTtcPs *TtcPsInst,u16 DeviceID,u16 TtcTickIntrID,XScuGic *InterruptController)
{
int Status;
TmrCntrSetup *TimerSetup;
XTtcPs *TtcPsTick;
TimerSetup = &SettingsTable;
TimerSetup->Options |= (XTTCPS_OPTION_INTERVAL_MODE |
XTTCPS_OPTION_MATCH_MODE | XTTCPS_OPTION_WAVE_POLARITY);
Status = SetupTimer(DeviceID,TtcPsInst);
if(Status != XST_SUCCESS) {
return Status;
}
TtcPsTick = TtcPsInst;
Status = XScuGic_Connect(InterruptController, TtcTickIntrID,
(Xil_InterruptHandler)TickHandler, (void *)TtcPsTick);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
XScuGic_Enable(InterruptController, TtcTickIntrID);
XTtcPs_EnableInterrupts(TtcPsTick, XTTCPS_IXR_INTERVAL_MASK);
XTtcPs_Start(TtcPsTick);
return Status;
}


// interrupt ctrlr; connect ttc to controller
static int SetupInterruptSystem(u16 IntcDeviceID,XScuGic *IntcInstancePtr)
{
int Status;
XScuGic_Config *IntcConfig;
IntcConfig = XScuGic_LookupConfig(IntcDeviceID);
if (NULL == IntcConfig) {
return XST_FAILURE;
}
Status = XScuGic_CfgInitialize(IntcInstancePtr, IntcConfig,
IntcConfig->CpuBaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_IRQ_INT,
(Xil_ExceptionHandler) XScuGic_InterruptHandler,
IntcInstancePtr);
Xil_ExceptionEnable();
return XST_SUCCESS;
}

// zynq interrupt timer
int SetupTimer(u16 DeviceID,XTtcPs *TtcPsInst)
{
int Status;
XTtcPs_Config *Config;
XTtcPs *Timer;
TmrCntrSetup *TimerSetup;
TimerSetup = &SettingsTable;
Timer = TtcPsInst;
Config = XTtcPs_LookupConfig(DeviceID);
if (NULL == Config) {
return XST_FAILURE;
}
Status = XTtcPs_CfgInitialize(Timer, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
XTtcPs_SetOptions(Timer, TimerSetup->Options);
XTtcPs_CalcIntervalFromFreq(Timer, TimerSetup->OutputHz,
&(TimerSetup->Interval), &(TimerSetup->Prescaler));
XTtcPs_SetInterval(Timer, TimerSetup->Interval);
XTtcPs_SetPrescaler(Timer, TimerSetup->Prescaler);
return XST_SUCCESS;
}

// for interrupts
static void TickHandler(void *CallBackRef)
{
u32 StatusEvent;
/*
* Read the interrupt status, then write it back to clear the interrupt.
*/
StatusEvent = XTtcPs_GetInterruptStatus((XTtcPs *)CallBackRef);
XTtcPs_ClearInterruptStatus((XTtcPs *)CallBackRef, StatusEvent);
//printf("timer\n\r");
/*update the flag if interrupt has been occurred*/
//UpdateFlag = TRUE;
}

Credits

J. Abate

1 project • 1 follower

Thanks to Avnet and Udhay Kumar.

MiniZed Motor Control with I2C Feature

Things used in this project

Hardware components

Software apps and online services

Story

Intro

Hardware Build: Zynq Configuration

Hardware Build: Pin Specification & Constraints

Hardware Build: Final Export

Software Build: Application Project Initialization

Software Build: Vitis Setup & Another Hello World

Software Build: Linux Issue

Software Build: Hello World Application Run

Software Build: I2C Project Initial Steps

Software Build: I2C Motor Control Application Code

App Code: Context

App Code: Sensor Init

App Code: Reading the Accelerometer

App Code: Reading the Accelerometer

Software Build: Targeting the MiniZed

Schematics

I2C Motor Control Processor System Configuration

Code

mz_i2c_mtrctrl.xdc

i2c_mtrctrl.c

Credits

J. Abate

Comments

Our Partners

Help

Customer Info

Company Info

Embed the widget on your own site

MiniZed Motor Control with I2C Feature

MiniZed Motor Control with I2C Feature

Things used in this project

Hardware components

Software apps and online services

Story

Intro

Hardware Build: Zynq Configuration

Hardware Build: Pin Specification & Constraints

Hardware Build: Final Export

Software Build: Application Project Initialization

Software Build: Vitis Setup & Another Hello World

Software Build: Linux Issue

Software Build: Hello World Application Run

Software Build: I2C Project Initial Steps

Software Build: I2C Motor Control Application Code

App Code: Context

App Code: Sensor Init

App Code: Reading the Accelerometer

App Code: Reading the Accelerometer

Software Build: Targeting the MiniZed

Schematics

I2C Motor Control Processor System Configuration

Code

mz_i2c_mtrctrl.xdc

i2c_mtrctrl.c

Credits

J. Abate

Comments

Related tags

Our Partners

Help

Customer Info

Company Info

Connect With Us