Btm-222 mit Nibobee verbinden

[daniel (Gast)]

Hallo liebe Elektronikfreunde,

ich bin ein kompletter Neuling auf dem Gebiet, der seit einem Jahr in 
der Schule Informatik hat.

Wir haben nun als Projekt den Nibobee mit einem BTM-222 mit dem Computer 
zu verbinden und ihm per Tastatur Signale zu senden.

Verbindung läuft auch soweit.

Ich kann die serielle Schnittstelle auswählen bei Bluetooth und auch 
darauf zugreifen.

Nun möchte ich jedoch dem Nibobee sagen, dass er bei W vorwärts fahren 
sollen etc. Dies klappt jedoch nicht. Ich habe versucht dem Nibo über 
hterm Signale zuzusenden, ist das überhaupt richtig?

zB hex 57

Ich kann aber bei hterm auch nur COM6 statt COM5 auswählen. Also immer 
den COM(X+1).

Der Nibobee besitzt ja einen ATmega16. Den habe ich folgendermaßen 
programmiert. Ich denke da liegt der Fehler, weil dies ist wirklich 
nicht meine Stärke...

Hauptprogramm:

#include "nibolibbtm.c"

#include "projekt.h"

#include <avr/io.h>

#include "uart.h"





int main()

{

  char c=getchar(); 

  uart_init();

  motoren_init(); // motoren initialisieren

  led_init();

  

  

    

  while(1)

  {

  c = uart_receive();

  switch(c)

  {

    case 'w':

        led_set(0,1);

        motor_setPower(70,70);

        _delay_ms(1000);

        motor_setPower(0,0);

        break;

    



    case 's':

        led_set(1,1);

        motor_setPower(-70,-70);

        _delay_ms(1000);

        motor_setPower(0,0);

        

        break;

    case 'a':

        led_set(2,1);

        motor_setPower(30,70);

        _delay_ms(1000);

        motor_setPower(0,0);

      

        break;

    case 'd':

        led_set(3,1);

        motor_setPower(70,30);

        _delay_ms(1000);

        motor_setPower(0,0);

      

        break;

       case 'q':

        led_set(0,0);

           led_set(1,0);

        led_set(2,0);

        led_set(3,0);

        

        motor_setPower(0,0);

           

        break;



    default:

        motor_setPower(0,0);

      }

  }



}

projekt.h:

#include <avr/io.h>

#include <stdlib.h>


#define BAUD 19200UL      // Baudrate



#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // 1000 = kein Fehler.

// Odometrie Zähler
volatile int16_t odometer_links;
volatile int16_t odometer_rechts;

volatile int8_t richtung_links;
volatile int8_t richtung_rechts; 

// Analoge Referenz Werte (VCC oder 2.56V)
#define REF_VCC (1<<REFS0)            // Batteriespannung als Referenzspannung
#define REF_256 ((1<<REFS0) | (1<<REFS1))        // interne 2,56 V als Referenzspannung

#define LINE_L ((1<<MUX0) | (1<<MUX2))          // ADC5
#define LINE_C ((1<<MUX1) | (1<<MUX2))          // ADC6
#define LINE_R ((1<<MUX0) | (1<<MUX1) | (1<<MUX2))     // ADC7

// Funktionsdeklarationen

//Initialisierung der LEDs. 

void led_init(void); 

void led_set(uint8_t led, uint8_t status);

//Initialisieren

void motoren_init(void);
void motor_setPower(int8_t power_links, int8_t power_rechts);
void power_rechts(int8_t value);
void power_links(int8_t value);



void PrintInt(uint16_t wert);

void SerPrint(char *data);

void UartPutc(uint8_t zeichen);

void SerRead(uint8_t *data, uint8_t length, uint16_t timeout);        

// Linienverfolgung

void line_init();

/*Liefert den Wert an den Linien(L/C/R) */
uint16_t line_get(uint8_t idx);

/*Führt AD-Wandlung durch und liefert einen Wert*/
uint16_t ReadADC(uint16_t mux);

void uart_putc(unsigned char c);

void uart_puts(char* string);

void uart_puti(int32_t integer);

unsigned char uart_receive(void);

void uart_gets(char* buffer, uint8_t maxlen);

void uart_init(void);

uart:

void uart_putc(unsigned char c)    // einzelnen wert abfragen 1 byte

{

  while(!(UCSRA & (1<<UDRE)))

  {

  }



  UDR = c;

}



void uart_puts(char* string)    // zeichenkette zb. gradeaus links

{

  while(*string)

  {

    uart_putc(*string);

    string++;

    }

}

  

unsigned char uart_receive( void )    // warten bis byte gesendet wurde

{  

  

  while ( !(UCSRA & (1<<RXC)) );

  return UDR;      // zeichen zurück geben

}



void uart_init(void)  

{

  UCSRB = (1<<TXEN) | (1<<RXEN);      

  UCSRC = (1<<URSEL) | (3<<UCSZ0);

  UBRRH = (unsigned char)UBRR_VAL >> 8;

  UBRRL = (unsigned char)UBRR_VAL & 0x0FF;

  }

void uart_puti(int32_t integer)

{

  char temp[9];

  itoa(integer, temp, 10);

  uart_puts(temp);



  }



void uart_gets(char* buffer, uint8_t maxlen)

{

  uint8_t next;

  uint8_t strlen = 0;



  next = uart_receive();

  while(next != '\n' && strlen < maxlen - 1)

  {

    *buffer++ = next;

    strlen++;

    next = uart_receive();

    }

  *buffer = '\0';



  }

nibolibbtm.c:

#include <avr/io.h>

#include <stdlib.h>












#include <util/delay.h>
#include <avr/interrupt.h>


volatile int16_t odometer_links;
volatile int16_t odometer_rechts;
volatile int8_t richtung_links=1;
volatile int8_t richtung_rechts=1; 



#define F_CPU 15000000
/*Das Schlüsselwort volatile teilt dem Compiler mit, dass die  Variablen 
durch Ereignisse außerhalb der Kontrolle des Programms verändert werden kann. 
Der Wert der Variablen muss deshalb vor jedem Zugriff neu aus dem 
Hauptspeicher eingelesen werden, d.h. er darf nicht in einem Register des 
Prozessors zwischengespeichert werden. */

void led_init()

{
   // Datenrichtungsregister für LED 0 bis LED 4 setzen und PB4 für LINE_EN
   DDRB |= (1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3) | (1 << PB4);
} 


void led_set(uint8_t led, uint8_t status)
{
   if(led == 0)
   {
      if(status == 0)
    {
        PORTB &= ~(1<<PB0);
    }
    else
    {
       PORTB |= (1<<PB0);
    }
   }
   if(led == 1)
   {
      if(status == 0)
    {
        PORTB &= ~(1<<PB1);
    }
    else
    {
       PORTB |= (1<<PB1);
    }
   }
   if(led == 2)
   {
      if(status == 0)
    {
        PORTB &= ~(1<<PB2);
    }
    else
    {
       PORTB |= (1<<PB2);
    }
   }
   if(led == 3)
   {
      if(status == 0)
    {
        PORTB &= ~(1<<PB3);
    }
    else
    {
       PORTB |= (1<<PB3);
    }
   }
}


void motoren_init()
{
   // Datenrichtungsregister für Motoren:
   DDRD |= (1<<PD4) | (1<<PD5) | (1<<PD6) | (1<<PD7);
   // PWM Register setzen:
   TCCR1A |= (1<<COM1A1)|(1<<COM1B1)|(1<<WGM10);
   TCCR1B |= (1<<CS10);    // Prescale = 1 und Start Timer/Counter1AB
   OCR1AL=255;  //Motoren aus
   OCR1BL=255;
}

void motor_setPower(int8_t power_links, int8_t power_rechts)
{
  
  if(power_links < 0) {
    PORTD &= ~(1<<PD6);  //Motorendrehrichtungen auf rückwärts
    OCR1AL=255+255*power_links/100;
    richtung_links=-1;
  }
  else {
    PORTD |= (1<<PD6);  //Motorendrehrichtungen auf vorwärts
    OCR1AL=255-255*power_links/100;
    richtung_links=1;

  }
  if(power_rechts < 0) {
    PORTD |= (1<<PD7);  //Motorendrehrichtungen auf rückwärts
    OCR1BL=255+255*power_rechts/100;
    richtung_rechts=-1;

  }
  else {
    PORTD &= ~(1<<PD7);  //Motorendrehrichtungen auf vorwärts
    OCR1BL=255-255*power_rechts/100;
    richtung_rechts=1;

  }


}

void sens_init(void){
     DDRC &= ~0xF0; // PC4-PC7 als Eingang 
  PORTC |= 0xF0; // Pullup aktivieren
}

int sens_getRechts(void){
   if(!(PINC & 0b10000000)) return 1;
   if(!(PINC & 0b01000000)) return -1;
   return 0;
}
int sens_getLinks(void){
   if(!(PINC & 0b00100000)) return 1;
   if(!(PINC & 0b00010000)) return -1;
   return 0;
}

void odometry_init()
{
    // Die Odometrie Sensoren erzeugen ca. 172 Unterbrechungen pro Meter,
    MCUCR |= (1<<ISC11) | (1<<ISC01); // INT0 und INT1 auf fallende Flanke konfigurieren
        GICR  |= (1<<INT1)  |  (1<<INT0); // INT0 und INT1 aktivieren
    odometer_links = 0;
        odometer_rechts = 0;
    sei();
}

void odometer_set(int16_t links,int16_t rechts)
{
   odometer_links = links;
   odometer_rechts = rechts;
}

// Unterbrechung vom linken Odometrie Sensor
ISR(INT0_vect) 
{
  if(richtung_links ==1)
  {
     odometer_links++;
    }
  else
  {
     odometer_links--;
    }
}
// Unterbrechung vom rechten Odometrie Sensor
ISR(INT1_vect) 
{
  if(richtung_rechts ==1)
  {
     odometer_rechts++;
    }
  else
  {
       odometer_rechts--;
    }
}

void USART_Init( unsigned int ubrr)
{
  /*Set baud rate */
  UBRRH = (unsigned char)(ubrr>>8);
  UBRRL = (unsigned char)ubrr;
  /*Enable receiver and transmitter */
  UCSRB = (1<<RXEN)|(1<<TXEN);
  /* Set frame format: 8data, 1stop bit */
  UCSRC = (1<<URSEL)|(0<<USBS)|(3<<UCSZ0);
}

void USART_Transmit( unsigned char data )
{
  /* Wait for empty transmit buffer */
  while ( !( UCSRA & (1<<UDRE)) );
  /* Put data into buffer, sends the data */
  UDR = data;
}


void SerPrint (char *data)
{
  unsigned char i = 0;

  while (data [i] != 0x00)
    USART_Transmit(data [i++]);
}

void PrintInt (uint16_t wert)
{
  char text [7];
  itoa (wert, text, 10);
  SerPrint (text);
}

void PrintFloat(float wert, char vorkomma, char nachkomma)
{
   // vorkomma + nachkomma max 7
   char text [10];                                       
   dtostrf(wert, vorkomma, nachkomma, text);
   SerPrint(text);
}

Ich hoffe ihr könnt mir weiter helfen... :/

[Stefan (Gast)]

Ich habe keine Lust so viel Source Code zu überprüfen.

Du kannst auf meine Homepage ein funktionierendes Programm für genau 
diesen Zweck downloaden. Damit kannst Du sehr einfach verifizieren, ob 
Du ein Hardwareproblem hast.

Hammer Terminal sendet erst, wenn Du die Enter Taste drückst. Es sendet 
dann je nach Konfiguration nicht nur den Buchstaben "W", sondern auch 
ein oder zwei Bytes für den Zeilenumbruch. Das musst Du im Programm auf 
dem Roboter berücksichtigen (im einfachsten Fall alle unerwünschten 
Zeichen ignorieren).

Bedenke auch, dass das Modul eine "CONNECT" Meldung an den Roboter 
abgibt, wenn die Verbindung aufgebaut wurde. Entsprechend gibt es auch 
eine "DISCONNECT" Meldung und diverse Statusmeldungen, während keine 
Verbindung besteht. Diese Meldungen bestehen alle ausschließlich aus 
Großbuchstaben, es liegt daher nahe, die eigene Steuerung auf 
Kleinbuchstaben zu beschränken.

Der Bluetooth Stack von Microsoft (zumindest unter Windows Vista und 7) 
kommuniziert nicht sauber mit dem BTM-222. Zwar baut er eine Verbindung 
auf, sendet und empfängt dann aber meistens (manchmal geht es doch) 
keine Daten. Abhilfe schafft die Installation des Bluetooth Stacks von 
Windcomm, der in meinem Fall auf der Treiber-CD meines Laptops versteckt 
war und komischerweise nicht installiert war.

[daniel (Gast)]

Vielen Dank für die Antwort. Hilft mir schonmal ein wenig weiter

Wie heißt Ihre HP denn?

[Stefan (Gast)]

Google mal nach Stefan Frings

[daniel (Gast)]

:D ich hatte schon per email Kontakt zu Ihnen.

Wo ist dort das Programm? Ich konnte bisher noch keines finden.

[Stefan (Gast)]

http://stefanfrings.de/nibobee/index.html

prg_demo.c (benötigt die Libraries darüber).

[daniel (Gast)]

Dieser Abschnitt ist mir ja völlig entgangen. Vielen Dank!