Electrical – Atmel AVR XMEGA-A USART MPCM (Multiprocessor communication mode) configuration with ASF 3.33

atmelavruartxmega

I'm using two XMEGA256-A3BU's on XMEGA-A3BU Xplained boards. My goal is to make MPCM (Multiprocessor communication mode) possible between the two using their USART in synchronous mode.
They are physically connected so that the master's PC1 (SCL), PC2 (RXD) and PC3 (TXD) are connected to the slave's PC1 (SCL), PC3 (TXD) and PC2 (RXD) respectively.
I use ASF 3.33's "USART – serial service" to make the communication work.

Master's initialization code:

static usart_serial_options_t usart_options = {
    .baudrate = 1200;
    .charlength = USART_CHSIZE_8BIT_gc,
    .paritytype = USART_PMODE_ODD_gc,
    .stopbits = false
};

sysclk_enable_module(SYSCLK_PORT_C, PR_USART0_bm);
usart_serial_init(&USARTC0, &usart_options);

usart_set_mode(&USARTC0, USART_CMODE_SYNCHRONOUS_gc);

// Pin to set as output for clock signal.
ioport_configure_pin(IOPORT_CREATE_PIN(PORTC, 1), IOPORT_DIR_OUTPUT);
// Port to output clock signal on.
PORTCFG.CLKEVOUT = PORTCFG_CLKOUT_PC1_gc;

usart_set_rx_interrupt_level(&USARTC0, USART_RXCINTLVL_OFF_gc);
usart_set_tx_interrupt_level(&USARTC0, USART_TXCINTLVL_OFF_gc);

Slave's initialization code:

static usart_serial_options_t usart_options = {
    .baudrate = 1200;
    .charlength = USART_CHSIZE_8BIT_gc,
    .paritytype = USART_PMODE_ODD_gc,
    .stopbits = false
};

sysclk_enable_module(SYSCLK_PORT_C, PR_USART0_bm);
usart_serial_init(&USARTC0, &usart_options);

usart_set_mode(&USARTC0, USART_CMODE_SYNCHRONOUS_gc);

// Pin to set as input for clock signal.
ioport_configure_pin(IOPORT_CREATE_PIN(PORTC, 1), IOPORT_DIR_INPUT);
// Do not output the clock signal.
PORTCFG.CLKEVOUT = PORTCFG_CLKOUT_OFF_gc;

usart_set_rx_interrupt_level(&USARTC0, USART_RXCINTLVL_OFF_gc);
usart_set_tx_interrupt_level(&USARTC0, USART_TXCINTLVL_OFF_gc);

I use usart_serial_putchar(&USARTC0, buffer[i]) and usart_serial_getchar(&USARTC0, &buffer[i]) to send and receive data for testing, the final design will use DMA.

In order to make MPCM work (and make it possible to add more slaves to the bus), I know that I need to switch to the 1 start bit + 9 data bits + parity + 1 stop bit format, and I also know that somehow I should use these constants I found in iox256a3bu.h file:

#define USART_MPCM_bm  0x02  /* Multi-processor Communication Mode bit mask. */
#define USART_MPCM_bp  1  /* Multi-processor Communication Mode bit position. */

Could someone help me out with some ASF sample code? What should I add to set the slave's own address, and where should I define on the master who I'm intending to send the message to?

Best Answer

I've spent a few hours on the problem, and fortunately it works now with one master and two slaves. It doesn't use DMA because I think it is impractical in this case, so I decided to use interrupts instead.
First I changed the USART's format to 9 bits, so the initialization method starts like this:

static usart_serial_options_t usart_options = {
    .baudrate = 1200;
    .charlength = USART_CHSIZE_9BIT_gc,
    .paritytype = USART_PMODE_ODD_gc,
    .stopbits = false
};

And I changed the interrupt level at its end:

usart_set_rx_interrupt_level(USART_SERIAL, USART_RXCINTLVL_OFF_gc);
usart_set_tx_interrupt_level(USART_SERIAL, USART_TXCINTLVL_MED_gc);

Then I defined two methods to replace the usart_serial_putchar(&USARTC0, buffer[i]) and usart_serial_getchar(&USARTC0, &buffer[i]) methods:

static void usart_send_mpcm_data(usart_if usart, uint8_t data, bool is_address)
{
    /* Wait until we are ready to send the next 9 bits */
    while (usart_data_register_is_empty(usart) == false) {}

    /* First we need to set the 9. bit of the frame, which is the indicator for the address frame */
    if (is_address)
    {
        (usart)->CTRLB |= USART_TXB8_bm;
    } else
    {
        (usart)->CTRLB &= ~USART_TXB8_bm;
    }

    /* Second, let's load the 8-bit data into the DATA register of the USART */
    (usart)->DATA = data;
}


static bool usart_receive_mpcm_data(usart_if usart, uint8_t* data, uint8_t my_address)
{
    bool result = false;

    /* Are we in MPCM mode? */
    bool MPCM_mode = usart->CTRLB & USART_MPCM_bm;
    /* Is this an address frame? */
    bool address_frame = usart->STATUS & USART_RXB8_bm;

    /* Read char, clearing RXCIF */
    uint8_t read_data = usart->DATA;

    if ((!MPCM_mode) && (!address_frame))
    {
        /* This is a data frame, and we are interested in it */
        *data = read_data;
        result = true;
    }

    if (address_frame)
    {
        /* This frame is an address frame, so let's check if it addresses us (my_address) or broadcasts (0) */
        MPCM_mode = !((read_data == my_address) || (read_data == 0));
    }

    /* Set the MPCM bit in the USART's control register */
    if (MPCM_mode)
    {
        usart->CTRLB |= USART_MPCM_bm;
    } else
    {
        usart->CTRLB &= ~USART_MPCM_bm;
    }

    /* Return true if we read some useful data */
    return result;
}

After having these, I could setup the interrupt method on the slaves:

// USART-C Reception Complete Interrupt
ISR(USARTC0_RXC_vect)
{
    if (usart_receive_mpcm_data(&USARTC0, &usart_destination[usart_interrupt_counter], settings.device_index))
    {
        usart_interrupt_counter = (usart_interrupt_counter+1) % DMA_BUFFER_SIZE;
        rx_counter += 1;    
    }
}

On the master I can use the usart_send_mpcm_data(&USARTC0, usart_source[i], false); method to send data, or usart_send_mpcm_data(&USARTC0, slave_address, true); to change the target slave address. If the address is 0, then that's going to be a broadcast message, so all slaves will receive the data.

Related Solutions

USART communication with PIC16F688

You are enabling the "GO" bit, which performs one conversion of the ADC.

Once that conversion is complete the "GO" bit is turned off and the ADC does nothing else until the "GO" bit is turned on again.

You should have something more like this:

while (1)
{
    ADCON0.1=1;
    while(ADCON0.1==1);
    byte=ADRESH;
    TXREG=byte;
}

Or, a better format (compiler dependent):

while (1)
{
    ADCON0bits.GO=1;
    while(ADCON0bits.GO==1);
    byte=ADRESH;
    TXREG=byte;
}

And even better - check to see if it has changed and only send if it has:

unsigned char byte,old;

... setup code ...

while (1)
{
    ADCON0bits.GO=1;
    while(ADCON0bits.GO==1);
    byte=ADRESH;
    if(byte!=old)
    {
        old=byte;
        TXREG=byte;
    }
}

And you should really check to see if the transmit buffer is ready to receive a new byte:

unsigned char byte,old;

... setup code ...

while (1)
{
    ADCON0bits.GO=1;
    while(ADCON0bits.GO==1);
    byte=ADRESH;
    if(byte!=old)
    {
        old=byte;
        while(TCSTAbits.TRMT==0);
        TXREG=byte;
    }
}

Of course, I have just knocked this code together in the browser here, so I haven't tested it, but it should give you the idea.

Electronic – Using AVR Dragon with Atmel Studio 6

I recently installed Atmel Studio 6 and upgraded a project that had to be manualy recreated so I thought I'd document the process including use of an AVR Dragon. The first step was to create a new project and as my code was C++ I selected GCC C++ Executable Project:

Project creation

The next step is device selection, a search facility is provided that saves sifting through the entire list of devices:

Device selection

The next step required for most projects is to define the CPU frequency. I went into Project | Properties and went to the symbols tab for the compiler I'm using, in this case C++. There I defined F_CPU by pressing the add button and typing F_CPU=11059200 to suit the crysyal I'm using. Once done the screen looks as follows (note that I corrected the value after taking the screenshot, it was missing a zero):

Setting the F_CPU clock speed

In the same area you can go down to the tool tab and define the type of debugger / programmer and the interface. In my case I was using the JTAG interface, different options will appear if using ISP but the defaults are normally OK.

Selecting the debugger / programmer

Once that's been saved you can click on the device programming icon on the toolbar or press Ctrl + Shift + P to get to the device programming screen.

Device programming toolbar

Once you've confirmed the correct tool, device and interface is selected you can press the apply button to connect. It's likely the AVR Dragon will require a firmware update to work so press the upgrade button if prompted to do so and wait for the upgrade to complete.

Device programming screen

Once connected you'll be able to read the device signature and target voltage to confirm the connection to the target is OK. You can also program the various memories, lockbits and lock bits from the same screen.

Device programming

However once your configuration bits are have been set you may find it more convenient to use the start without debugging button on the toolbar to launch the project. That will automatically build the project if required, program the device and start the program.

Start without debugging