Operácie

Jednoduchý prijímač diaľkového IR ovládania: Rozdiel medzi revíziami

Z SensorWiki

(→‎Algoritmus a program)
(→‎Algoritmus a program)
Riadok 35: Riadok 35:
  
 
<tabs>
 
<tabs>
−
<tab name="AVR C-code"><source lang="c++" style="background: LightYellow;">
+
<tab name="Irremote"><source lang="c++" style="background: LightYellow;">
 
#include <avr/io.h>
 
#include <avr/io.h>
 +
#include <avr/interrupt.h>
 +
#include <util/delay.h>
 +
#include <stdio.h>
 +
#include "uart.h"
  
−
int main(void)
+
// #define F_CPU 16000000UL
−
{
+
// #define BAUD 9600
−
  unsigned int measuredValue;
+
 
 +
// Define button codes (example values, replace with actual values from your remote)
 +
#define RED_BUTTON 0xFFA25D
 +
#define GREEN_BUTTON 0xFF629D
 +
#define BLUE_BUTTON 0xFFE21D
 +
#define OFF_BUTTON 0xFF22DD
 +
#define IRLED PD2
 +
 
 +
#define toggleBIT(reg, bit) ((reg) ^=  (1 << (bit))) //PREPNUTIE STAVU
 +
#define setBIT(reg, bit) ((reg) |= (1 << (bit))) //JEDNA   
 +
#define clearBIT(reg, bit) ((reg) &= ~(1 << (bit))) //NULAs
 +
 
 +
volatile uint32_t ir_code = 0;
 +
volatile uint8_t bit_count = 0;
 +
 
 +
void initIRReceiver(void);
 +
void initRGBLED(void);
 +
void setColor(uint8_t red, uint8_t green, uint8_t blue);
 +
void handleIRCode(uint32_t code);
 +
 
 +
FILE mystdout = FDEV_SETUP_STREAM(uart_putc, NULL, _FDEV_SETUP_WRITE);
 +
 
 +
 
 +
ISR(INT0_vect) {
 +
    // Simple state machine to decode the IR signal
 +
    static uint8_t last_edge = 0;
 +
    uint8_t edge = (PIND & (1 << PIND2)) >> PIND2;
 +
    uint16_t duration = TCNT1;
 +
    TCNT1 = 0;
 +
 
 +
    if (edge == last_edge) return;
 +
    last_edge = edge;
 +
 
 +
    if (duration > 10000) { // Header
 +
        ir_code = 0;
 +
        bit_count = 0;
 +
    } else if (duration > 0 && duration < 100) { // Logical 0
 +
        ir_code = 0xFFA25D ;
 +
        bit_count++;
 +
    } else if (duration > 100 && duration < 200) { // Logical 1
 +
        ir_code = 0xFF629D;
 +
        bit_count++;
 +
    }
 +
else if (duration > 200 && duration < 300) { // Logical 1
 +
        ir_code = 0xFFE21D;
 +
        bit_count++;
 +
    }
 +
 
 +
    if (bit_count >= 32) {
 +
        handleIRCode(ir_code);
 +
printf("IR Code: %08lX\n",ir_code);
 +
        ir_code = 0;
 +
        bit_count = 0;
 +
    }
 +
}
 +
 
 +
void initIRReceiver(void) {
 +
clearBIT(PORTD,IRLED);
 +
clearBIT(DDRD,IRLED);
 +
 +
EICRA |= (1 << ISC00); // Any logical change on INT0 triggers interrupt
 +
    EIMSK |= (1 << INT0);  // Enable external interrupt INT0
 +
 
 +
    // Timer1 initialization
 +
    TCCR1B |= (1 << CS11); // Prescaler 8
 +
    TCNT1 = 0;            // Initialize counter
 +
}
 +
 
 +
void initRGBLED(void) {
 +
    // Set PB1, PB2, and PB3 as output (PWM)
 +
    DDRB |= (1 << PB1) | (1 << PB2) | (1 << PB3);
 +
 
 +
    // Setup Timer1 for Fast PWM mode on PB1 and PB2
 +
    TCCR1A |= (1 << COM1A1) | (1 << COM1B1) | (1 << WGM11);
 +
    TCCR1B |= (1 << WGM12) | (1 << WGM13);
 +
    ICR1 = 255; // TOP value for 8-bit PWM
 +
 
 +
    // Setup Timer2 for Fast PWM mode on PB3
 +
    TCCR2A |= (1 << COM2A1) | (1 << WGM20) | (1 << WGM21);
 +
    TCCR2B |= (1 << CS21); // Prescaler 8
 +
}
 +
 
 +
void setColor(uint8_t red, uint8_t green, uint8_t blue) {
 +
    OCR1A = red;  // Set PWM value for PB1 (Red)
 +
    OCR1B = green; // Set PWM value for PB2 (Green)
 +
    OCR2A = blue;  // Set PWM value for PB3 (Blue)
 +
}
  
−
  while (1)
+
void handleIRCode(uint32_t code) {
−
  {
+
    switch(code) {
−
    /*  relax  */
+
        case RED_BUTTON:
−
  }
+
            printf("Red Button Pressed\n");
 +
            setColor(255, 0, 0); // Red
 +
            break;
 +
        case GREEN_BUTTON:
 +
            printf("Green Button Pressed\n");
 +
            setColor(0, 255, 0); // Green
 +
            break;
 +
        case BLUE_BUTTON:
 +
            printf("Blue Button Pressed\n");
 +
            setColor(0, 0, 255); // Blue
 +
            break;
 +
        case OFF_BUTTON:
 +
            printf("Off Button Pressed\n");
 +
            setColor(0, 0, 0); // Off
 +
            break;
 +
        default:
 +
            printf("Unknown Button Pressed\n");
 +
            break;
 +
    }
 +
}
  
−
  return(0);
+
int main(void) {
 +
    uart_init();
 +
stdout = &mystdout;
 +
 +
    initIRReceiver();
 +
    initRGBLED();
 +
 +
    printf("System Initialized\n");
 +
 +
sei(); //globalne interupty
 +
 +
    while (1)
 +
{
 +
printf("IR Code: %08lX\r",ir_code);
 +
       
 +
    }
 
}
 
}
  
 
</source></tab>
 
</source></tab>
−
<tab name="filename.h"><source lang="c++" style="background: LightYellow;">
+
<tab name="SemProj_uart.c"><source lang="c++" style="background: LightYellow;">
 
#include <avr/io.h>
 
#include <avr/io.h>
 +
#include <util/delay.h>
 +
#include "uart.h"
 +
 +
#define CLK  PD5  // CLK -> pin 5 portD.5
 +
#define DIO  PD4  // DIO -> pin 4 portD.4
 +
 +
#define BIT_DELAY 100  // Delay 100ms
 +
 +
// Define for TM1637
 +
#define TM1637_I2C_COMM1    0x40
 +
#define TM1637_I2C_COMM2    0xC0
 +
#define TM1637_I2C_COMM3    0x80
 +
 +
// Nastavenie cisiel na 7 segmentovom displeji
 +
const uint8_t digitToSegment[] = {
 +
    // XGFEDCBA
 +
    0b00111111,    // 0
 +
    0b00000110,    // 1
 +
    0b01011011,    // 2
 +
    0b01001111,    // 3
 +
    0b01100110,    // 4
 +
    0b01101101,    // 5
 +
    0b01111101,    // 6
 +
    0b00000111,    // 7
 +
    0b01111111,    // 8
 +
    0b01101111,    // 9
 +
    0b01110111,    // A
 +
    0b01111100,    // b
 +
    0b00111001,    // C
 +
    0b01011110,    // d
 +
    0b01111001,    // E
 +
    0b01110001    // F
 +
};
 +
 +
uint8_t brightness = (0x7 & 0x7) | 0x08;
 +
 +
static const uint8_t minusSegments = 0b01000000;
 +
 +
int inicialize_bit(uint8_t byte){
 +
    uint8_t data = byte;
 +
   
 +
    // 8 Data Bits
 +
    for(uint8_t i = 0; i < 8; i++) {
 +
        // CLK low
 +
        set_bit(DDRD, CLK);
 +
        clear_bit(PORTD, CLK);
 +
        _delay_us(BIT_DELAY);
 +
       
 +
        // Set data bit
 +
        if (data & 0x01){
 +
            clear_bit(DDRD, DIO);  // Nastavenie DIO ako input
 +
            set_bit(PORTD, DIO);  // DIO ako input pull-up on
 +
        } else{
 +
            set_bit(DDRD, DIO);    // Nastavenie DIO ako output
 +
            clear_bit(PORTD, DIO); // Nastavenie DIO low
 +
        }
 +
       
 +
        _delay_us(BIT_DELAY);
 +
       
 +
        // CLK high
 +
        clear_bit(DDRD, CLK);  // Nastavenie CLK ako input
 +
        set_bit(PORTD, CLK);  // CLK ako input pull-up on
 +
        _delay_us(BIT_DELAY);
 +
        data = data >> 1;
 +
    }
 +
   
 +
    // Wait for acknowledge
 +
    // CLK to zero
 +
    set_bit(DDRD, CLK);    // Nastavenie CLK ako output
 +
    clear_bit(PORTD, CLK);  // Nastavenie CLK low
 +
   
 +
    clear_bit(DDRD, DIO);  // Nastavenie DIO ako input
 +
    set_bit(PORTD, DIO);    // DIO ako input pull-up on
 +
    _delay_us(BIT_DELAY);
 +
   
 +
    // CLK to high
 +
    clear_bit(DDRD, CLK);  // Nastavenie CLK ako input
 +
    set_bit(PORTD, CLK);    // Nastavenie CLK high
 +
    _delay_us(BIT_DELAY);
 +
    uint8_t ack = !bit_is_clear(PIND, DIO);
 +
    if (ack == 0)
 +
        set_bit(DDRD, DIO);  // Nastavenie DIO ako output
 +
    clear_bit(PORTD, DIO);  // Nastavenie DIO low
 +
   
 +
    _delay_us(BIT_DELAY);
 +
    set_bit(DDRD, CLK);    // Nastavenie CLK ako output
 +
    clear_bit(PORTD, CLK); // Nastavenie CLK low
 +
    _delay_us(BIT_DELAY);
 +
   
 +
    return ack;
 +
}
 +
 +
 +
void comunication_start(){
 +
    set_bit(DDRD, DIO);    // Nastavenie DIO ako output
 +
    clear_bit(PORTD, DIO); // Nastavenie DIO ako output
 +
    _delay_us(BIT_DELAY);
 +
}
 +
 +
void comunication_stop(){
 +
    set_bit(DDRD, DIO);    // Nastavenie DIO ako output
 +
    clear_bit(PORTD, DIO); // Nastavenie DIO ako output
 +
    _delay_us(BIT_DELAY);
 +
   
 +
    clear_bit(DDRD, CLK);  // Nastavenie CLK ako input
 +
    set_bit(PORTD, CLK);  // CLK ako input pull-up on
 +
    _delay_us(BIT_DELAY);
 +
   
 +
    clear_bit(DDRD, DIO);  // Nastavenie DIO ako input
 +
    set_bit(PORTD, DIO);  // DIO ako input pull-up on
 +
    _delay_us(BIT_DELAY);
 +
}
 +
 +
 +
void displayShowDots(uint8_t dots, uint8_t* digits){
 +
    for(int i = 0; i < 4; ++i)
 +
    {
 +
        digits[i] |= (dots & 0x80);
 +
        dots <<= 1;
 +
    }
 +
}
 +
 +
 +
// Funkcia na zobrazenie cisla
 +
void display_middle_dots(int num, uint8_t dots, const int leading_zero, uint8_t length, uint8_t pos){
 +
    display_number(num < 0? -10 : 10, num < 0? -num : num, dots, leading_zero, length, pos);
 +
}
 +
 +
// Funkcia na zobrazenie cisla v danom zaklade
 +
void display_number(int8_t base, uint16_t num, uint8_t dots, const int leading_zero, uint8_t length, uint8_t pos)
 +
{
 +
    int negative = 0; // False
 +
    if (base < 0) {
 +
        base = -base;
 +
        negative = 1; // True
 +
    }
 +
   
 +
    uint8_t digits[4];
 +
   
 +
    if (num == 0 && !leading_zero) {
 +
        for(uint8_t i = 0; i < (length-1); i++)
 +
            digits[i] = 0;
 +
        digits[length-1] = digitToSegment[0 & 0x0f];;
 +
    }
 +
    else {
 +
        for(int i = length-1; i >= 0; --i)
 +
        {
 +
            uint8_t digit = num % base;
 +
           
 +
            if (digit == 0 && num == 0 && leading_zero == 0)
 +
                digits[i] = 0;
 +
            else
 +
                digits[i] = digitToSegment[digit & 0x0f];;
 +
           
 +
            if (digit == 0 && num == 0 && negative) {
 +
                digits[i] = minusSegments;
 +
                negative = 0;
 +
            }
 +
           
 +
            num /= base;
 +
        }
 +
    }
 +
   
 +
    if(dots != 0)
 +
    {
 +
        displayShowDots(dots, digits);
 +
    }
 +
   
 +
    set_segments(digits, length, pos);
 +
}
 +
 +
// Funkcia na zobrazenie cisla s default nastaveniami
 +
void display_number_segment(int num, const int leading_zero, uint8_t length, uint8_t pos){
 +
    display_middle_dots(num,  0x40, leading_zero, length, pos);
 +
}
 +
 +
void set_segments(const uint8_t segments[], uint8_t length, uint8_t pos){
 +
    // Zapis COMM1
 +
    comunication_start();
 +
    inicialize_bit(TM1637_I2C_COMM1);
 +
    comunication_stop();
 +
   
 +
    // Zapis COMM2 + prvu cislicu adresy
 +
    comunication_start();
 +
    inicialize_bit(TM1637_I2C_COMM2 + (pos & 0x03));
 +
   
 +
    // Zapis datove bajty
 +
    for (uint8_t k=0; k < length; k++)
 +
        inicialize_bit(segments[k]);
 +
   
 +
    comunication_stop();
 +
   
 +
    // Zapis COMM3 + brightness
 +
    comunication_start();
 +
    inicialize_bit(TM1637_I2C_COMM3 + (brightness & 0x0f));
 +
    comunication_stop();
 +
}
 +
 +
  
−
void adc_init(void);                                  // A/D converter initialization
 
  
−
unsigned int adc_read(char a_pin);
 
 
</source></tab>
 
</source></tab>
−
</tabs>
+
<tab name="SemProj_uart.h"><source lang="c++" style="background: LightYellow;">
 +
#define set_bit(ADDRESS,BIT) (ADDRESS |= (1<<BIT))
 +
#define clear_bit(ADDRESS,BIT) (ADDRESS &= ~(1<<BIT))
 +
 
 +
#ifndef UART_H_
 +
#define UART_H_
 +
 
 +
void comunication_start();
 +
void comunication_stop();
 +
void displayShowDots(uint8_t dots, uint8_t* digits);
 +
int inicialize_bit(uint8_t byte);
 +
void display_middle_dots(int num, uint8_t dots, const int leading_zero, uint8_t length, uint8_t pos);
 +
void display_number(int8_t base, uint16_t num, uint8_t dots, const int leading_zero, uint8_t length, uint8_t pos);
 +
void display_number_segment(int num, const int leading_zero, uint8_t length, uint8_t pos);
 +
void set_segments(const uint8_t segments[], uint8_t length, uint8_t pos);
  
−
Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':
 
  
 +
#endif /* UART_H_ */
 +
</source></tab>
 +
</tabs>
 
Zdrojový kód: [[Médiá:projektKaterynaBuzko.zip|zdrojaky.zip]]
 
Zdrojový kód: [[Médiá:projektKaterynaBuzko.zip|zdrojaky.zip]]
  

Verzia zo dňa a času 14:20, 11. jún 2024

Záverečný projekt predmetu MIPS / LS2024 - Meno Priezvisko


Zadanie

Zostrojte a naprogramujte ovladanie škrtiacej klapky pomocou plynového pedálu.



Vývojová doska Arduino UNO R3

Literatúra:


Analýza a opis riešenia

Opíšte sem čo a ako ste spravili, ak treba, doplňte obrázkami...

RGB LED.

Nezabudnite doplniť schému zapojenia!

Schéma zapojenia LCD displeja.


Algoritmus a program

Algoritmus programu je.... 


#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdio.h>
#include "uart.h"

// #define F_CPU 16000000UL
// #define BAUD 9600

// Define button codes (example values, replace with actual values from your remote)
#define RED_BUTTON 0xFFA25D
#define GREEN_BUTTON 0xFF629D
#define BLUE_BUTTON 0xFFE21D
#define OFF_BUTTON 0xFF22DD
#define IRLED PD2

#define toggleBIT(reg, bit) ((reg) ^=  (1 << (bit))) //PREPNUTIE STAVU
#define setBIT(reg, bit) ((reg) |= (1 << (bit))) //JEDNA    
#define clearBIT(reg, bit) ((reg) &= ~(1 << (bit))) //NULAs

volatile uint32_t ir_code = 0;
volatile uint8_t bit_count = 0;

void initIRReceiver(void);
void initRGBLED(void);
void setColor(uint8_t red, uint8_t green, uint8_t blue);
void handleIRCode(uint32_t code);

FILE mystdout = FDEV_SETUP_STREAM(uart_putc, NULL, _FDEV_SETUP_WRITE);


ISR(INT0_vect) {
    // Simple state machine to decode the IR signal
    static uint8_t last_edge = 0;
    uint8_t edge = (PIND & (1 << PIND2)) >> PIND2;
    uint16_t duration = TCNT1;
    TCNT1 = 0;

    if (edge == last_edge) return;
    last_edge = edge;

    if (duration > 10000) { // Header
        ir_code = 0;
        bit_count = 0;
    } else if (duration > 0 && duration < 100) { // Logical 0
        ir_code = 0xFFA25D ;
        bit_count++;
    } else if (duration > 100 && duration < 200) { // Logical 1
        ir_code = 0xFF629D;
        bit_count++;
    }
	else if (duration > 200 && duration < 300) { // Logical 1
        ir_code = 0xFFE21D;
        bit_count++;
    }

    if (bit_count >= 32) {
        handleIRCode(ir_code);
		printf("IR Code: %08lX\n",ir_code);
        ir_code = 0;
        bit_count = 0;
    }
}

void initIRReceiver(void) {
	clearBIT(PORTD,IRLED); 
	clearBIT(DDRD,IRLED);
	
	EICRA |= (1 << ISC00); // Any logical change on INT0 triggers interrupt
    EIMSK |= (1 << INT0);  // Enable external interrupt INT0

    // Timer1 initialization
    TCCR1B |= (1 << CS11); // Prescaler 8
    TCNT1 = 0;             // Initialize counter
}

void initRGBLED(void) {
    // Set PB1, PB2, and PB3 as output (PWM)
    DDRB |= (1 << PB1) | (1 << PB2) | (1 << PB3);

    // Setup Timer1 for Fast PWM mode on PB1 and PB2
    TCCR1A |= (1 << COM1A1) | (1 << COM1B1) | (1 << WGM11);
    TCCR1B |= (1 << WGM12) | (1 << WGM13);
    ICR1 = 255; // TOP value for 8-bit PWM

    // Setup Timer2 for Fast PWM mode on PB3
    TCCR2A |= (1 << COM2A1) | (1 << WGM20) | (1 << WGM21);
    TCCR2B |= (1 << CS21); // Prescaler 8
}

void setColor(uint8_t red, uint8_t green, uint8_t blue) {
    OCR1A = red;  // Set PWM value for PB1 (Red)
    OCR1B = green; // Set PWM value for PB2 (Green)
    OCR2A = blue;  // Set PWM value for PB3 (Blue)
}

void handleIRCode(uint32_t code) {
    switch(code) {
        case RED_BUTTON:
            printf("Red Button Pressed\n");
            setColor(255, 0, 0); // Red
            break;
        case GREEN_BUTTON:
            printf("Green Button Pressed\n");
            setColor(0, 255, 0); // Green
            break;
        case BLUE_BUTTON:
            printf("Blue Button Pressed\n");
            setColor(0, 0, 255); // Blue
            break;
        case OFF_BUTTON:
            printf("Off Button Pressed\n");
            setColor(0, 0, 0); // Off
            break;
        default:
            printf("Unknown Button Pressed\n");
            break;
    }
}

int main(void) {
    uart_init();
	stdout = &mystdout;
	
    initIRReceiver();
    initRGBLED();
	
    printf("System Initialized\n");
	
	sei(); //globalne interupty
	
    while (1) 
	{
		printf("IR Code: %08lX\r",ir_code);
        
    }
}

#include <avr/io.h>
#include <util/delay.h>
#include "uart.h"

#define CLK  PD5  // CLK -> pin 5 portD.5
#define DIO  PD4  // DIO -> pin 4 portD.4

#define BIT_DELAY 100  // Delay 100ms

// Define for TM1637
#define TM1637_I2C_COMM1    0x40
#define TM1637_I2C_COMM2    0xC0
#define TM1637_I2C_COMM3    0x80

// Nastavenie cisiel na 7 segmentovom displeji
const uint8_t digitToSegment[] = {
    // XGFEDCBA
    0b00111111,    // 0
    0b00000110,    // 1
    0b01011011,    // 2
    0b01001111,    // 3
    0b01100110,    // 4
    0b01101101,    // 5
    0b01111101,    // 6
    0b00000111,    // 7
    0b01111111,    // 8
    0b01101111,    // 9
    0b01110111,    // A
    0b01111100,    // b
    0b00111001,    // C
    0b01011110,    // d
    0b01111001,    // E
    0b01110001     // F
};

uint8_t brightness = (0x7 & 0x7) | 0x08;

static const uint8_t minusSegments = 0b01000000;

int inicialize_bit(uint8_t byte){
    uint8_t data = byte;
    
    // 8 Data Bits
    for(uint8_t i = 0; i < 8; i++) {
        // CLK low
        set_bit(DDRD, CLK);
        clear_bit(PORTD, CLK);
        _delay_us(BIT_DELAY);
        
        // Set data bit
        if (data & 0x01){
            clear_bit(DDRD, DIO);  // Nastavenie DIO ako input
            set_bit(PORTD, DIO);   // DIO ako input pull-up on
        } else{
            set_bit(DDRD, DIO);    // Nastavenie DIO ako output
            clear_bit(PORTD, DIO); // Nastavenie DIO low
        }
        
        _delay_us(BIT_DELAY);
        
        // CLK high
        clear_bit(DDRD, CLK);  // Nastavenie CLK ako input
        set_bit(PORTD, CLK);   // CLK ako input pull-up on
        _delay_us(BIT_DELAY);
        data = data >> 1;
    }
    
    // Wait for acknowledge
    // CLK to zero
    set_bit(DDRD, CLK);     // Nastavenie CLK ako output
    clear_bit(PORTD, CLK);  // Nastavenie CLK low
    
    clear_bit(DDRD, DIO);   // Nastavenie DIO ako input
    set_bit(PORTD, DIO);    // DIO ako input pull-up on
    _delay_us(BIT_DELAY);
    
    // CLK to high
    clear_bit(DDRD, CLK);   // Nastavenie CLK ako input
    set_bit(PORTD, CLK);    // Nastavenie CLK high
    _delay_us(BIT_DELAY);
    uint8_t ack = !bit_is_clear(PIND, DIO);
    if (ack == 0)
        set_bit(DDRD, DIO);  // Nastavenie DIO ako output
    clear_bit(PORTD, DIO);  // Nastavenie DIO low
    
    _delay_us(BIT_DELAY);
    set_bit(DDRD, CLK);    // Nastavenie CLK ako output
    clear_bit(PORTD, CLK); // Nastavenie CLK low
    _delay_us(BIT_DELAY);
    
    return ack;
}


void comunication_start(){
    set_bit(DDRD, DIO);    // Nastavenie DIO ako output
    clear_bit(PORTD, DIO); // Nastavenie DIO ako output
    _delay_us(BIT_DELAY);
}

void comunication_stop(){
    set_bit(DDRD, DIO);    // Nastavenie DIO ako output
    clear_bit(PORTD, DIO); // Nastavenie DIO ako output
    _delay_us(BIT_DELAY);
    
    clear_bit(DDRD, CLK);  // Nastavenie CLK ako input
    set_bit(PORTD, CLK);   // CLK ako input pull-up on
    _delay_us(BIT_DELAY);
    
    clear_bit(DDRD, DIO);  // Nastavenie DIO ako input
    set_bit(PORTD, DIO);   // DIO ako input pull-up on
    _delay_us(BIT_DELAY);
}


void displayShowDots(uint8_t dots, uint8_t* digits){
    for(int i = 0; i < 4; ++i)
    {
        digits[i] |= (dots & 0x80);
        dots <<= 1;
    }
}


// Funkcia na zobrazenie cisla
void display_middle_dots(int num, uint8_t dots, const int leading_zero, uint8_t length, uint8_t pos){
    display_number(num < 0? -10 : 10, num < 0? -num : num, dots, leading_zero, length, pos);
}

// Funkcia na zobrazenie cisla v danom zaklade
void display_number(int8_t base, uint16_t num, uint8_t dots, const int leading_zero, uint8_t length, uint8_t pos)
{
    int negative = 0; // False
    if (base < 0) {
        base = -base;
        negative = 1; // True
    }
    
    uint8_t digits[4];
    
    if (num == 0 && !leading_zero) {
        for(uint8_t i = 0; i < (length-1); i++)
            digits[i] = 0;
        digits[length-1] = digitToSegment[0 & 0x0f];;
    }
    else {
        for(int i = length-1; i >= 0; --i)
        {
            uint8_t digit = num % base;
            
            if (digit == 0 && num == 0 && leading_zero == 0)
                digits[i] = 0;
            else
                digits[i] = digitToSegment[digit & 0x0f];;
            
            if (digit == 0 && num == 0 && negative) {
                digits[i] = minusSegments;
                negative = 0;
            }
            
            num /= base;
        }
    }
    
    if(dots != 0)
    {
        displayShowDots(dots, digits);
    }
    
    set_segments(digits, length, pos);
}

// Funkcia na zobrazenie cisla s default nastaveniami
void display_number_segment(int num, const int leading_zero, uint8_t length, uint8_t pos){
    display_middle_dots(num,  0x40, leading_zero, length, pos);
}

void set_segments(const uint8_t segments[], uint8_t length, uint8_t pos){
    // Zapis COMM1
    comunication_start();
    inicialize_bit(TM1637_I2C_COMM1);
    comunication_stop();
    
    // Zapis COMM2 + prvu cislicu adresy
    comunication_start();
    inicialize_bit(TM1637_I2C_COMM2 + (pos & 0x03));
    
    // Zapis datove bajty
    for (uint8_t k=0; k < length; k++)
        inicialize_bit(segments[k]);
    
    comunication_stop();
    
    // Zapis COMM3 + brightness
    comunication_start();
    inicialize_bit(TM1637_I2C_COMM3 + (brightness & 0x0f));
    comunication_stop();
}

#define set_bit(ADDRESS,BIT) (ADDRESS |= (1<<BIT))
#define clear_bit(ADDRESS,BIT) (ADDRESS &= ~(1<<BIT))

#ifndef UART_H_
#define UART_H_

void comunication_start();
void comunication_stop();
void displayShowDots(uint8_t dots, uint8_t* digits);
int inicialize_bit(uint8_t byte);
void display_middle_dots(int num, uint8_t dots, const int leading_zero, uint8_t length, uint8_t pos);
void display_number(int8_t base, uint16_t num, uint8_t dots, const int leading_zero, uint8_t length, uint8_t pos);
void display_number_segment(int num, const int leading_zero, uint8_t length, uint8_t pos);
void set_segments(const uint8_t segments[], uint8_t length, uint8_t pos);


#endif /* UART_H_ */

Zdrojový kód: zdrojaky.zip

Overenie

Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia. Na konci uvádzame fotku záverečnej obrazovky pred resetom. Vypísaný je tu priemerný čas a najlepší čas.

Aplikácia.

Video:

Kľúčové slová 'Category', ktoré sú na konci stránky nemeňte.

Zdroj: „https://senzor.robotika.sk/sensorwiki/index.php?title=Jednoduchý_prijímač_diaľkového_IR_ovládania&oldid=16579“