sliceKIT Development Board Tutorial

The Target should be shown as XMOS XTAG-2 connected to L1[0..1].

Run Configuration

xTIMEcomposer uses JTAG to load the application directly into the internal SRAM in the xCORE multicore microcontroller. The SRAM is a fast, single cycle memory and does not include caches, which makes all memory accesses deterministic.

Loading directly into SRAM is used during development, as it provides the fastest mechanism for loading code into the device. In production, xCORE devices usually boot from SPI flash. xTIMEcomposer includes a flash programming utility that can be used by creating a Flash Configuration in the same way as a Run Configuration - see Run > Flash.

void wait(unsigned wait_cycles) {
  timer tmr;
  unsigned t;

  // read the current time
  tmr :> t;
  // event will occur wait_cycles * 10ns in the future
  tmr when timerafter (t+wait_cycles) :> void;
}

Show where the wait code goes

The function uses a timer to emit an event at some time in the future. Timers use the 100MHz reference clock to provide programmable delays to the software. The 100MHz clock gives 10ns resolution to these delays, allowing the software to precisely control the time at which actions occur. The logical core remains idle until that event happens, thereby saving power.

void pwm_controller(chanend c_pwm)
{
  // PWM period is 10us. 1000 cycles at 10ns (100MHz ref clock)
  int period = 1000;
  // duty_cycle starts at 100% which switches all LEDs off
  // (LEDs active low on GPIO sliceCARD)
  int duty_cycle = 1000;
  // duty cycle step (up or down)
  unsigned step = period / 100;
  // duty_cycle delta.
  int delta = -step; // start with increasing brightness

  // output the PWM period length to a channel
  c_pwm <: period;
  // output the PWM duty cycle length to a channel
  c_pwm <: duty_cycle;

  while(1) {
    // update the duty cycle length
    c_pwm <: duty_cycle;

    wait(XS1_TIMER_HZ/100); // 0.01 s
    duty_cycle += delta;
    if(duty_cycle > period) {
      delta = -step; // increase brightness
      duty_cycle = period;
    }
    else if(duty_cycle < 0) {
      delta = step; // decrease brightness
      duty_cycle = 0;
    }
  }
}

Show where the pwm_controller code goes

The new pwm_controller updates the PWM logical core, by periodically sending new PWM settings to it over the channel. There is a delay of 10ms between each update to the PWM core. The step between every successive duty cycle is 1/100 of a PWM period which means the time to go from 0 to 100% duty (LED fully on to LED fully off) is 100 * 10ms = 1 second.

The four LEDs are dimmed up and down every 2 seconds.

#include "print.h"

int delta = -step; // start with increasing brightness

printstr("Welcome to the XMOS PWM tutorial");

// output the PWM period length to a channel
c_pwm <: period;

Show where the printstr code goes

The print library includes functions for printing various different formats, including strings and integers.

Your welcome message is printed to the xTIMEcomposer Console.

xTIMEcomposer Console

As you are adding a module to an existing project, you need to add the module to the Makefile.

Your USED_MODULES will now be:

USED_MODULES = module_i2c_master module_pwm_tutorial_example

module_i2c_master is displayed in the project tree.

#include "i2c.h"

on tile[1] : struct r_i2c i2cOne = {
  XS1_PORT_1F,
  XS1_PORT_1B,
  1000
};

Show where the port code goes

This declares a structure with two 1-bit ports which are the SCL and SCK pins for I2C. The third member of the structure is the speed of the bus. The I2C Programming Guide gives this description of the structure:

Structure Members

port scl - Port on which clock wire is attached. Must be on bit 0

port sda - Port on which data wire is attached. Must be on bit 0

unsigned int ``clockTicks`` - Number of reference clocks per I2C clock, set to 1000 for 100 kHz.

The location of the I2C ports can be found in the GPIO sliceCARD documentation.

The Editor window jumps to the tx8 function that implements the I2C protocol for writing a single byte.

The HighPulse() function sends each bit of the byte in a loop. The timing of the edges of the I2C SCL (clock) and I2C SDA (data) signals are controlled by the function waitQuarter which, like the wait function you implemented previously, uses a timer to emit an event in the future upon which the signal level is changed.

// I2C write data
  unsigned char wr_data[1]={0x13};
  unsigned char rd_data[2];
  int adc_value;

  //Write configuration information to ADC
  i2c_master_write_reg(0x28, 0x00, wr_data, 1, i2cOne);

  printstr("Welcome to the XMOS PWM tutorial\n");

Show where the i2c_master_write_reg function goes

if (duty_cycle > period)
{
  //Read ADC value using I2C read

  rd_data[0]=rd_data[0]&0x0F;
  i2c_master_rx(0x28, rd_data, 2, i2cOne);
  rd_data[0]=rd_data[0]&0x0F;
  adc_value=(rd_data[0]<<6)|(rd_data[1]>>2);
  printstr("Temperature is :");
  printintln(linear_interpolation(adc_value));

Show where the i2c_master_rx code goes

int TEMPERATURE_LUT[][2]= //Temperature Look up table
{
  {-10,845},{-5,808},{0,765},{5,718},{10,668},
  {15,614},{20,559},{25,504},{30,450},{35,399},
  {40,352},{45,308},{50,269},{55,233},{60,202}
};

int linear_interpolation(int adc_value)
{
  int i=0,x1,y1,x2,y2,temper;
  while(adc_value<TEMPERATURE_LUT[i][1])
  {
    i++;
  }
  // Calculating Linear interpolation using the formula
  // y=y1+(x-x1)*(y2-y1)/(x2-x1)
  x1=TEMPERATURE_LUT[i-1][1];
  y1=TEMPERATURE_LUT[i-1][0];
  x2=TEMPERATURE_LUT[i][1];
  y2=TEMPERATURE_LUT[i][0];
  temper=y1+(((adc_value-x1)*(y2-y1))/(x2-x1));

  return temper;
}

Show where the interpolation function goes

Every two seconds the temperature is printed to your console. Check that the temperature is printed to your console.

Output temperature reading