Dálkové ovládání pomocí infračervených kódů (PIO programování)

cmake_minimum_required(VERSION 3.13)

set(PICO_BOARD pico)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)


# initialize the SDK based on PICO_SDK_PATH
# note: this must happen before project()
include($ENV{PICO_SDK_PATH}/external/pico_sdk_import.cmake)

project(ir_keyboard C CXX ASM)

# initialize the Raspberry Pi Pico SDK
pico_sdk_init()

add_subdirectory( nec_transmit_library )
add_executable (ir_keyboard ir_keyboard.c)
pico_generate_pio_header(ir_keyboard ${CMAKE_CURRENT_LIST_DIR}/keyboard.pio)


# link the executable using the IR transmit library
#
target_link_libraries(ir_keyboard LINK_PUBLIC
  pico_stdlib
  hardware_pio
  nec_transmit_library
  )

pico_add_extra_outputs(ir_keyboard)
pico_enable_stdio_usb(ir_keyboard 1)
pico_enable_stdio_uart(ir_keyboard 0)

/**
 * Maticová klávesnice 4x4 s přenosem IR na jiné Pico
 * ir_keyboard.c
 * Copyright (c) 2026 Jirka Chráska, <jirka@lixis.cz>
 *
 * License: BSD-3-Clause
 */

#include <stdio.h>
#include <stdlib.h>
#include "pico/stdlib.h"
#include "pico/util/queue.h"
#include "hardware/pio.h"
// knihovna pro přenos IR
#include "nec_transmit.h"                           
// klávesnice pomocí PIO
#include "keyboard.pio.h"

#define BASE_KEYPAD_PIN 14
#define OUT_KEYPAD_PIN  18
#define KEYROWS         4
#define NUMKEYS         16
#define FIFO_SIZE       64
#define MAX_COUNTER     10
#define IR_addr         0xac
#define IR_LED_PIN      2


static PIO ir_pio = pio0;
static uint ir_sm;

static PIO kbd_pio = pio1;
static uint kbd_sm;
static uint8_t kbd_pio_irq;
static uint kbd_offset;
static bool klavesa = false;
static queue_t fifo;

char pismeno = '\0';


static char klavesy[4][4] = {
                            '1', '2', '3', 'A',
                            '4', '5', '6', 'B',
                            '7', '8', '9', 'C',
                            '*', '0', '#', 'D'
                            };
                            
                            
static uint32_t tx_frame[4][4] = {
        0,0,0,0,
        0,0,0,0,
        0,0,0,0,
        0,0,0,0
};

// naplnění pole tx_frame
// zakódování jednotlivých kláves pro přenos NEC protokolem
void encode_all_keys()
{
    for(int i=0; i<4; i++) {
        for(int j=0; j<4; j++) {
            tx_frame[j][i] = nec_encode_frame(IR_addr, klavesy[i][j]);
        }
    }
}

// obsluha přerušení vyvolaná při stisku klávesy
static void pio_irq_obsluzna_funkce( void )
{
    while( !pio_sm_is_rx_fifo_empty( kbd_pio, kbd_sm ) ) {
        if( pio_sm_get_rx_fifo_level(kbd_pio, kbd_sm) == 2 ) {
            uint32_t x,y;
            x = pio_sm_get( kbd_pio, kbd_sm );
            y = pio_sm_get( kbd_pio, kbd_sm );
            int i, j;
            for( i=0; i<4; i++) {
                if( x >> i == 1) break;
            }
            for( j=0; j<4; j++) {
                if( y >> j == 1 ) break;
            }
            pismeno = klavesy[j][i];
            // odeslání IR kódu
            pio_sm_put(ir_pio, ir_sm, tx_frame[i][j]);
            klavesa = true;
        }
    }
    irq_clear(kbd_pio_irq);
}



int main() 
{
    stdio_init_all();
    gpio_init(25);
    gpio_set_dir(25,true);
    gpio_put(25,1);
    sleep_ms(2000);
    gpio_put(25,0);
    printf("Klávesnice s IR vysílačem.\n");
    // protože budeme posílat IR kódy v rámci obsluhy přerušení klávesnice,
    // připravíme si dopředu zakódování, aby byla obsluha přerušení rychlá
    encode_all_keys();
    const uint tx_gpio = IR_LED_PIN;   // pin kde je IR LED

    // konfigurace a spuštění stavového PIO strojku pro IR
    ir_sm = nec_tx_init(ir_pio, tx_gpio);           
    
    // nastavení klávesnice
    queue_init(&fifo, sizeof(uint32_t), FIFO_SIZE);
    kbd_offset = pio_add_program(kbd_pio, &keyboard_program);
    kbd_sm = pio_claim_unused_sm(kbd_pio, true);
    if (kbd_sm == -1 || ir_sm == -1) {
        printf("Nemohu nastavit PIO\n");
        return -1;
    }
    keyboard_program_init(kbd_pio, kbd_sm, kbd_offset, BASE_KEYPAD_PIN, OUT_KEYPAD_PIN);
    // najdeme volné přerušení
    kbd_pio_irq = pio_get_irq_num(kbd_pio,0);
    if( irq_get_exclusive_handler( kbd_pio_irq ) ) {
        kbd_pio_irq++;
        if( irq_get_exclusive_handler( kbd_pio_irq ) ){
            panic("Nenalezen volný interrupt.");
        }
    }
    // nastavíme přerušení pro klávesnici
    // přidáme sdílenou obsluhu
    irq_add_shared_handler(kbd_pio_irq, pio_irq_obsluzna_funkce, 
                           PICO_SHARED_IRQ_HANDLER_DEFAULT_ORDER_PRIORITY); 
    irq_set_enabled(kbd_pio_irq, true); // spustíme
    // obdržíme číslo přerušení
    const uint irq_index = kbd_pio_irq - pio_get_irq_num( kbd_pio, 0); 
    // nastavíme pio, aby nám řekl, když je něco ve frontě
    pio_set_irqn_source_enabled( kbd_pio, irq_index, 
                                 pio_get_rx_fifo_not_empty_interrupt_source(kbd_sm), true); 
                          
    // tohle je jenom test, že to funguje
    while (true) {      
        if(klavesa == true) {
            gpio_put(25,1); // blikneme default LEDkou
            printf("Stisknuto '%c'\n",pismeno);
            klavesa = false;
            sleep_ms(200);
            gpio_put(25,0);
        }
        sleep_ms(100);
    }
    
    queue_free(&fifo);
}

; klavesnice
; (c) Jirka Chráska 2025; <jirka@lixis.cz>
.program keyboard
; 
; 
; 
.define KEYBOARD_IRQ 0
.wrap_target

nastav_radek_1:
    set pins, 1 [31]        ; nastavím 1 pro 1. řádek klávesnice
    set X, 0x1
    in pins, 4
    mov Y, isr
    jmp !Y, nastav_radek_2
    jmp rx_fifo

nastav_radek_2:
    set pins, 2 [31]        ; nastavím 1 pro 2. řádek klávesnice
    set X, 0x2
    in pins, 4
    mov Y, isr
    jmp !Y, nastav_radek_3
    jmp rx_fifo

nastav_radek_3:
    set pins, 4 [31]        ; nastavím 1 pro 3. řádek klávesnice
    set X, 0x4
    in pins, 4
    mov Y, isr
    jmp !Y, nastav_radek_4
    jmp rx_fifo

nastav_radek_4:
    set pins, 8 [31]        ; nastavím 1 pro 4. řádek klávesnice
    set X, 0x8
    in pins, 4
    mov Y, isr
    jmp !Y nastav_radek_1

rx_fifo:
    push                    ; pošlu souřadnici y (řádek)
    in X, 4 [2]
    push                    ; pošlu souřadnici x (sloupec)
    irq KEYBOARD_IRQ  rel    
    
    wait 0 pin 0            ; čekám, až bude klávesa uvolněna
    wait 0 pin 1
    wait 0 pin 2
    wait 0 pin 3
    
.wrap

% c-sdk {

#include "hardware/clocks.h"
#include "hardware/gpio.h"

static inline void keyboard_program_init (PIO pio, uint sm, uint offset, uint row_pin, uint col_pin) {

    // řádkové piny jsou nastaveny jako výstupní
    //
    pio_gpio_init(pio, row_pin);
    pio_gpio_init(pio, row_pin+1);
    pio_gpio_init(pio, row_pin+2);
    pio_gpio_init(pio, row_pin+3);
    pio_sm_set_consecutive_pindirs(pio, sm, row_pin, 4, true);
    
    // sloupcové piny
    pio_sm_set_consecutive_pindirs(pio, sm, col_pin, 4, false);

    
    // Konfigurace stavového stroje
    pio_sm_config c = keyboard_program_get_default_config (offset);

    // konfigurace vstupního posuvného registru (Input Shift Register)
    sm_config_set_in_shift (&c,
                            false,       // posunujeme doprava
                            false,       // autopush je vypnut
                            32);         // 

    
    // piny pro funkci IN
    sm_config_set_in_pins( &c, col_pin );
    // piny pro funkci SET
    sm_config_set_set_pins( &c, row_pin, 4 );
    
    // zvětšení fronty
    // sm_config_set_fifo_join (&c, PIO_FIFO_JOIN_RX);

    // Tik hodin stavového stroje nastavíme na 2 KHz
    float div = clock_get_hz (clk_sys) / 4000;
    sm_config_set_clkdiv (&c, div);
    
    // Konfiguraci šoupneme do stavového stroje
    pio_sm_init (pio, sm, offset, &c);

    // Stavový stroj spustíme
    pio_sm_set_enabled (pio, sm, true);
}
%}

# build a normal library
#
add_library(nec_transmit_library nec_transmit.c)

# invoke pio_asm to assemble the PIO state machine programs
#
pico_generate_pio_header(nec_transmit_library ${CMAKE_CURRENT_LIST_DIR}/nec_carrier_burst.pio)
pico_generate_pio_header(nec_transmit_library ${CMAKE_CURRENT_LIST_DIR}/nec_carrier_control.pio)

target_link_libraries(nec_transmit_library PRIVATE
        pico_stdlib
        hardware_pio
        )

# add the `binary` directory so that the generated headers are included in the project
#
target_include_directories (nec_transmit_library PUBLIC
	${CMAKE_CURRENT_SOURCE_DIR}
	${CMAKE_CURRENT_BINARY_DIR}
	)

/**
 * Copyright (c) 2021 mjcross
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include "pico/stdlib.h"
#include "hardware/pio.h"

// public API

int nec_tx_init(PIO pio, uint pin);
uint32_t nec_encode_frame(uint8_t address, uint8_t data);

/**
 * Copyright (c) 2021 mjcross
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */


// SDK types and declarations
//
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "hardware/clocks.h"    // for clock_get_hz()
#include "nec_transmit.h"

// import the assembled PIO state machine programs
#include "nec_carrier_burst.pio.h"
#include "nec_carrier_control.pio.h"

// Claim an unused state machine on the specified PIO and configure it
// to transmit NEC IR frames on the specified GPIO pin.
//
// Returns: on success, the number of the carrier_control state machine
// otherwise -1
int nec_tx_init(PIO pio, uint pin_num) {

    // install the carrier_burst program in the PIO shared instruction space
    uint carrier_burst_offset;
    if (pio_can_add_program(pio, &nec_carrier_burst_program)) {
        carrier_burst_offset = pio_add_program(pio, &nec_carrier_burst_program);
    } else {
        return -1;
    }

    // claim an unused state machine on this PIO
    int carrier_burst_sm = pio_claim_unused_sm(pio, true);
    if (carrier_burst_sm == -1) {
        return -1;
    }

    // configure and enable the state machine
    nec_carrier_burst_program_init(pio,
                                   carrier_burst_sm,
                                   carrier_burst_offset,
                                   pin_num,
                                   38.222e3);                   // 38.222 kHz carrier

    // install the carrier_control program in the PIO shared instruction space
    uint carrier_control_offset;
    if (pio_can_add_program(pio, &nec_carrier_control_program)) {
        carrier_control_offset = pio_add_program(pio, &nec_carrier_control_program);
    } else {
        return -1;
    }

    // claim an unused state machine on this PIO
    int carrier_control_sm = pio_claim_unused_sm(pio, true);
    if (carrier_control_sm == -1) {
        return -1;
    }

    // configure and enable the state machine
    nec_carrier_control_program_init(pio,
                                     carrier_control_sm,
                                     carrier_control_offset,
                                     2 * (1 / 562.5e-6f),        // 2 ticks per 562.5us carrier burst
                                     32);                       // 32 bits per frame

    return carrier_control_sm;
}


// Create a frame in `NEC` format from the provided 8-bit address and data
//
// Returns: a 32-bit encoded frame
uint32_t nec_encode_frame(uint8_t address, uint8_t data) {
    // a normal 32-bit frame is encoded as address, inverted address, data, inverse data,
    return address | (address ^ 0xff) << 8 | data << 16 | (data ^ 0xff) << 24;
}

;
; Copyright (c) 2021 mjcross
;
; SPDX-License-Identifier: BSD-3-Clause
;
.pio_version 0 // only requires PIO version 0

.program nec_carrier_control

; Transmit an encoded 32-bit frame in NEC IR format.
;
; Accepts 32-bit words from the transmit FIFO and sends them least-significant bit first
; using pulse position modulation.
;
; Carrier bursts are generated using the nec_carrier_burst program, which is expected to be
; running on a separate state machine.
;
; This program expects there to be 2 state machine ticks per 'normal' 562.5us
; burst period.
;
.define BURST_IRQ 7                     ; the IRQ used to trigger a carrier burst
.define NUM_INITIAL_BURSTS 16           ; how many bursts to transmit for a 'sync burst'

.wrap_target
    pull                                ; fetch a data word from the transmit FIFO into the
                                        ; output shift register, blocking if the FIFO is empty

    set X, (NUM_INITIAL_BURSTS - 1)     ; send a sync burst (9ms)
long_burst:
    irq BURST_IRQ
    jmp X-- long_burst

    nop [15]                            ; send a 4.5ms space
    irq BURST_IRQ [1]                   ; send a 562.5us burst to begin the first data bit

data_bit:
    out X, 1                            ; shift the least-significant bit from the OSR
    jmp !X burst                        ; send a short delay for a '0' bit
    nop [3]                             ; send an additional delay for a '1' bit
burst:
    irq BURST_IRQ                       ; send a 562.5us burst to end the data bit

jmp !OSRE data_bit                      ; continue sending bits until the OSR is empty

.wrap                                   ; fetch another data word from the FIFO


% c-sdk {
static inline void nec_carrier_control_program_init (PIO pio, uint sm, uint offset, float tick_rate, int bits_per_frame) {

    // create a new state machine configuration
    //
    pio_sm_config c = nec_carrier_control_program_get_default_config(offset);

    // configure the output shift register
    //
    sm_config_set_out_shift (&c,
                             true,       // shift right
                             false,      // disable autopull
                             bits_per_frame);

    // join the FIFOs to make a single large transmit FIFO
    //
    sm_config_set_fifo_join (&c, PIO_FIFO_JOIN_TX);

    // configure the clock divider
    //
    float div = clock_get_hz (clk_sys) / tick_rate;
    sm_config_set_clkdiv (&c, div);

    // apply the configuration to the state machine
    //
    pio_sm_init(pio, sm, offset, &c);

    // set the state machine running
    //
    pio_sm_set_enabled(pio, sm, true);
}
%}

;
; Copyright (c) 2021 mjcross
;
; SPDX-License-Identifier: BSD-3-Clause
;
.pio_version 0 // only requires PIO version 0

.program nec_carrier_burst

; Generate bursts of carrier.
;
; Repeatedly wait for an IRQ to be set then clear it and generate 21 cycles of
; carrier with 25% duty cycle
;
.define NUM_CYCLES 21               ; how many carrier cycles to generate
.define BURST_IRQ 7                 ; which IRQ should trigger a carrier burst
.define public TICKS_PER_LOOP 4     ; the number of instructions in the loop (for timing)

.wrap_target
    set X, (NUM_CYCLES - 1)         ; initialise the loop counter
    wait 1 irq BURST_IRQ            ; wait for the IRQ then clear it
cycle_loop:
    set pins, 1                     ; set the pin high (1 cycle)
    set pins, 0 [1]                 ; set the pin low (2 cycles)
    jmp X--, cycle_loop             ; (1 more cycle)
.wrap


% c-sdk {
static inline void nec_carrier_burst_program_init(PIO pio, uint sm, uint offset, uint pin, float freq) {
    // Create a new state machine configuration
    //
    pio_sm_config c = nec_carrier_burst_program_get_default_config (offset);

    // Map the SET pin group to one pin, namely the `pin`
    // parameter to this function.
    //
    sm_config_set_set_pins (&c, pin, 1);

    // Set the GPIO function of the pin (connect the PIO to the pad)
    //
    pio_gpio_init (pio, pin);

    // Set the pin direction to output at the PIO
    //
    pio_sm_set_consecutive_pindirs (pio, sm, pin, 1, true);

    // Set the clock divider to generate the required frequency
    //
    float div = clock_get_hz (clk_sys) / (freq * nec_carrier_burst_TICKS_PER_LOOP);
    sm_config_set_clkdiv (&c, div);

    // Apply the configuration to the state machine
    //
    pio_sm_init (pio, sm, offset, &c);

    // Set the state machine running
    //
    pio_sm_set_enabled (pio, sm, true);
}
%}