ROUVus - auf die Plätze, fertig, los !

Ich hab während des Zivildienstes ein ROV gestartet, das auf den Namen "ROUVus" hören soll.
Ich habe mich heute aufgemacht, den gegenwärtigen Zustand zu dokumentieren und meine Ideen aus meinem Kopf in digitale Form zu bannen.
Für viel Kritik und Meinungen wäre ich sehr dankbar, da mir die simpelsten Ideen meistens erst nach dem Bau einfallen und diese doch alles deutlich erleichtert hätten.
Adresse: http://hardegser-sv.de/rov/

MfG
ngb

Ah endlich wieder jemand der einen Tauchroboter baut. Freue mich schon auf deine Fortschritte.
Bin momentan selber am überlegen ob ich ein Tauchroboter baue.

Hallo..
bei den rs485 tests hat sich ein problem ergeben..
ich glaube ich stehe einfach vor einer wand um die ein sehr einfacher weg herumführt..

ich habe meine zentrale c-datei namens motor-treiber.c.
ich habe versucht die funktionen zur kommunikation allgemein zu implementieren... in einer header datei..
und wenn mich meine c/c++ erfahrungen nicht täuschen, sollte man diese auslagerung mit dem befehl #include "rs485.h" einbinden können..
in die header datei schreibe ich die prototypen und in die "rs485.c" die definitionen ..
wenn ich nun die rs485.h datei einbinde, müssten die in rs485.c ausführlich definierten funktionen verfügbar sein oder hab ich was falsch in errinnerung ?
das problem ist, dass die beispiele zum UART mit AVR/GCC hier für mich etwas schwer zu durchblicken sind was die dateizuordnung angeht..
ist der mit c-datei überschriebene teil die eigentliche programm-quellcode-datei oder die zur header datei gehörige c-datei.. ?
desweiteren stellt sich mir die frage, ob die c-datei denselben namen tragen muss wie die header datei damit die funktionen sauber implementiert werden.. weil ja nur die header datei eingebunden wird.. (und damit dann auch die zugehörige c-datei ??)
für einen kleinen hinweis wär ich sehr dankbar..

MfG
ngb

P.S.: hier die dateien und die fehlermeldung von PN:

Code:

---

// Sollte schon im Makefile definiert sein.
// In dem Fall hier einfach löschen.
#define F_CPU      16000000UL

#include <avr/io.h>
#include <inttypes.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include "rs485.h"
#include "fifo.h"

void warte (uint16_t loop) //loop: wartezeit in ms
{
        uint16_t i;
        for(i=0;i<loop;i++) _delay_ms(1); //Hier sind als Werte für _delay_ms Takt-abhängige Werte maximal
                                                                                //erlaubt.. Durch die Schleife werden beliebige Werte möglich
}

int main(void)
{
    // USART initialisieren
    rs485_init();
       
        warte(5000);
       
        rs485_puts("Hallo Welt !");
       
        sei();
       
        while(1);
}

---

Code:

---

#ifndef _RS485_H_
#define _RS485_H_

void rs485_init();
uint8_t rs485_getc_wait();
int rs485_getc_nowait();
void rs485_putc(unsigned char buffer);
void rs485_puts(const char *s);

static inline void rs485_flush()
{
        while (UCSRB & (1 << UDRIE));
}

#endif /* _RS485_H_ */

---

Code:

---

#define BAUDRATE 19200

// FIFO-Objekte und Puffer für die Ein- und Ausgabe

#define BUFSIZE_IN  0x40
uint8_t inbuf[BUFSIZE_IN];
fifo_t infifo;

// Empfangene Zeichen werden in die Eingabgs-FIFO gespeichert und warten dort
SIGNAL (SIG_UART_RECV)
{
    _inline_fifo_put (&infifo, UDR);
}

void rs485_init()
{
    uint8_t sreg = SREG;
    uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16*BAUDRATE) - 1);

    UBRRH = (uint8_t) (ubrr>>8);
    UBRRL = (uint8_t) (ubrr);

    // Interrupts kurz deaktivieren
    cli();

    // UART Receiver und Transmitter anschalten, Receive-Interrupt aktivieren
    // Data mode 8N1, asynchron
    UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);
    UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);

    // Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte)
    do
    {
        // UDR auslesen (Wert wird nicht verwendet)
        UDR;
    }
    while (UCSRA & (1 << RXC));

    // Rücksetzen von Receive und Transmit Complete-Flags
    UCSRA = (1 << RXC) | (1 << TXC);

    // Global Interrupt-Flag wieder herstellen
    SREG = sreg;

    // FIFOs für Ein- und Ausgabe initialisieren
    fifo_init (&infifo,  inbuf, BUFSIZE_IN);
       
        //Output DDD2 setzen für Send/Receive- Wechsel
        DDRD = (1<<DDD2);
}

// Ein Zeichen lesen (Wenn keine Zeichen da, Rückmeldung)
int rs485_getc_nowait ()
{
    return fifo_get_nowait (&infifo);
}

// Ein Zeichen lesen (so lange warten, bis ein Zeichen da ist)
uint8_t rs485_getc_wait ()
{
    return fifo_get_wait (&infifo);
}

// Um das Problem bei RS485 zu umgehen, dass nicht gleichzeitig gesendet und empfangen werden kann (2 Adern),
// nur "direktes" Senden möglich

//Einzelnes Zeichen senden
void rs485_putc (unsigned char buffer)
{
        while (!(UCSRA & (1 << UDRE)));
        PORTD |= (1 << 2);
        UDR = buffer;
        PORTD &= ~(1 << 2);
}

//String senden
void rs485_puts (const char *s)
{
        PORTD |= (1 << 2);
        do
    {
                // Warten bis der Sendepuffer frei ist
                while ( !( UCSRA & (1<<UDRE)) );
                UDR = *s;
    }
    while (*s++);       
        PORTD &= ~(1 << 2);
}

---

Fehlermeldung:
in Main:
Undefined Reference to rs485_puts

ich nochmal ;-)

wie gesagt stand ich voll auf dem schlauch..
man sollte, wenn man richtig auslagern will, sich die idee einer header datei vergegenwärtigen..
also lieber die c-datei includen und in der c-datei die header datei include...

MfG
ngb

Hallo..

es hat sich da eine frage ergeben die mich etwas verwirrt..
wenn ich den empfang über UART mit FIFO abfangen will, hab ich ein verständnis problem..
ich empfange ja char-variablen..
problem:
bei der initialisierung des buffers für fifo wird als dateityp schon uint8_t angegeben.. das passt nicht zusammen oder ?
und dasselbe gilt auch für die funktionen ..
die lesefunktionen haben als rückgabetyp int oder uint8_t und das bei char variablen die empfangen werden..?
etwas komisch in meinen augen..
für hinweise wäre ich dankbar..

MfG
ngb

Hallo,
grundsätzlich heißt "FIFO" "First In First Out", also das was Du als erstes auf den Stack des UART packst, wird auch als erstes wieder rausgeschrieben.
Zu Deinem Problem mit den Variablen Typen:
Ein Char besteht aus einem Byte, sprich 8 Bit. Ein uint_8 besteht auch aus einem Byte also auch 8 Bit. Ein int besteht jedoch aus 2 Byte bei 8/16 Bit Microcontrollern bzw. 4 Byte bei 32 Bit Controllern.

Grundsätzlich sollte es also keine Probleme geben ein char in ein uint8_t zu schreiben. Sollte der Compiler rummäckern mußte halt casten, sprich den einen Wertebereich an den anderen anpassen. Wenn Du z.B. ein 8 Bit Wert in eine 16Bit Variable schreiben willst sieht das dann so aus:
uint16_t GROSSEZAHL; //16Bit Zahl
uint8_t KLEINEZAHL; // 8Bit Zahl
GROSSEZAHL = (uint8_t)KLEINEZAHL; //8Bit Zahl wird auf 16Bit Zahl geCASTed
Im Zweifelsfall such in Netz einfach nach CAST.

Gruß
Quentin

danke !!

MfG
ngb