Intermediate
30 min

Upgrade your power needs with triple step-down conversion based on TPS65263 and ATmega328P

Buck it right, save power

3xBuck click with Arduino UNO Rev3

Published Feb 14, 2024

Click board™

3xBuck click

Dev. board

Arduino UNO Rev3

Compiler

NECTO Studio

MCU

ATmega328P

Offering voltage control at your fingertips, this cutting-edge solution empowers your gadgets to perform at their best

A

A

Hardware Overview

How does it work?

3xBuck Click is based on the TPS65263, a triple synchronous step-down converter from Texas Instruments with programmable dynamic voltage scaling. This IC contains three independent switching sections, which operate at a fixed frequency of 600kHz. One buck section uses the switching clock, which is 180˚ out-of-phase, with respect to the other two sections. This ensures low input current ripple, as well as the lowered EMI of the power supply itself. The TPS65263 IC has the I2C bus logic section, which allows the output voltage of each converter to be programmed. The output voltage is initially set with feedback voltage divider resistors on each section. The output voltages of the sections are set to 5V, 3.3V, and 1.8V because these values are the most commonly used in embedded applications. As soon as the command is sent via the I2C interface, the logic section of the TPS65263 IC takes over the control, allowing to program the voltage at each of the three outputs between 0.68V to 1.95V, with 10mV steps. This allows the desired output to be fine-tuned according to the application's specific needs, which is powered by the 3xBuck click. The I2C interface is also used to independently retrieve

the Power Good status, the overcurrent, and the die temperature warning for each buck section. There are three completely independent switching sections in the TPS65263 IC, meaning each has its dedicated Enable pin, Soft-Start pin, and loop compensation pin. The Enable pins for each section are routed to mikroBUS™. EN1, EN2, and EN3 are routed to AN, PWM, and INT pins of the mikroBUS™, respectively. This allows the host MCU to control the operation of the 3xBuck Click. Not all three sections share the same characteristics. The output of the 3xBuck click labeled as 1V8 (VOUT1) can withstand up to 3A of current while supplied with 12V across the input terminal. The other two outputs can deliver up to 2A, keeping the output well regulated, well within the 1% margin. However, it should be noted that this is the combined current rating, so if multiple outputs are used, the summed current consumption should not exceed these values. The input voltage should range between 4.5V and 18V, with a remark that it must be sufficiently higher than the selected output voltage to reach the specified voltage and current ratings. The soft-start feature uses a 10nF capacitor at the

dedicated SS pin. Each channel has its own dedicated SS pin, so three pins are used to set the soft start of each channel. The soft-start function prevents the high inrush current on power up, ramping up the output current during the soft-start period, defined by the capacitor. As mentioned, the device features protection functions that allow reliable operation in events such as short circuit protection, overcurrent, overvoltage, and thermal protection. If the connected load draws too much current, the cycle-by-cycle current limit will be activated on both high- and low-side output MOSFETs. If the high current condition persists after 0.5ms, the device will enter the hiccup mode, shutting down completely, then restarting after 14ms. The whole startup sequence will be repeated; if the fault condition persists on the output, this cycle will be repeated. This prevents damage in the case of significant loads connected at the output. The logic voltage level of the 3xBuck click can be selected by switching the SMD jumper labeled VCC SEL to an appropriate position. This allows interfacing with both 3.3V and 5V MCUs, expanding the interfacing options of this board.

3xBuck click hardware overview image

Features overview

Development board

Arduino UNO is a versatile microcontroller board built around the ATmega328P chip. It offers extensive connectivity options for various projects, featuring 14 digital input/output pins, six of which are PWM-capable, along with six analog inputs. Its core components include a 16MHz ceramic resonator, a USB connection, a power jack, an

ICSP header, and a reset button, providing everything necessary to power and program the board. The Uno is ready to go, whether connected to a computer via USB or powered by an AC-to-DC adapter or battery. As the first USB Arduino board, it serves as the benchmark for the Arduino platform, with "Uno" symbolizing its status as the

first in a series. This name choice, meaning "one" in Italian, commemorates the launch of Arduino Software (IDE) 1.0. Initially introduced alongside version 1.0 of the Arduino Software (IDE), the Uno has since become the foundational model for subsequent Arduino releases, embodying the platform's evolution.

Arduino UNO Rev3 double side image

Microcontroller Overview

MCU Card / MCU

default

Architecture

AVR

MCU Memory (KB)

32

Silicon Vendor

Microchip

Pin count

28

RAM (Bytes)

2048

You complete me!

Accessories

Click Shield for Arduino UNO has two proprietary mikroBUS™ sockets, allowing all the Click board™ devices to be interfaced with the Arduino UNO board without effort. The Arduino Uno, a microcontroller board based on the ATmega328P, provides an affordable and flexible way for users to try out new concepts and build prototypes with the ATmega328P microcontroller from various combinations of performance, power consumption, and features. The Arduino Uno has 14 digital input/output pins (of which six can be used as PWM outputs), six analog inputs, a 16 MHz ceramic resonator (CSTCE16M0V53-R0), a USB connection, a power jack, an ICSP header, and reset button. Most of the ATmega328P microcontroller pins are brought to the IO pins on the left and right edge of the board, which are then connected to two existing mikroBUS™ sockets. This Click Shield also has several switches that perform functions such as selecting the logic levels of analog signals on mikroBUS™ sockets and selecting logic voltage levels of the mikroBUS™ sockets themselves. Besides, the user is offered the possibility of using any Click board™ with the help of existing bidirectional level-shifting voltage translators, regardless of whether the Click board™ operates at a 3.3V or 5V logic voltage level. Once you connect the Arduino UNO board with our Click Shield for Arduino UNO, you can access hundreds of Click boards™, working with 3.3V or 5V logic voltage levels.

Click Shield for Arduino UNO accessories 1 image

Used MCU Pins

mikroBUS™ mapper

Channel 1 Enable
PC0
AN
NC
NC
RST
NC
NC
CS
NC
NC
SCK
NC
NC
MISO
NC
NC
MOSI
Power Supply
3.3V
3.3V
Ground
GND
GND
Channel 2 Enable
PD6
PWM
Channel 3 Enable
PC3
INT
NC
NC
TX
NC
NC
RX
I2C Clock
PC5
SCL
I2C Data
PC4
SDA
Power Supply
5V
5V
Ground
GND
GND
1

Take a closer look

Click board™ Schematic

3xBuck click Schematic schematic

Step by step

Project assembly

Click Shield for Arduino UNO front image hardware assembly

Start by selecting your development board and Click board™. Begin with the Arduino UNO Rev3 as your development board.

Click Shield for Arduino UNO front image hardware assembly
Arduino UNO Rev3 front image hardware assembly
Charger 27 Click front image hardware assembly
Prog-cut hardware assembly
Charger 27 Click complete accessories setup image hardware assembly
Arduino UNO Rev3 Access MB 1 - upright/background hardware assembly
Necto image step 2 hardware assembly
Necto image step 3 hardware assembly
Necto image step 4 hardware assembly
Necto image step 5 hardware assembly
Necto image step 6 hardware assembly
Arduino UNO MCU Step hardware assembly
Necto No Display image step 8 hardware assembly
Necto image step 9 hardware assembly
Necto image step 10 hardware assembly
Debug Image Necto Step hardware assembly

Track your results in real time

Application Output

1. Application Output - In Debug mode, the 'Application Output' window enables real-time data monitoring, offering direct insight into execution results. Ensure proper data display by configuring the environment correctly using the provided tutorial.

2. UART Terminal - Use the UART Terminal to monitor data transmission via a USB to UART converter, allowing direct communication between the Click board™ and your development system. Configure the baud rate and other serial settings according to your project's requirements to ensure proper functionality. For step-by-step setup instructions, refer to the provided tutorial.

3. Plot Output - The Plot feature offers a powerful way to visualize real-time sensor data, enabling trend analysis, debugging, and comparison of multiple data points. To set it up correctly, follow the provided tutorial, which includes a step-by-step example of using the Plot feature to display Click board™ readings. To use the Plot feature in your code, use the function: plot(*insert_graph_name*, variable_name);. This is a general format, and it is up to the user to replace 'insert_graph_name' with the actual graph name and 'variable_name' with the parameter to be displayed.

Software Support

Library Description

This library contains API for 3xBuck Click driver.

Key functions:

  • c3xbuck_enable_buck - This function enables desired Buck on the board

  • c3xbuck_disable_buck - This function disables desired Buck on the board

  • c3xbuck_set_voltage - This function sets voltage on desired Buck on the board

Open Source

Code example

The complete application code and a ready-to-use project are available through the NECTO Studio Package Manager for direct installation in the NECTO Studio. The application code can also be found on the MIKROE GitHub account.

/*!
 * \file 
 * \brief 3xBuck Click example
 * 
 * # Description
 * This example demonstrates the use of the 3 x Buck Click Board.
 *
 * The demo application is composed of two sections :
 * 
 * ## Application Init 
 * Initializes the driver and performs the click default configuration.
 * 
 * ## Application Task  
 * Alternates between predefined and default values for the Bucks output and 
 * logs the current set values on the USB UART.
 * 
 * @note
 * The default output voltage on Buck 1 is 1800mV, Buck 2 is 3300mV, and Buck 3 is 5000mV.
 * Configurable output voltage on all Bucks ranges from 680mV to 1950mV.
 * 
 * \author Petar Suknjaja
 *
 */
// ------------------------------------------------------------------- INCLUDES

#include "board.h"
#include "log.h"
#include "c3xbuck.h"

// ------------------------------------------------------------------ VARIABLES

static c3xbuck_t c3xbuck;
static log_t logger;

// ------------------------------------------------------ APPLICATION FUNCTIONS

void application_init ( void )
{
    log_cfg_t log_cfg;
    c3xbuck_cfg_t cfg;

    /** 
     * Logger initialization.
     * Default baud rate: 115200
     * Default log level: LOG_LEVEL_DEBUG
     * @note If USB_UART_RX and USB_UART_TX 
     * are defined as HAL_PIN_NC, you will 
     * need to define them manually for log to work. 
     * See @b LOG_MAP_USB_UART macro definition for detailed explanation.
     */
    LOG_MAP_USB_UART( log_cfg );
    log_init( &logger, &log_cfg );
    log_info( &logger, "---- Application Init ----" );

    //  Click initialization.

    c3xbuck_cfg_setup( &cfg );
    C3XBUCK_MAP_MIKROBUS( cfg, MIKROBUS_1 );
    c3xbuck_init( &c3xbuck, &cfg );
    Delay_ms ( 100 );
    
    c3xbuck_default_cfg ( &c3xbuck );
    log_info( &logger, "---- Application Task ----" );
}

void application_task ( void )
{
    //  Task implementation.
    log_printf( &logger, "Setting predefined values : \r\n" );
    log_printf( &logger, "Buck 1 : 1000 mV\r\n");
    log_printf( &logger, "Buck 2 : 1250 mV\r\n");
    log_printf( &logger, "Buck 3 : 1500 mV\r\n");
    
    c3xbuck_set_voltage( &c3xbuck, C3XBUCK_SELECT_BUCK_1, C3XBUCK_OUTPUT_VOLTAGE_1000mV );
    c3xbuck_set_voltage( &c3xbuck, C3XBUCK_SELECT_BUCK_2, C3XBUCK_OUTPUT_VOLTAGE_1250mV );
    c3xbuck_set_voltage( &c3xbuck, C3XBUCK_SELECT_BUCK_3, C3XBUCK_OUTPUT_VOLTAGE_1500mV );
    
    // 10 seconds delay
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    
    log_printf( &logger, "Setting default values: \r\n");
    log_printf( &logger, "Buck 1 : 1800 mV\r\n");
    log_printf( &logger, "Buck 2 : 3300 mV\r\n");
    log_printf( &logger, "Buck 3 : 5000 mV\r\n");
    
    c3xbuck_set_voltage( &c3xbuck, C3XBUCK_SELECT_BUCK_1, C3XBUCK_BUCK_DEFAULT_OUTPUT_VOLTAGE );
    c3xbuck_set_voltage( &c3xbuck, C3XBUCK_SELECT_BUCK_2, C3XBUCK_BUCK_DEFAULT_OUTPUT_VOLTAGE );
    c3xbuck_set_voltage( &c3xbuck, C3XBUCK_SELECT_BUCK_3, C3XBUCK_BUCK_DEFAULT_OUTPUT_VOLTAGE );
    
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
}

int main ( void ) 
{
    /* Do not remove this line or clock might not be set correctly. */
    #ifdef PREINIT_SUPPORTED
    preinit();
    #endif
    
    application_init( );
    
    for ( ; ; ) 
    {
        application_task( );
    }

    return 0;
}

// ------------------------------------------------------------------------ END

Additional Support

Resources

Love this project?

'Buy This Kit' button takes you directly to the shopping cart where you can easily add or remove products.