Wie mache ich einen FIFO-Puffer mit can_frame Struktur innerhalb?

Question

Im Moment arbeite ich an einem Projekt, bei dem ein paar Prozessoren Kommunikation zwischen Can-Bus verwenden. Der Hauptkontroller (Beagle Bone) steuert das andere Gerät über einen Can-Bus. Mit einem Socket kann Linux-Framework Ich schrieb einen Prozess, der liest die Nachrichten können von den anderen Geräten senden, und jetzt möchte ich die Nachrichten, die ich in einem FIFO-Bufer, und dann obrobotam die Nachrichten zu stellen. Also muss ich den FIFO-Puffer mit can_frame Struktur innerhalb schreiben.

Zum Beispiel:

struct can_buffer { 
    struct can_frame *frames; 
    int head; 
    int tail; 
    int size; 
}; 

can_buffer new_can_buffer (size_t capacity) 
{ 
    can_buffer rb = malloc(sizeof(struct can_buffer)); 
    if (rb) { 

     /* One byte is used for detecting the full condition. */ 
     rb->size = capacity + 1; 
     rb->frames = malloc(rb->size * sizeof(struct can_frame)); 
     if (rb->frames) 
      can_buffer_reset(rb); 
     else { 
      free(rb); 
      return 0; 
     } 
    } 
    return rb; 
} 

size_t can_buffer_size(const struct can_buffer *rb) 
{ 
    return rb->size; 
} 

size_t can_buffer_capacity(const struct can_buffer *rb) 
{ 
    return can_buffer_buffer_size(rb) - 1; 
} 

size_t can_buffer_free(const struct can_buffer *rb) 
{ 
    if (rb->head >= rb->tail) 
     return can_buffer_capacity(rb) - (rb->head - rb->tail); 
    else 
     return rb->tail - rb->head - 1; 
} 

int can_buffer_is_full(const struct can_buffer *rb) 
{ 
    return can_buffer_free(rb) == 0; 
} 

int can_buffer_is_empty(const struct can_buffer *rb) 
{ 
    return can_buffer_free(rb) ==can_buffer_capacity(rb); 
} 

void can_buffer_reset(can_buffer rb) 
{ 
    rb->head = rb->tail = 0; 
} 

......... ........

/* hinzufügen Nachricht an das Ende der Warteschlange. */

void can_buffer_push(struct can_buffer *cb, struct can_frame *frame) 
{ 
    memcpy(&cb->frames[cb->tail], frame, sizeof(struct can_frame)); 
    cb->tail = (cb->tail + 1) % cb->size; 
} 

/* Retrieve message from the start of the queue. */ 
can_frame *can_buffer_pop(struct can_buffer *cb) 
{ 
    struct can_frame *frame; 
    memcpy(frame, &cb->frames[cb->head], sizeof(struct can_frame)); 
    cb->head = (cb->head + 1) % cb->size; 
    return frame; 
} 

Aber ich kann es erfolgreich tun. Ich denke, das Problem ist, dass jede can_frame-Struktur im Inneren wieder eine Struktur ist, das ist das Problem (zum Beispiel int, char usw.), aber ich weiß nicht, wie ich dieses Problem lösen soll.

Wie kann ich einen FIFO-Puffer erstellen, der die can_frame-Struktur darin speichern kann?

Ich brauche diese lagnuage in C schreiben

in Haupt nennen i

can_buffer can_buff; 

can_buff = new_can_buffer(100); 

can_buffer_push(can_buff,frame); 

frame = can_frame i

can_buff = Fifo-Puffer

Answer 1

Gut erhalten, haben Sie nicht vollständig geändert die ringbuf Routinen. Insbesondere haben ordnen Sie nicht genug Platz für die Strukturen hier:

if (rb) { 

    /* One byte is used for detecting the full condition. */ 
    rb->size = capacity + 1; 
    rb->frames = malloc(rb->size); 
    if (rb->frames) 
     ringbuf_reset(rb); 
    else { 
     free(rb); 
     return 0; 
    } 
} 

Die malloc Bedürfnisse

rb->frames = malloc(rb->size * sizeof(struct can_frame)); 

sein und das sollten Sie den ringbuf_reset() Anruf auf der nächsten Zeile in umbenannt can_buffer_reset()

aktualisieren

---

Nachtrag:

Ich habe gerade bemerkt, dass Sie müssen auch rb->head = rb->tail = 0

---

Addendum 2 zu Ihrer ringbuf_reset() Funktion aktualisieren:

Referenzierung den neu hinzugefügten Code, can_buffer_pop() wird nicht korrekt funktionieren, da es nicht für die Nachricht nicht überprüft bestehende und es reserviert keinen Speicher für die Popup-Nachricht.

Es gibt auch einen Tippfehler in can_buffer_capacity().

Editorial: Ich würde dringend vorschlagen, ein einfaches Testprogramm zu schreiben, das diese Funktionen ausführt. Es ist frustrierend, aber wird eine Reihe dieser kleinen Fehler fangen.