Manage multiple functions with our 2x2 keyboard based on 74HC32 and MK22FN512VLH12

Master your controls: 4 buttons, 1 solution

Published Oct 17, 2023

Click board™

2x2 Key Click

Dev Board

Kinetis Clicker

Compiler

NECTO Studio

MCU

MK22FN512VLH12

Our purpose is to maximize functionality while minimizing complexity with our 4-in-1 button integration

Hardware Overview

How does it work?

2x2 Key Click is based on the 2x2 button keyboard with debounce circuit, composed of the 74HC32, a quad 2-input OR gate from Nexperia, and the SN74HC14, a Hex Schmitt-Trigger inverter from Texas Instruments. In electronics, two metal components bounce or create multiple signals when they are in contact with each other — like when you push a button — before they reach a stable state. You want a single contact to be recorded, but the microcontroller records this as if you pressed the button many times. So debouncing is, as the name states, the removal of bounces or spikes of low and high voltages.

Graphically speaking, you want a clean line, not spikes. A debounce circuit makes sure that there are no voltage changes on the output. Thanks to it, one button press is recorded as such. All four Schmitt-trigger outputs are connected to the logic OR gate 74HC32 input pins, whose output is directly connected to the INT pin on mikroBUS. This pin is used to signalize an interrupt to the MCU any time a button is pressed. This way, the MCU software can be implemented as a simple polling routine without any delays programmed in the code (like it would be necessary if there weren’t a hardware debouncing circuit present).

Thanks to the INT pin, you can easily program a common interrupt service routine to detect when a button is pressed (the state of the button changes from low to high logic level). This Click board™ can operate with either 3.3V or 5V logic voltage levels selected via the PWR SEL jumper. This way, both 3.3V and 5V capable MCUs can use the communication lines properly. Also, this Click board™ comes equipped with a library containing easy-to-use functions and an example code that can be used as a reference for further development.

Features overview

Development board

Kinetis Clicker is a compact starter development board that brings the flexibility of add-on Click boards™ to your favorite microcontroller, making it a perfect starter kit for implementing your ideas. It comes with an onboard 32-bit ARM Cortex-M4 microcontroller, the MK22FN512VLH12 from NXP Semiconductor, a USB connector, LED indicators, buttons, a mikroProg connector, and a header for interfacing with external electronics. Thanks to its compact design with clear and easy-recognizable silkscreen markings, it provides a fluid and immersive working experience, allowing access

anywhere and under any circumstances. Each part of the Kinetis Clicker development kit contains the components necessary for the most efficient operation of the same board. In addition to the possibility of choosing the Kinetis Clicker programming method, using USB HID mikroBootloader, or through an external mikroProg connector for Kinetis programmer, the Clicker board also includes a clean and regulated power supply module for the development kit. The USB-MiniAB connection provides up to 500mA of current, which is more than enough to operate all

onboard and additional modules. All communication methods that mikroBUS™ itself supports are on this board, including the well-established mikroBUS™ socket, reset button, and several buttons and LED indicators. Kinetis Clicker is an integral part of the Mikroe ecosystem, allowing you to create a new application in minutes. Natively supported by Mikroe software tools, it covers many aspects of prototyping thanks to a considerable number of different Click boards™ (over a thousand boards), the number of which is growing every day.

Microcontroller Overview

MCU Card / MCU

Architecture

ARM Cortex-M4

MCU Memory (KB)

512

Silicon Vendor

NXP

Pin count

RAM (Bytes)

131072

Used MCU Pins

mikroBUS™ mapper

T1 Button Status

PTB2

T2 Button Status

PTB3

RST

T3 Button Status

PTC4

SCK

MISO

MOSI

Power Supply

3.3V

Ground

GND

T4 Button Status

PTC1

PWM

Interrupt

PTD0

INT

SCL

SDA

Power Supply

Ground

GND

Take a closer look

Schematic

Step by step

Project assembly

Kinetis Clicker front image hardware assembly

Start by selecting your development board and Click board™. Begin with the Kinetis Clicker as your development board.

Thermo 28 Click front image hardware assembly

Kinetis Mini B Connector clicker - upright/background hardware assembly

Kinetis Clicker HA MCU/Select Step hardware assembly

Necto No Display image step 8 hardware assembly

Debug Image Necto Step hardware assembly

Track your results in real time

Application Output

After loading the code example, pressing the "DEBUG" button builds and programs it on the selected setup.

After programming is completed, a header with buttons for various actions available in the IDE appears. By clicking the green "PLAY "button, we start reading the results achieved with Click board™.

Upon completion of programming, the Application Output tab is automatically opened, where the achieved result can be read. In case of an inability to perform the Debug function, check if a proper connection between the MCU used by the setup and the CODEGRIP programmer has been established. A detailed explanation of the CODEGRIP-board connection can be found in the CODEGRIP User Manual. Please find it in the RESOURCES section.

Software Support

Library Description

This library contains API for 2x2 Key Click driver.

Key functions:

c2x2key_t1_state - This function gets state of AN pin
c2x2key_t2_state - This function gets state of RST pin
c2x2key_t3_state - This function gets state of CS pin
c2x2key_t4_state - This function gets state of PWM pin

Open Source

Code example

This example can be found in NECTO Studio. Feel free to download the code, or you can copy the code below.

/*!
 * \file 
 * \brief 2x2 key Click example
 * 
 * # Description
 * 2x2 Key click has a 4 button keypad and allows multiple key presses.
 *
 * The demo application is composed of two sections :
 * 
 * ## Application Init 
 * Application Init performs Logger and Click initialization.
 * 
 * ## Application Task  
 * This example code demonstrates the usage of 2X2 Key Click board.
 * Detects whether any of the keys is pressed where results are being sent 
 * to the UART terminal where you can track changes.
 * 
 * \author Mihajlo Djordjevic
 *
 */
// ------------------------------------------------------------------- INCLUDES

#include "board.h"
#include "log.h"
#include "c2x2key.h"

uint8_t t1_state     = 0;
uint8_t t1_state_old = 1;
uint8_t t2_state     = 0;
uint8_t t2_state_old = 1;
uint8_t t3_state     = 0;
uint8_t t3_state_old = 1;
uint8_t t4_state     = 0;
uint8_t t4_state_old = 1;

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

static c2x2key_t c2x2key;
static log_t logger;

// ------------------------------------------------------- ADDITIONAL FUNCTIONS


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

void application_init ( void )
{
    log_cfg_t log_cfg;
    c2x2key_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_printf( &logger, "-- Application  Init --\r\n" );
    Delay_ms ( 1000 );

    //  Click initialization.

    c2x2key_cfg_setup( &cfg );
    C2X2KEY_MAP_MIKROBUS( cfg, MIKROBUS_1 );
    c2x2key_init( &c2x2key, &cfg );
    
    log_printf( &logger, "-----------------------\r\n" );
    log_printf( &logger, "     2X2 key Click     \r\n" );
    log_printf( &logger, "-----------------------\r\n" );
    Delay_ms ( 1000 );
    
    log_printf( &logger, "    System is ready    \r\n" );
    log_printf( &logger, "-----------------------\r\n" );
    Delay_ms ( 1000 );
}

void application_task ( void )
{
   t1_state = c2x2key_t1_state( &c2x2key );
   
   if ( ( t1_state == 1 ) && ( t1_state_old == 0 ) )
    {
        log_printf( &logger, "-----------------------\r\n" );
        log_printf( &logger, "     Key 1 pressed     \r\n" );
        log_printf( &logger, "-----------------------\r\n" );
        t1_state_old = 1;
    }
    
    if ( ( t1_state == 0 ) && ( t1_state_old == 1 ) )
    {
        t1_state_old = 0;
    }
    
    t2_state = c2x2key_t2_state( &c2x2key );
   
   if ( ( t2_state == 1 ) && ( t2_state_old == 0 ) )
    {
        log_printf( &logger, "-----------------------\r\n" );
        log_printf( &logger, "     Key 2 pressed     \r\n" );
        log_printf( &logger, "-----------------------\r\n" );
        t2_state_old = 1;
    }
    
    if ( ( t2_state == 0 ) && ( t2_state_old == 1 ) )
    {
        t2_state_old = 0;
    }
    
    t3_state = c2x2key_t3_state( &c2x2key );
   
   if ( ( t3_state == 1 ) && ( t3_state_old == 0 ) )
    {
        log_printf( &logger, "-----------------------\r\n" );
        log_printf( &logger, "     Key 3 pressed     \r\n" );
        log_printf( &logger, "-----------------------\r\n" );
        t3_state_old = 1;
    }
    
    if ( ( t3_state == 0 ) && ( t3_state_old == 1 ) )
    {
        t3_state_old = 0;
    }
    
    t4_state = c2x2key_t4_state( &c2x2key );
   
   if ( ( t4_state == 1 ) && ( t4_state_old == 0 ) )
    {
        log_printf( &logger, "-----------------------\r\n" );
        log_printf( &logger, "     Key 4 pressed     \r\n" );
        log_printf( &logger, "-----------------------\r\n" );
        t4_state_old = 1;
    }
    
    if ( ( t4_state == 0 ) && ( t4_state_old == 1 ) )
    {
        t4_state_old = 0;
    }
}

void main ( void )
{
    application_init( );

    for ( ; ; )
    {
        application_task( );
    }
}

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