To initialize UART communication with the ATmega328P microcontroller in AVR C using the Arduino IDE, you can follow these steps:
Include the necessary header files:
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
Define the UART settings:
#define BAUDRATE 9600
#define BAUD_PRESCALLER (((F_CPU / (BAUDRATE * 16UL))) - 1)
Initialize UART by configuring the baud rate and other settings:
void uart_init() {
UBRR0H = (uint8_t)(BAUD_PRESCALLER >> 8);
UBRR0L = (uint8_t)(BAUD_PRESCALLER);
UCSR0B = (1 << RXEN0) | (1 << TXEN0); // Enable receiver and transmitter
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00); // 8-bit data format
}
Implement functions for transmitting and receiving data:
void uart_transmit(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // Wait for empty transmit buffer
UDR0 = data; // Put data into the buffer, sends the data
}
uint8_t uart_receive() {
while (!(UCSR0A & (1 << RXC0))); // Wait for data to be received
return UDR0; // Get and return received data from buffer
}
(Optional) Implement a function to transmit a string:
void uart_transmit_string(const char* str) {
for (size_t i = 0; str[i] != '\0'; ++i) {
uart_transmit(str[i]);
}
}
Finally, call the uart_init() function in your setup() function to initialize UART communication:
void setup() {
// Other setup code...
uart_init();
// More setup code...
}
Now, you can use uart_transmit() to send individual characters and uart_receive() to receive data. If needed, you can use uart_transmit_string() to send strings.
Note that the above code assumes you are using the default hardware UART (UART0) on the ATmega328P, and the UART pins (RX and TX) are connected to the corresponding pins on your Arduino board.
Make sure to set the correct BAUDRATE value based on your desired communication speed. Also, ensure that the F_CPU macro is defined with the correct clock frequency of your microcontroller.
Remember to include the necessary header files in your Arduino sketch and define the setup() and loop() functions as required for Arduino compatibility.
Please note that configuring the UART in this way bypasses some of the Arduino’s built-in serial functionality, so you won’t be able to use Serial.print() or Serial.read() with this setup.
Code for a demo program
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#define BAUDRATE 9600
#define BAUD_PRESCALLER (((F_CPU / (BAUDRATE * 16UL))) - 1)
void uart_init() {
UBRR0H = (uint8_t)(BAUD_PRESCALLER >> 8);
UBRR0L = (uint8_t)(BAUD_PRESCALLER);
UCSR0B = (1 << RXEN0) | (1 << TXEN0);
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
}
void uart_transmit(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0)));
UDR0 = data;
}
uint8_t uart_receive() {
while (!(UCSR0A & (1 << RXC0)));
return UDR0;
}
void uart_transmit_string(const char* str) {
for (size_t i = 0; str[i] != '\0'; ++i) {
uart_transmit(str[i]);
}
}
void setup() {
// Initialize UART
uart_init();
// Set PB5 (Arduino digital pin 13) as output
DDRB |= (1 << PB5);
}
void loop() {
// Read input from UART
uint8_t receivedData = uart_receive();
// Echo back received data
uart_transmit(receivedData);
// Toggle the built-in LED (PB5) on each received character
PORTB ^= (1 << PB5);
// Delay for a short period to observe the LED blink
_delay_ms(500);
}
In this demo program, the ATmega328P’s UART is initialized in the setup() function, and then in the loop() function, it continuously reads incoming data and sends it back (echo) over UART. Additionally, it toggles the built-in LED (PB5) on each received character, providing a visual indication.
Um die UART-Kommunikation mit dem ATmega328P-Mikrocontroller in AVR C mithilfe der Arduino IDE zu initialisieren, können Sie den folgenden Schritten folgen:
Fügen Sie die erforderlichen Header-Dateien hinzu:
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
Definieren Sie die UART-Einstellungen:
#define BAUDRATE 9600
#define BAUD_PRESCALLER (((F_CPU / (BAUDRATE * 16UL))) - 1)
Initialisieren Sie UART, indem Sie die Baudrate und andere Einstellungen konfigurieren:
void uart_init() {
UBRR0H = (uint8_t)(BAUD_PRESCALLER >> 8);
UBRR0L = (uint8_t)(BAUD_PRESCALLER);
UCSR0B = (1 << RXEN0) | (1 << TXEN0); // Empfänger und Sender aktivieren
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00); // 8-Bit-Datenformat
}
Implementieren Sie Funktionen zum Senden und Empfangen von Daten:
void uart_transmit(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // Auf leeren Sendepuffer warten
UDR0 = data; // Daten in den Puffer schreiben und senden
}
uint8_t uart_receive() {
while (!(UCSR0A & (1 << RXC0))); // Auf empfangene Daten warten
return UDR0; // Empfangene Daten aus dem Puffer lesen und zurückgeben
}
(Optional) Implementieren Sie eine Funktion zum Senden einer Zeichenkette:
void uart_transmit_string(const char* str) {
for (size_t i = 0; str[i] != '\0'; ++i) {
uart_transmit(str[i]);
}
}
Rufen Sie schließlich die Funktion uart_init() in Ihrer setup() Funktion auf, um die UART-Kommunikation zu initialisieren:
void setup() {
// Anderer Setup-Code...
uart_init();
// Weitere Setup-Code...
}
Jetzt können Sie uart_transmit() verwenden, um einzelne Zeichen zu senden, und uart_receive() zum Empfangen von Daten. Bei Bedarf können Sie uart_transmit_string() verwenden, um Zeichenketten zu senden.
Beachten Sie, dass der obige Code davon ausgeht, dass Sie die standardmäßige Hardware-UART (UART0) des ATmega328P verwenden und dass die UART-Pins (RX und TX) mit den entsprechenden Pins auf Ihrem Arduino-Board verbunden sind.
Stellen Sie sicher, dass Sie den korrekten BAUDRATE-Wert entsprechend Ihrer gewünschten Übertragungsgeschwindigkeit festlegen. Stellen Sie außerdem sicher, dass die F_CPU-Makrodefinition die richtige Taktgeschwindigkeit Ihres Mikrocontrollers enthält.
Vergessen Sie nicht, die erforderlichen Header-Dateien in Ihren Arduino-Sketch einzufügen und die setup() und loop() Funktionen gemäß den Anforderungen der Arduino-Kompatibilität zu definieren.
Bitte beachten Sie, dass durch die Konfiguration der UART auf diese Weise einige der integrierten seriellen Funktionen des Arduino umgangen werden. Sie können daher nicht Serial.print() oder Serial.read() mit dieser Konfiguration verwenden.
Code für ein Demo-Programm
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#define BAUDRATE 9600
#define BAUD_PRESCALLER (((F_CPU / (BAUDRATE * 16UL))) - 1)
void uart_init() {
UBRR0H = (uint8_t)(BAUD_PRESCALLER >> 8);
UBRR0L = (uint8_t)(BAUD_PRESCALLER);
UCSR0B = (1 << RXEN0) | (1 << TXEN0);
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
}
void uart_transmit(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0)));
UDR0 = data;
}
uint8_t uart_receive() {
while (!(UCSR0A & (1 << RXC0)));
return UDR0;
}
void uart_transmit_string(const char* str) {
for (size_t i = 0; str[i] != '\0'; ++i) {
uart_transmit(str[i]);
}
}
void setup() {
// UART initialisieren
uart_init();
// PB5 (Arduino digitaler Pin 13) als Ausgang festlegen
DDRB |= (1 << PB5);
}
void loop() {
// Eingabe von UART lesen
uint8_t receivedData = uart_receive();
// Empfangene Daten zurückschicken (Echo)
uart_transmit(receivedData);
// Die integrierte LED (PB5) bei jedem empfangenen Zeichen umschalten
PORTB ^= (1 << PB5);
// Eine kurze Verzögerung, um das Blinken der LED zu beobachten
_delay_ms(500);
}
In diesem Demo-Programm wird die UART des ATmega328P im setup() Funktion initialisiert. In der loop() Funktion liest es kontinuierlich eingehende Daten und sendet sie zurück (Echo) über UART. Darüber hinaus wird die integrierte LED (PB5) bei jedem empfangenen Zeichen umgeschaltet, um eine visuelle Anzeige zu bieten.
ATmega328P माइक्रोकंट्रोलर के साथ AVR C और Arduino IDE का उपयोग करके UART संचार को प्रारंभ करने के लिए, आप निम्नलिखित चरणों का पालन कर सकते हैं:
आवश्यक हैडर फ़ाइलें शामिल करें:
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
UART सेटिंग्स को परिभाषित करें:
#define BAUDRATE 9600
#define BAUD_PRESCALLER (((F_CPU / (BAUDRATE * 16UL))) - 1)
बॉडरेट और अन्य सेटिंग्स को कॉन्फ़िगर करके UART को प्रारंभ करें:
void uart_init() {
UBRR0H = (uint8_t)(BAUD_PRESCALLER >> 8);
UBRR0L = (uint8_t)(BAUD_PRESCALLER);
UCSR0B = (1 << RXEN0) | (1 << TXEN0); // प्राप्तकर्ता और प्रेषक को सक्षम करें
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00); // 8 बिट डेटा प्रारूप
}
डेटा भेजने और प्राप्त करने के लिए फ़ंक्शन को अमल में लाएं:
void uart_transmit(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0))); // खाली भेजने वाले बफ़र के लिए प्रतीक्षा करें
UDR0 = data; // डेटा बफ़र में डेटा डालें, डेटा भेजें
}
uint8_t uart_receive() {
while (!(UCSR0A & (1 << RXC0))); // डेटा प्राप्त होने की प्रतीक्षा करें
return UDR0; // बफ़र से प्राप्त और डेटा लौटाएं
}
(ऐच्छिक) स्ट्रिंग भेजने के लिए एक फ़ंक्शन को अमल में लाएं:
void uart_transmit_string(const char* str) {
for (size_t i =
0; str[i] != '\0'; ++i) {
uart_transmit(str[i]);
}
}
अंतिम रूप में, अपने सेटअप() फ़ंक्शन में uart_init() फ़ंक्शन को बुलाएं और UART संचार को प्रारंभ करें:
void setup() {
// अन्य सेटअप कोड...
uart_init();
// अधिक सेटअप कोड...
}
अब, आप uart_transmit() का उपयोग अक्षरों को भेजने के लिए कर सकते हैं और uart_receive() का उपयोग डेटा प्राप्त करने के लिए कर सकते हैं। आवश्यकता होने पर, आप uart_transmit_string() का उपयोग स्ट्रिंग भेजने के लिए कर सकते हैं।
ध्यान दें कि ऊपर का कोड मानता है कि आप ATmega328P पर डिफ़ॉल्ट हार्डवेयर UART (UART0) का उपयोग कर रहे हैं, और UART पिन (RX और TX) आपके Arduino बोर्ड पर संबंधित पिनों से कनेक्ट हैं।
अपनी Arduino स्केच में आवश्यक हैडर फ़ाइलें शामिल करने और Arduino संगतता के लिए सेटअप() और लूप() फ़ंक्शन को परिभाषित करने के लिए याद रखें।
कृपया ध्यान दें कि इस तरीके से UART को कॉन्फ़िगर करने से अर्डुइनो के कुछ निर्मित सीरियल कार्यक्षमता का बाहर जाना होता है, इसलिए इस सेटअप के साथ Serial.print() या Serial.read() का उपयोग नहीं कर सकेंगे।
डेमो प्रोग्राम के लिए कोड
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#define BAUDRATE 9600
#define BAUD_PRESCALLER (((F_CPU / (BAUDRATE * 16UL))) - 1)
void uart_init() {
UBRR0H = (uint8_t)(BAUD_PRESCALLER >> 8);
UBRR0L = (uint8_t)(BAUD_PRESCALLER);
UCSR0B = (1 << RXEN0) | (1 << TXEN0);
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
}
void uart_transmit(uint8_t data) {
while (!(UCSR0A & (1 << UDRE0)));
UDR0 = data;
}
uint8_t uart_receive() {
while (!(UCSR0A & (1 << RXC0)));
return UDR0;
}
void uart_transmit_string(const char* str) {
for (size_t i = 0; str[i] != '\0'; ++i) {
uart_transmit(str[i]);
}
}
void setup() {
// UART को प्रारंभ करें
uart_init();
// PB5 (Arduino डिजिटल पिन 13) को आउटपुट के रूप में सेट करें
DDRB |= (1 << PB5);
}
void loop() {
// UART से इनपुट पढ़ें
uint8_t receivedData = uart_receive();
// प्राप्त डेटा को वापस भेजें (इको)
uart_transmit(receivedData);
// प्राप्त वर्णकों पर बिल्ट-इन LED (PB5) को टॉगल करें, यह दिखाने के लिए
PORTB ^= (1 << PB5);
// LED ब्लिंक को देखने के लिए थोड़ी सी देरी के लिए विलंब करें
_delay_ms(500);
}
इस डेमो प्रोग्राम में, ATmega328P का UART सेटअप() फ़ंक्शन में प्रारंभित होता है, और फिर लूप() फ़ंक्शन में, यह निरंतर आने वाले डेटा को पढ़ता है और उसे वापस (इको) UART के माध्यम से भेजता है। इसके अलावा, यह प्राप्त प्रत्येक आंकड़े पर बिल्ट-इन LED (PB5) को टॉगल करता है, जिससे एक लैंप एफेक्ट प्रदर्शित होता है।
