C und volatile

gfcwfzkm · 13. Februar 2015, 14:30

Hallo @ all,

ich habe da ein gewisses Problem in C bzw. eine Frage. Und zwar bekomme ich
ständig eine Warnung wo ich nicht weiss wie ich diese lösen kann.

C-Quellcode

void ringbuffer_Init(volatile ringbuffer8_t* inst)
{
inst->readPointer = &inst->Buffer[0]; //Warnung bei &inst....
inst->writePointer = &inst->Buffer[0]; //Warnung bei &inst....
inst->BufElements = 0;
}

Das Problem ist, das ich volatile benötige. da jedoch &inst nicht mitmacht, wird das "wegoptimiert" wodurch mein Programm wiederum nicht mehr korrekt geht.

Hat da jemand schon Erfahrung damit gemacht bzw. eine Ahnung was ich hinzufügen müsste?

Thx

~gfc

RodFromGermany · 13. Februar 2015, 14:37

gfcwfzkm schrieb:

eine Warnung

Welche?
Kannst Du ein Code-Snippet posten, das kompilierbar ist und diesen Effekt reproduziert?

Thunderbolt · 13. Februar 2015, 14:53

Moin,

mit & holst du dir die Adresse der Variable. * ist der Dereferenzieurngsoperator. Bei Strukturen kann auch -> angewendet werden, um die Adresse zu dereferenzieren.
Also wäre dein Code z. B. inst->readPointer = inst->Buffer[0];

RodFromGermany · 13. Februar 2015, 14:58

Thunderbolt schrieb:

dein Code

Nö.

C-Quellcode

inst->readPointer = inst->Buffer;

jvbsl · 13. Februar 2015, 15:08

Die Lösung wurde bereits gepostet.

Aber um das mal Allgemein klar zu machen, volatile wirst du wohl nie brauchen. Das ist eher für ganz spezielle Dinge:
z.B. setzen eines Registers mit sich selbst um einen Wechsel in den UserMode zu erzwingen - würde natürlich wegoptimert werden, weil es dasselbe ist wie x=x, aber man braucht es, weil im Hintergrund tatsächlich noch etwas anderes passiert. Das ist eigt. mal eines der wenigen Beispiele und zwar aus dem Bereich der OS Programmierung->nah an der Hardware.
Was anderes das mir vlt. noch einfällt ist, falls du einen Algorithmus voll und ganz für deine Hardware/speziellen Fall optimiert hast und du nicht willst, dass die Compiler-Optiierung dadrinne rumpfuscht. Aber i.d.r. sind die Optimierungen ziemlich gut und ergibt nur Sinn die zu verhindern, wenn du mit Assembler rumpfuschst/eine spezielle Funktion anders optimieren willst wie den rest...

gfcwfzkm · 13. Februar 2015, 15:46

hmm. Hätte da noch ein Problem zu volatile und low-level.
Und zwar bin ich an einer Bibliothek für die Serielle Schnittstelle dahinter. Dort verwende ich einen Ring-Buffer. Aber genau dieser macht Probleme.
Wenn ich eine Zeichenkette senden will, speichert er diese in einem Ringbuffer und startet die Interrupt-Gesteuerte Übertragung. Im Interrupt holt er sich nach und nach die Zeichen vom Buffer und sendet diese.
Jedoch setzten teilweise Zeichen aus oder ganze Wörter werden doppelt gesendet. Soweit ich gelesen habe sollte volatile doch genau das verhindern, oder?

Spoiler anzeigen

C-Quellcode

/*
* GD_UART.c
*
* Created: 25.08.2014 13:34:12
* Author: gespa1
*/
#include "UART.H"
#include <avr/interrupt.h>
#if defined(UDR0)
#define UDR_0 UDR0
#define UCSRA_0 UCSR0A
#define U2X_0 U2X0
#define UBRRH_0 UBRR0H
#define UBRRL_0 UBRR0L
#define UCSRB_0 UCSR0B
#define UCSRC_0 UCSR0C
#define UCSZ0_0 UCSZ00
#define UCSZ1_0 UCSZ01
#define USBS_0 USBS0
#define RXC_0 RXC0
#define UDRE_0 UDRE0
#define RXEN_0 RXEN0
#define TXEN_0 TXEN0
#define RXCIE_0 RXCIE0
#define TXCIE_0 UDRIE0
#define RX_INTERRUPT USART0_RX_vect
#define TX_INTERRUPT USART0_UDRE_vect
#elif defined(UDR)
#define UDR_0 UDR
#define UCSRA_0 UCSRA
#define U2X_0 U2X
#define UBRRH_0 UBRRH
#define UBRRL_0 UBRRL
#define UCSRB_0 UCSRB
#define UCSRC_0 UCSRC
#define UCSZ0_0 UCSZ0
#define UCSZ1_0 UCSZ1
#define USBS_0 USBS
#define RXC_0 RXC
#define UDRE_0 UDRE
#define RXEN_0 RXEN
#define TXEN_0 TXEN
#define RXCIE_0 RXCIE
#define TXCIE_0 UDRIE
#define RX_INTERRUPT USART_RX_vect
#define TX_INTERRUPT USART_UDRE_vect
#endif
/* Rx/Tx Ringbuffer (FIFO) */
typedef struct ringbuffer8_t
{
unsigned char Buffer[UART_BUFLENGTH];
unsigned char BufElements;
unsigned char *readPointer;
unsigned char *writePointer;
} ringbuffer8_t;
static unsigned char UART0_Rx_Error;
static volatile ringbuffer8_t UART0_Rx_Buffer;
static volatile ringbuffer8_t UART0_Tx_Buffer;
#if defined(UDR1)
static volatile ringbuffer8_t UART1_Rx_Buffer;
static volatile ringbuffer8_t UART1_Tx_Buffer;
static unsigned char UART1_Rx_Error;
#endif
/* Speichervariablen für Interrupt-Funktionen*/
void (*uart_user_onReceive0)(unsigned int);
void (*uart_user_onTransmit0)(void);
void (*uart_user_onBufferFull0)(void);
#if defined(UDR1)
void (*uart_user_onReceive1)(unsigned int);
void (*uart_user_onBufferFull1)(void);
void (*uart_user_onTransmit1)(void);
#endif
static uint8_t uart_INT = 0;
void ringbuffer_Init(volatile ringbuffer8_t* inst)
{
inst->readPointer = (volatile)&inst->Buffer[0];
inst->writePointer = (volatile)&inst->Buffer[0];
inst->BufElements = 0;
}
unsigned char ringbuffer_Read(volatile ringbuffer8_t* inst)
{
inst->BufElements--;
if(inst->readPointer > (volatile)&inst->Buffer[UART_BUFLENGTH-1])
{
inst->readPointer = (volatile)&inst->Buffer[0];
}
return *inst->readPointer++;
}
void ringbuffer_Write(volatile ringbuffer8_t* inst, unsigned char data)
{
inst->BufElements++;
if(inst->writePointer > (volatile)&inst->Buffer[UART_BUFLENGTH-1])
{
inst->writePointer = (volatile)&inst->Buffer[0];
}
*inst->writePointer++ = data;
}
unsigned char uart_init(uint16_t BAUD)
{
if (BAUD & 0x8000)
{
UCSRA_0 |= (1<<U2X_0);
BAUD &=~0x8000;
}
// Baudrate setzten
UBRRH_0 = (unsigned char)(BAUD>>8);
UBRRL_0 = (unsigned char)BAUD;
// Empfänger und sender aktivieren sowie Interrupts einstellen
UCSRB_0 = (1<<TXEN_0) | (1<<RXEN_0) | (1<<RXCIE_0);
UCSRC_0 = (1<<UCSZ0_0) | (1<<UCSZ1_0);
return NO_ERROR;
}
unsigned char uart_off(void)
{
UCSRB_0 = 0x00;
UCSRC_0 = 0x00;
uart_INT = 0;
return NO_ERROR;
}
/* Gibt den akuellsten Wert
vom Buffer zurück */
unsigned int uart_getc(void)
{
unsigned char _error = NO_ERROR;
struct ringbuffer8_t tempbuf = UART0_Rx_Buffer;
if(tempbuf.BufElements==0) return (NO_DATA_RECEIVED << 8);
if (!(uart_INT & (1<<0))) _error = UART0_Rx_Error;
UART0_Rx_Error = NO_ERROR;
return ((_error << 8) & ringbuffer_Read(&tempbuf));
}
unsigned char uart_putc(char data)
{
UCSRB_0 &=~ (1<<TXCIE_0);
if(UART0_Tx_Buffer.BufElements>=UART_BUFLENGTH)
{
return (BUFFER_FULL);
}
ringbuffer_Write(&UART0_Tx_Buffer, data);
UCSRB_0 |= (1<<TXCIE_0);
return (NO_ERROR);
}
void uart_putsc(char data)
{
if(UART0_Tx_Buffer.BufElements>=UART_BUFLENGTH)
{
return (BUFFER_FULL);
}
ringbuffer_Write(&UART0_Tx_Buffer, data);
}
unsigned char uart_puts(unsigned char *data, unsigned char nlength)
{
UCSRB_0 &=~ (1<<TXCIE_0);
if((UART0_Tx_Buffer.BufElements+nlength)>=UART_BUFLENGTH)
{
return (BUFFER_FULL);
}
while (*data)
{
uart_putsc(*data++);
}
UCSRB_0 |= (1<<TXCIE_0);
return (NO_ERROR);
}
void uart_onReceive(void (*function)(unsigned int))
{
uart_user_onReceive0 = function;
uart_INT |= (1<<0);
}
void uart_onRxBufferFull(void (*function)(void))
{
uart_user_onBufferFull0 = function;
uart_INT |= (1<<2);
}
void uart_onTransmit(void (*function)(void))
{
uart_user_onTransmit0 = function;
uart_INT |= (1<<1);
}
ISR(RX_INTERRUPT)
{
if(uart_INT & (1<<0)) uart_user_onReceive0(uart_getc);
if(UART0_Rx_Buffer.BufElements>=UART_BUFLENGTH)
{
UART0_Rx_Error = BUFFER_FULL;
if(uart_INT & (1<<2)) uart_user_onBufferFull0();
}
else
{
ringbuffer_Write(&UART0_Rx_Buffer, UDR_0);
}
}
/* UART Transmit Interrupt
Sendet zusätzlich ein Interrupt an die user-Funktion
wenn alle Daten gesendet wurden */
ISR(TX_INTERRUPT)
{
UART0_Tx_Buffer.readPointer = UART0_Tx_Buffer.readPointer;
if(UART0_Tx_Buffer.BufElements==0)
{
UCSRB_0 &=~ (1<<TXCIE_0);
if(uart_INT & (1<<1)) uart_user_onTransmit0();
}
else
{
UDR_0 = ringbuffer_Read(&UART0_Tx_Buffer);
}
}
#if defined(UDR1)
unsigned char uart_init1(uint16_t BAUD)
{
if (BAUD & 0x8000)
{
UCSR1A |= (1<<U2X1);
BAUD &=~0x8000;
}
// Baudrate setzten
UBRR1H = (unsigned char)(BAUD>>8);
UBRR1L = (unsigned char)BAUD;
// Empfänger und sender aktivieren sowie Interrupts einstellen
UCSR1B = (1<<TXEN1) | (1<<RXEN1) | (1<<RXCIE1);
// Datenformat
UCSR1C = (1<<UCSZ10) | (1<<UCSZ11) | (1<<USBS1);
return NO_ERROR;
}
unsigned char uart_off1(void)
{
UCSR1B = 0x00;
UCSR1C = 0x00;
uart_INT = 0;
return NO_ERROR;
}
unsigned int uart_getc1(void)
{
unsigned char _error = NO_ERROR;
struct ringbuffer8_t tempbuf = UART1_Rx_Buffer;
if(tempbuf.BufElements==0)
{
return (NO_DATA_RECEIVED << 8);
}
if (!(uart_INT & (1<<0)))
{
_error = UART0_Rx_Error;
}
UART1_Rx_Error = NO_ERROR;
return ((_error << 8) & ringbuffer_Read(&tempbuf));
}
unsigned char uart_putc1(char data)
{
UCSR1B &=~ (1<<UDRIE1);
if(UART1_Tx_Buffer.BufElements==UART_BUFLENGTH)
{
return (BUFFER_FULL);
}
ringbuffer_Write(&UART1_Tx_Buffer,data);
UCSR1B |= (1<<UDRIE1);
return (NO_ERROR);
}
unsigned char uart_puts1(char *data, unsigned char nlength)
{
UCSR1B &=~ (1<<UDRIE1);
if(UART1_Tx_Buffer.BufElements>=UART_BUFLENGTH)
{
return (BUFFER_FULL);
}
while (*data)
{
uart_putc(*data++);
}
UCSR1B |= (1<<UDRIE1);
return (NO_ERROR);
}
void uart_onReceive1(void (*function)(unsigned int))
{
uart_user_onReceive1 = function;
uart_INT |= (1<<3);
}
void uart_onTransmit1(void (*function)(void))
{
uart_user_onTransmit1 = function;
uart_INT |= (1<<4);
}
void uart_onRxBufferFull1(void (*function)(void))
{
uart_user_onBufferFull1 = function;
uart_INT |= (1<<5);
}
ISR(USART1_RX_vect)
{
if(uart_INT & (1<<3))
{
uart_user_onReceive1(uart_getc);
}
if(UART1_Rx_Buffer.BufElements==UART_BUFLENGTH)
{
UART1_Rx_Error = BUFFER_FULL;
if(uart_INT & (1<<5))
{
uart_user_onBufferFull1();
}
}
else
{
ringbuffer_Write(&UART1_Rx_Buffer, UDR1);
}
}
ISR(USART1_TX_vect)
{
if(UART1_Rx_Buffer.BufElements==0)
{
UCSR1C &=~ (1<<TXCIE1);
if(uart_INT & (1<<1))
{
uart_user_onTransmit1();
}
}
else
{
UDR1 = ringbuffer_Read(&UART1_Tx_Buffer);
}
}
#endif

Genau habe ich das Problem in Zeile 218 (Sende-Interrupt) und 147 / 168 (Funktionen zum hinzufügen von Zeichen in den Buffer und zum Starten der Übertragung)

Ich verstehe allmähnlich wirklich nicht warum es nicht funktionieren will. Im Simulator sehe ich das von dem struct ringbuffer8_t namens 'UART0_Tx_Buffer' immer '*readPointer' und '*writePointer' nicht übernommen werden. Und das für genau zwei Zeichen. Und das habe ich auch während dem Programm (also nicht nur am Anfang).

Es ist so als wird die Variable im Interrupt nicht mit der Globalen Variable Synchronisiert.

Brauche da einen kleinen Anstupps zur Lösung bitte.

~gfc

jvbsl · 13. Februar 2015, 16:03

volatile verhindert nur Compiler Optimierung mehr nicht.

C-Quellcode

struct ringbuffer8_t tempbuf = UART1_Rx_Buffer;

das ist mir z.B. aufgefallen. Vmtl. nicht so gewollt. tempbuf ist dann nämlich eine Kopie des UART1_Rx_Buffer und somit hat die spätere aktion auf tempbuf. Z.B. ringbuffer_Read/Write keine auswirkung auf UART1_Rx_Buffer.
Und ich finde dein Programm ziemlich unübersichtlich, auch wenn C nicht OOP ist kann man das ganze besser unterteilen.
Z.B. grad den Ringbuffer einfach in ne extra Datei, kannst dann ja schön includen. Außerdem kannst du dann die Komponenten getrennt voneinander Testen und so den Fehler finden. Im Prinzip Unit Tests machen...

RodFromGermany · 13. Februar 2015, 17:13

@gfcwfzkm Kannst Du bitte um den Code einen Expander machen?

Spoiler anzeigen

Thunderbolt · 13. Februar 2015, 20:13

RodFromGermany schrieb:

Nö.

Ich bin davon ausgegangen, dass Buffers ein Array auf Pointer darstellt.

thefiloe · 13. Februar 2015, 20:21

Thunderbolt schrieb:

dass Buffers ein Array auf Pointer darstellt

Ist aufgrund des Namens auch nachvollziehbar. Ein Buffer ist meistens ein byte-array. In C ist das (sofern dynamische Größe benötigt) ein char*. Wenn es also Buffers heißt geht man davon aus, dass es mehrere Buffer sind -> char**.

C und volatile

C und volatile

C-Quellcode

gfcwfzkm schrieb:

Thunderbolt schrieb:

C-Quellcode

C-Quellcode

C-Quellcode

RodFromGermany schrieb:

Thunderbolt schrieb:

Benutzer online 1

Ähnliche Themen

5 Benutzer haben hier geschrieben