np :
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
// Parametry UART
#define BAUD 9600
#define MYUBRR ((16000000UL / 16 / BAUD) - 1) // Zakładamy domyślną częstotliwość 16 MHz
// Funkcja inicjalizacji UART
void uart_init(unsigned int ubrr) {
// Ustawienie prędkości transmisji
UBRR0H = (unsigned char)(ubrr >> 8);
UBRR0L = (unsigned char)ubrr;
// Włączenie transmisji i odbioru
UCSR0B = (1 << RXEN0) | (1 << TXEN0);
// Ustawienie ramki: 8 bitów danych, 1 bit stopu
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
}
// Funkcja wysyłająca pojedynczy znak przez UART
void uart_transmit(char data) {
while (!(UCSR0A & (1 << UDRE0))); // Czekaj na pusty bufor nadawczy
UDR0 = data; // Wyślij znak
}
// Funkcja wysyłająca ciąg znaków przez UART
void uart_print(const char *str) {
while (*str) {
uart_transmit(*str++);
}
}
// Funkcja wyświetlająca liczbę przez UART
void uart_print_number(int number) {
if (number == 0) {
uart_transmit('0');
return;
}
char buffer[10];
int i = 0;
if (number < 0) { // Obsługa liczb ujemnych
uart_transmit('-');
number = -number;
}
// Rozkład liczby na cyfry
while (number > 0) {
buffer[i++] = (number % 10) + '0'; // Pobranie ostatniej cyfry
number /= 10; // Usuń ostatnią cyfrę
}
// Wypisz cyfry w odwrotnej kolejności
while (i > 0) {
uart_transmit(buffer[--i]);
}
}
// Funkcja odwracająca liczbę rekurencyjnie
int reverse_recursive(int number, int result) {
if (number == 0) {
return result; // Warunek zakończenia
}
return reverse_recursive(number / 10, result * 10 + (number % 10));
}
// Wrapper dla funkcji rekurencyjnej
int reverse_number(int number) {
return reverse_recursive(number, 0);
}
int main(void) {
uart_init(MYUBRR); // Inicjalizacja UART
int a = 1234; // Liczba do odwrócenia
// Główna pętla programu
while (1) {
uart_print("Original: ");
uart_print_number(a);
uart_print("\nReversed: ");
uart_print_number(reverse_number(a));
uart_print("\n");
_delay_ms(2000); // Odczekaj 2 sekundy
}
return 0;
}[/syntax]
resztę sobie dostosuj
ew mozna bardziej skomplikować sprawę np :
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <string.h>
// Funkcja inicjalizacji UART
void uart_init(unsigned int ubrr) {
UBRR0H = (unsigned char)(ubrr >> 8);
UBRR0L = (unsigned char)ubrr;
UCSR0B = (1 << RXEN0) | (1 << TXEN0);
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
}
// Funkcja wysyłająca pojedynczy znak przez UART
void uart_transmit(char data) {
while (!(UCSR0A & (1 << UDRE0)));
UDR0 = data;
}
// Funkcja wysyłająca ciąg znaków przez UART
void uart_print(const char *str) {
while (*str) {
uart_transmit(*str++);
}
}
// Funkcja wyświetlająca liczbę przez UART
void uart_print_number(int number) {
char buffer[12];
itoa(number, buffer, 10);
uart_print(buffer);
}
// Funkcja zamieniająca liczbę na reprezentację binarną w formie ciągu znaków
void to_binary(int number, char *buffer) {
int bit_index = 0;
unsigned int mask = 1 << (sizeof(int) * 8 - 1); // Maska na najstarszy bit
for (int i = 0; i < sizeof(int) * 8; i++) {
buffer[bit_index++] = (number & mask) ? '1' : '0';
number <<= 1; // Przesuwamy liczby o 1 bit w lewo
}
buffer[bit_index] = '\0';
}
// Funkcja odwracająca reprezentację binarną liczby
int reverse_binary(int number) {
unsigned int reversed = 0;
unsigned int size = sizeof(int) * 8; // Liczba bitów w liczbie całkowitej
for (unsigned int i = 0; i < size; i++) {
if (number & (1 << i)) { // Sprawdzenie, czy bit na pozycji i jest ustawiony
reversed |= (1 << (size - 1 - i)); // Ustawienie bitu w odwrotnej pozycji
}
}
return reversed;
}
// Główna funkcja odwracająca liczbę w reprezentacji dziesiętnej
int reverse_decimal(int number) {
int reversed = 0;
while (number > 0) {
reversed = reversed * 10 + (number % 10);
number /= 10;
}
return reversed;
}
int main(void) {
unsigned int ubrr = (16000000UL / 16 / 9600) - 1;
uart_init(ubrr);
int a = 1234; // Liczba do odwrócenia
char binary_buffer[33]; // Bufor na binarną reprezentację liczby
while (1) {
uart_print("Original decimal: ");
uart_print_number(a);
uart_print("\n");
uart_print("Reversed decimal: ");
uart_print_number(reverse_decimal(a));
uart_print("\n");
uart_print("Original binary: ");
to_binary(a, binary_buffer);
uart_print(binary_buffer);
uart_print("\n");
uart_print("Reversed binary as decimal: ");
uart_print_number(reverse_binary(a));
uart_print("\n");
_delay_ms(3000);
}
return 0;
}[/syntax]
ewentualnie możesz tak :
[syntax=asm]; Program odwracający liczbę dziesiętną i binarną w AVR assembler
.include "m328pdef.inc" ; Definicje dla ATmega328P
.def temp = r16
.def digit = r17
.def result = r18
.def input = r19
.def bit_reversed = r20
.equ BAUD = 9600
.equ MYUBRR = 16000000 / 16 / BAUD - 1
; Makro do ustawienia rejestru UBRR
.macro set_ubrr
ldi temp, high(MYUBRR)
out UBRR0H, temp
ldi temp, low(MYUBRR)
out UBRR0L, temp
.endmacro
; Inicjalizacja UART
uart_init:
set_ubrr
ldi temp, (1 << RXEN0) | (1 << TXEN0) ; Włącz odbiór i transmisję
out UCSR0B, temp
ldi temp, (1 << UCSZ01) | (1 << UCSZ00) ; 8-bitowa ramka
out UCSR0C, temp
ret
; Funkcja wysyłająca pojedynczy znak przez UART
uart_transmit:
push temp
wait_udre:
in temp, UCSR0A
sbrs temp, UDRE0 ; Czekaj aż UDRE0 będzie gotowy
rjmp wait_udre
out UDR0, r24 ; Wyślij znak
pop temp
ret
; Funkcja wysyłająca ciąg znaków
uart_print:
ldi ZL, low(pm(uart_string)) ; Adres ciągu w Z
ldi ZH, high(pm(uart_string))
uart_print_loop:
lpm temp, Z+
tst temp
breq uart_print_end
mov r24, temp
rcall uart_transmit
rjmp uart_print_loop
uart_print_end:
ret
; Funkcja odwracająca liczbę w systemie dziesiętnym
reverse_decimal:
clr result
reverse_loop:
cpi input, 0
breq reverse_done
mov temp, input
ldi digit, 10
div temp, digit ; Oblicz resztę
mul result, digit
add result, temp ; Dodaj cyfrę do wyniku
rjmp reverse_loop
reverse_done:
mov r24, result ; Wynik w r24
ret
; Funkcja odwracająca bity
reverse_binary:
clr bit_reversed
ldi temp, 8
reverse_binary_loop:
lsl input ; Przesuń bit w lewo
brcc reverse_binary_skip
ldi bit_reversed, 1
reverse_binary_skip:
ror bit_reversed ; Obróć bit w prawo
dec temp
brne reverse_binary_loop
mov r24, bit_reversed ; Wynik w r24
ret
; Sekcja danych
.data
uart_string:
.db "Hello, World!", 0
; Główna funkcja
main:
ldi temp, HIGH(RAMEND) ; Inicjalizacja stosu
out SPH, temp
ldi temp, LOW(RAMEND)
out SPL, temp
rcall uart_init ; Inicjalizacja UART
ldi input, 123 ; Liczba do odwrócenia
rcall reverse_decimal
rcall uart_print
ldi input, 0b10110110 ; Liczba binarna
rcall reverse_binary
rcall uart_print
loop:
rjmp loop[/syntax]
takie luźne rozważanie , miłej zabawy
Statystyki: Napisane przez SunRiver — 19 gru 2024, o 19:28
]]>
przynajmniej dla mnie jest to łamigłówka 