Heren,

Ik probeer een ATTINY aan de praat te krijgen in C language, heb hier vroeger ook al eens in assembler mee gewerkt een lange tjd geleden. Nu wou ik graag gebruik maken van de uart via interrupt. Hier mijn code:


// TEST DIPSWITCH IN 22/10/2010
//PB0=1 ,PD6 = 2 --- PD2 = 6 FOR DIPWSWITCHES
#include <avr/io.h>
// The last character is a lower case &#8216;L&#8217; not a 1 (one)
//#define F_CPU 11059200
#include <util/delay.h>
#include <avr/interrupt.h>


//prototyping

unsigned char readdipswitch(void);
void init_uart(void);
ISR(USART_RX_vect);

unsigned char  charin = 0;
unsigned char  adres = 0;
unsigned char  data = 0;


int main (void)
{

//DDR = 0 is input 1 = output
// set PORTD for output
//DDRD = 0x00;   //PD0 EN PD1 OUTPUT
//PORTD = 0X00;	// ENABLE INTERNAL PULL UP
DDRB = 0x10;   //PB0 = INPUT
//PORTB = 0X01;	//ENABLE INTERNALL PULL UP

init_uart();

PORTB &= 0b111011111;

sei();		// enable all interrupts

	while(1) {
	
		adres = readdipswitch(); //adres van de kaart
		data = charin;

	}

return 1;
}

unsigned char readdipswitch(void){
	unsigned char dipswitch = 0 ,temp = 0;
	temp = ~PINB & 0X01; //BIT 0 DIPSWITCH = PB0
		if (temp > 0)
			dipswitch = dipswitch + 1;
		temp = ~PIND & 0b01000000; //BIT 1 DIPSWITCH = PD6
		if (temp > 0)
			dipswitch = dipswitch + 2;
		temp = ~PIND & 0b00100000; //bit 2 dipswitch = PD5
		if (temp > 0)
			dipswitch = dipswitch + 4;
		temp = ~PIND & 0b00010000; //bit 3 dipswitch = PD4
		if (temp > 0)
			dipswitch = dipswitch + 8;
		temp = ~PIND & 0b00001000; //bit 4 = PD3
		if (temp > 0)
			dipswitch = dipswitch + 16;
		temp = ~PIND & 0b00000100; //bit 5 = PD2
		if (temp > 0)
			dipswitch = dipswitch + 32;
		return dipswitch;
}

void init_uart(void){
	//set usart baud rate register 
	UBRRL = 71; //9600 BAUD bij clock 11,0592 Mhz
	
	//set control and status register A 
	//UCRSA = std;
	
	//set control and status register B
	UCSRB = 0b10010000; /* bit 7 = RX complete interrupt enable
	bit 4 = receiver enable*/
	
	//set control and status register C
	UCSRC = 0b00000110;//8bit

}

ISR(USART_RX_vect) {
	//update();
	charin = UDR;
}

in charin zou dus volgens mij het ontvangen karakter moeten komen, maar ik krijg hier nonsens in. Toch reageert de interrupt receive wanneer ik van de pc een karakter doorstuur via een terminal.

Kan iemand mij op weg helpen?

[Bericht gewijzigd door Henry S. op (0%)]

Maak alle variabelen, die in een ISR bewerkt worden, volatile. Zo, dus:


volatile unsigned char charin = 0;

Verder is de UART-initialisatie OK. Ik neem aan, dat de AVR op een kristal draait? Dat zou goed moeten gaan.

draait inderdaad op kristal

met deze aanpassing geen resultaat.

Ik gebruik een ATTINY2313 en heb een MK2 debugger en werk in AVRSTudio

Nog iemand tips?

Voor een ATtint2313 gebruik ik deze init-code:


#define F_CPU 20000000UL
#define BAUD 9600UL

void uart_init(void)
{
    UCSRB = _BV(TXEN) | _BV(RXEN) | _BV(RXCIE);			// enable tx/rx and interrupt on rx
    UCSRC = _BV(UCSZ1) | _BV(UCSZ0);				// Set frame format: 8N1
    UBRRH = 0;							// set baudrate
    UBRRL = (F_CPU / (16 * BAUD)) - 1;
}

Je wil zelf niets versturen, dus is _BV(TXEN) overbodig. En je Avr draait op een lagere klokfrequentie. Maar verder zie ik weinig verschil met jouw code.

Kijk eens naar de bits in UCRSA. FE, DOR en UPE kunnen je vertellen wat er misging.
In welke mate verschillen de ontvangen karakters van hetgeen je verzonden hebt? Steeds dezelfde afwijking, of gewoon rommel waar je niet mee aan kunt?

Ik probeer nu gewoon te starten met het volgende. Gewoon een constant uitzenden op de TX. Hier kan ik ook al niets detecteren van signaal met de scoop. ATTINY2313 al vervangen , dit schijnt het probleem niet te zijn. Nog iemand ideeen?

Volgende code voor het zenden :

#include <avr/io.h>
// The last character is a lower case ‘L’ not a 1 (one)
//#define F_CPU 11059200
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdio.h>

/* Prototypes */
void InitUART (unsigned char baudrate);

#define F_CPU 11059200UL
#define BAUD 9600UL

/* --------------------------------------------------------------
Main - program that recieves a character then transmits back the next character.
An example would be if you send in an A, the chip will return a B
---------------------------------------------------------------- */
int main (void)
{
// unsigned char i;
// unsigned char dat;
DDRB = 0X10;
PORTB = 0x10;
InitUART (71); /* Set the baudrate to*/

while(1){

printf("\n\rYabba Dabba Do");

}
}

/* Initialize UART */
void
InitUART (unsigned char baudrate)
{

UCSRB = _BV(TXEN) | _BV(RXEN) | _BV(RXCIE); // enable tx/rx and interrupt on rx
UCSRC = _BV(UCSZ1) | _BV(UCSZ0); // Set frame format: 8N1
UBRRH = 0; // set baudrate
UBRRL = (F_CPU / (16 * BAUD)) - 1;

}


printf("\n\rYabba Dabba Do");

Ik denk niet, dat print() zijn output zomaar naar de UART gaat sturen.

Ik gebruik dit:


void uart_sendchar(unsigned char c)
{
    loop_until_bit_is_set(UCSRA, UDRE);
    UDR = c;
}


// send string to the rs232
void uart_sendstr(char *s)
{
    while (*s) {
	uart_sendchar(*s);
	s++;
    }
}

Als je een nette blokgolf op de TX-pin wil zien, doe dan dit:


while(1) {
    uart_sendchar('U');
}

Om printf met de uart te gebruiken in GCC: zie het stdiodemo voorbeeld.