Re: Przerwanie USART nie zostaje wywoływane nigdy.

2017-01-24T17:00:37+01:00

Quote:

Teraz kiedy wysyłam bit do uC to przestaje się wykonywać główna pętla (pierwszy post).

Dlatego że teraz wymyślasz już totalnie przedziwne rzeczy - czyli wewnątrz przerwania próbujesz wysłać znak a procedura czeka na zakończenie przerwania które się jeszcze nie zakończyło - i wąż zjada własny ogon ....

Do wysyłania użyj albo w sposób blokujący samego transmitbyte albo jeśli chcesz na przerwaniach .... hmmm to hmmm ta biblioteka w ogóle tego nie uwzględnia. Ty zaś próbujesz robić to na zasadzie - "a może się tak uda, albo tak .... .... bez jak na razie widzę wiedzy jak w ogóle działa system przerwań procka" ... i to powoduje że błądzisz

Statystyki: Napisane przez mirekk36 — 24 sty 2017, o 17:00

Re: Przerwanie USART nie zostaje wywoływane nigdy.

2017-01-24T15:32:33+01:00

[syntax=c]ISR(USART_TX_vect)
{
transmitByte(128);
}
// ----[/syntax]

Teraz kiedy wysyłam bit do uC to przestaje się wykonywać główna pętla (pierwszy post).

Statystyki: Napisane przez Trebuh — 24 sty 2017, o 15:32

Re: Przerwanie USART nie zostaje wywoływane nigdy.

2017-01-24T13:39:02+01:00

Oczywiście ją kupię tylko teraz mam inne wydatki.

Statystyki: Napisane przez Trebuh — 24 sty 2017, o 13:39

Re: Przerwanie USART nie zostaje wywoływane nigdy.

2017-01-24T13:19:03+01:00

Ja ze swojej strony polecę tę książkę:

http://atnel.pl/mikrokontrolery-avr-jezyk-c.html

będziesz wiedział dokładnie co robisz i o co chodzi z obsługą UART i to w oparciu o bufory cykliczne

Statystyki: Napisane przez mirekk36 — 24 sty 2017, o 13:19

Re: Przerwanie USART nie zostaje wywoływane nigdy.

2017-01-24T13:14:42+01:00

Ustawiłem ten bit (w initUSART):
[syntax=c]UCSR0B = (1 << TXEN0) | (1 << RXEN0) | (1 << RXCIE0);[/syntax]
i kod odpowiedzialny za przerwanie:
[syntax=c]ISR(USART_RX_vect)
{
transmitByte(128);
}[/syntax]

Teraz dostaję tylko przerwanie nawet kiedy nic nie wysyłam.

Statystyki: Napisane przez Trebuh — 24 sty 2017, o 13:14

Re: Przerwanie USART nie zostaje wywoływane nigdy.

2017-01-24T06:31:34+01:00

Nazwę przerwania masz źle. Powinno być ISR(USART_RX_vect).

Jeśli mikrokontroler ma wchodzić do procedury obsługi przerwania ISR(USART_RX_vect), to powinien być ustawiony bit RXCIE0 w rejestrze UCSR0B, a nie zauważyłem w kodzie, żebyś go ustawiał.

Statystyki: Napisane przez andrews — 24 sty 2017, o 06:31

Przerwanie USART nie zostaje wywoływane nigdy.

2017-01-24T00:29:47+01:00

Cześć,
mam taki kod main.c
[syntax=c]#include
#include
#include
#include "USART.h"

ISR(USART_RXC)
{
transmitByte(77);
}
// -------- Funkcje --------- //
static inline void initFreerunningADC(void) {
ADMUX |= (1 << REFS0); /* napięcie referencyjne to AVCC */
ADCSRA |= (0 << ADPS2) | (1 << ADPS1) | (0 << ADPS0); /* preskaler zegara konwertera /4 */

ADMUX |= (1 << ADLAR); /* wyrównaj wynik do lewej, zwracaj tylko 8 bitów */

ADCSRA |= (1 << ADEN); /* włącz konwerter AC */
ADCSRA |= (1 << ADATE); /* włącz tryb ciągły */
ADCSRA |= (1 << ADSC); /* uruchom pierwszą konwersję */
}
void Delay_ms(int n) { //nie mozna uzyc zmiennej do delay (jako argument) cos jak tab[var] w c++
while (n--) {
_delay_ms(1);
}
}

int main(void) {
initUSART();
initFreerunningADC();
sei();
uint8_t delay = 20;
while (1)
{
transmitByte(ADCH);
Delay_ms(delay);
}
return (0);
}[/syntax]

USART.c
[syntax=c]/*
Quick and dirty functions that make serial communications work.

Note that receiveByte() blocks -- it sits and waits _forever_ for
a byte to come in. If you're doing anything that's more interesting,
you'll want to implement this with interrupts.

initUSART requires BAUDRATE to be defined in order to calculate
the bit-rate multiplier. 9600 is a reasonable default.

May not work with some of the older chips:
Tiny2313, Mega8, Mega16, Mega32 have different pin macros
If you're using these chips, see (e.g.) iom8.h for how it's done.
These old chips don't specify UDR0 vs UDR1.
Correspondingly, the macros will just be defined as UDR.
*/

#include
#include "USART.h"
#include

void initUSART(void) { /* requires BAUD */
UBRR0H = UBRRH_VALUE; /* defined in setbaud.h */
UBRR0L = UBRRL_VALUE;
#if USE_2X
UCSR0A |= (1 << U2X0);
#else
UCSR0A &= ~(1 << U2X0);
#endif
/* Enable USART transmitter/receiver */
UCSR0B = (1 << TXEN0) | (1 << RXEN0);
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00); /* 8 data bits, 1 stop bit */
}

void transmitByte(uint8_t data) {
/* Wait for empty transmit buffer */
loop_until_bit_is_set(UCSR0A, UDRE0);
UDR0 = data; /* send data */
}

uint8_t receiveByte(void) {
loop_until_bit_is_set(UCSR0A, RXC0); /* Wait for incoming data */
return UDR0; /* return register value */
}

/* Here are a bunch of useful printing commands */

void printString(const char myString[]) {
uint8_t i = 0;
while (myString[i]) {
transmitByte(myString[i]);
i++;
}
}

void readString(char myString[], uint8_t maxLength) {
char response;
uint8_t i;
i = 0;
while (i < (maxLength - 1)) { /* prevent over-runs */
response = receiveByte();
transmitByte(response); /* echo */
if (response == '\r') { /* enter marks the end */
break;
}
else {
myString[i] = response; /* add in a letter */
i++;
}
}
myString[i] = 0; /* terminal NULL character */
}

void printByte(uint8_t byte) {
/* Converts a byte to a string of decimal text, sends it */
transmitByte('0' + (byte / 100)); /* Hundreds */
transmitByte('0' + ((byte / 10) % 10)); /* Tens */
transmitByte('0' + (byte % 10)); /* Ones */
}

void printWord(uint16_t word) {
transmitByte('0' + (word / 10000)); /* Ten-thousands */
transmitByte('0' + ((word / 1000) % 10)); /* Thousands */
transmitByte('0' + ((word / 100) % 10)); /* Hundreds */
transmitByte('0' + ((word / 10) % 10)); /* Tens */
transmitByte('0' + (word % 10)); /* Ones */
}

void printBinaryByte(uint8_t byte) {
/* Prints out a byte as a series of 1's and 0's */
uint8_t bit;
for (bit = 7; bit < 255; bit--) {
if (bit_is_set(byte, bit))
transmitByte('1');
else
transmitByte('0');
}
}

char nibbleToHexCharacter(uint8_t nibble) {
/* Converts 4 bits into hexadecimal */
if (nibble < 10) {
return ('0' + nibble);
}
else {
return ('A' + nibble - 10);
}
}

void printHexByte(uint8_t byte) {
/* Prints a byte as its hexadecimal equivalent */
uint8_t nibble;
nibble = (byte & 0b11110000) >> 4;
transmitByte(nibbleToHexCharacter(nibble));
nibble = byte & 0b00001111;
transmitByte(nibbleToHexCharacter(nibble));
}

uint8_t getNumber(void) {
// Gets a numerical 0-255 from the serial port.
// Converts from string to number.
char hundreds = '0';
char tens = '0';
char ones = '0';
char thisChar = '0';
do { /* shift over */
hundreds = tens;
tens = ones;
ones = thisChar;
thisChar = receiveByte(); /* get a new character */
transmitByte(thisChar); /* echo */
} while (thisChar != '\r'); /* until type return */
return (100 * (hundreds - '0') + 10 * (tens - '0') + ones - '0');
}[/syntax]
USART.h
[syntax=c]/* Functions to initialize, send, receive over USART

initUSART requires BAUD to be defined in order to calculate
the bit-rate multiplier.
*/

#ifndef BAUD /* if not defined in Makefile... */
#define BAUD 9600 /* set a safe default baud rate */
#endif

/* These are defined for convenience */
#define USART_HAS_DATA bit_is_set(UCSR0A, RXC0)
#define USART_READY bit_is_set(UCSR0A, UDRE0)

/* Takes the defined BAUD and F_CPU,
calculates the bit-clock multiplier,
and configures the hardware USART */
void initUSART(void);

/* Blocking transmit and receive functions.
When you call receiveByte() your program will hang until
data comes through. We'll improve on this later. */
void transmitByte(uint8_t data);
uint8_t receiveByte(void);

void printString(const char myString[]);
/* Utility function to transmit an entire string from RAM */
void readString(char myString[], uint8_t maxLength);
/* Define a string variable, pass it to this function
The string will contain whatever you typed over serial */

void printByte(uint8_t byte);
/* Prints a byte out as its 3-digit ascii equivalent */
void printWord(uint16_t word);
/* Prints a word (16-bits) out as its 5-digit ascii equivalent */

void printBinaryByte(uint8_t byte);
/* Prints a byte out in 1s and 0s */
char nibbleToHex(uint8_t nibble);
void printHexByte(uint8_t byte);
/* Prints a byte out in hexadecimal */
uint8_t getNumber(void);
/* takes in up to three ascii digits,
converts them to a byte when press enter */[/syntax]

kod USART.c i USART.h pochodzi z książki "Programowanie układów AVR dla praktyków". Uruchomiłem globalne przerwania sei() ale nie widzę żadnego rezultatu (nie odbieram tego co powinno się wysłać podczas przerwania). Programuję na układzie ATMEGA328P. Co może być przyczyną tego?

Statystyki: Napisane przez Trebuh — 24 sty 2017, o 00:29

ATNEL tech-forum

Re: Przerwanie USART nie zostaje wywoływane nigdy.

Re: Przerwanie USART nie zostaje wywoływane nigdy.

Re: Przerwanie USART nie zostaje wywoływane nigdy.

Re: Przerwanie USART nie zostaje wywoływane nigdy.

Re: Przerwanie USART nie zostaje wywoływane nigdy.

Re: Przerwanie USART nie zostaje wywoływane nigdy.

Przerwanie USART nie zostaje wywoływane nigdy.