UART Interrupt und Time kommen sich in die Quere???

Das is strange. dann mach mal

if ( (inStr[inCnt]) < 32) || (inStr[inCnt]) > 96) )
printf("CHAR RECEIVED: %i\n\r", (int)inStr[inCnt]);
else
printf("CHAR RECEIVED: %c\n\r", inStr[inCnt]);


Edit: ausgebessert . muh muh !

Nochwas: ich bin dann weg. bis morgen !

immernoch: bei kleinen Buchstaben andere Zeichen oder Piepsen. Bei Großbuchstaben der entsprechende int-Wert, bei Zahlen auch der entsprechende int-Wert.

Ahh,
sowas ist doch ätzend: scheinbar hat sich das terminal durch die Zeichen aufgehängt, die zur Servobewegung gesendet wurden. Sobald ich das bewegen weg lasse klappt alles.
Dh. irgendwer müsste mir jetzt doch mal beibringen, wie ich TX auf einen anderen Pin verlege, damit das nicht über die selbe Leitung geht, die zur Kommunikation mit dem PC verwendet wird. Gibts da eine Tutorial oder so?

Danke, dass ihr euch den Code angeschaut habt. War ja auch einiges Überflüssiges drin.

mfg
jagdfalke

Bei bestimmten Zeichen hängt sich das Terminal auf. ich kann dir aber zeigen, wie du das vermeidest, auch ohne eigene Leitung. ich muß nur vorher einige Wege machen.
Wie ist das mit den kleinbuchstaben gelaufen ?

Seit dem Neustart des Terminals geht alles wunderbar. Von Großbuchstaben über Kleinbuchstaben bis zu Sonderzeichen geht alles.
Wie kann ich das vermeiden? Ich habe aber gelesen, dass diese avrlibs einen Software UART bereitstellen.

mfg
jagdfalke

Wenn du NACH dem senden der Servo-Message (oder sonst was binäres)
schick folgendes, das beruhigt die Nerven vom Terminal wieder
Print "{015}{017}";
Das ist ein <SI> und sicherheitshalber ein <XON>

Ich hatte das gleiche Problem, is damit gelöst.

bist du dir sicher, dass ich
[code]
printf("{015}{017}");
[/code}
schreiben muss? Du hast ja print ".."; geschrieben. Ist das ne Mischung aus Bascom und C ? Also was muss ich jetzt senden lassen?

Mein Fehler,
[code]
print "{015}{017}"; 'BASCOM
printf (%c%c", 15, 17); 'C (= 0x0F, 0x11)
[/code}

Also irgendwie kommt immer nur noch Müll dabei raus. Das was jetzt dabei raus kommt macht irgendwie überhaupt keinen Sinn und ein Muster ist auch nicht zu erkennen:

Code:

---

#define F_CPU        8000000
#define BAUD_RATE        9600

#include <avr/delay.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <avr/io.h>
#include <avr/sfr_defs.h>


#define stopsign '!'
#define startsign '&'
volatile char inStr[500];
volatile int inCnt = 0;

// -- METHODEN DEKLARATIONEN
void        keep_moving(void);
void        move(int servo, int pos);
void        calc_steps(void);
int        putChar(char c);
int        signum(int val);
void        uart_init(int tx, int rx);
uint8_t uart_readChar(void);
void        parseInput(void);
void        input(void);


volatile uint8_t char_flag = 0;

// -- SERVO VARIABLES
volatile uint8_t servo_flag = 0;

volatile float shoulder_pos        = 127.0;
volatile float elbow_pos        = 127.0;
volatile float wrist_pos        = 127.0;
volatile float gripper_pos        = 127.0;

volatile uint8_t shoulder_dest        = 255;
volatile uint8_t elbow_dest        = 1;
volatile uint8_t wrist_dest        = 127;
volatile uint8_t gripper_dest        = 250;

volatile float shoulder_step        = 0;
volatile float elbow_step        = 0;
volatile float wrist_step        = 0;
volatile float gripper_step        = 0;


int main (void) {
        //TIMER-IINTERRUPT AN
        TCCR0 |= (1<<CS01) | (1<<CS00);
        TIMSK |= (1<<TOIE0);
        //UART-INTERRUPT AN
        UCSRB |= (1<<RXCIE);
        //UART INITIALISIEREN (RX UND TX ANSCHALTEN)
        uart_init(1, 1);
        //GLOBAL INTERRUPT AN
        sei();
        //PRINTF FÜR AUSGABE KONFIGURIEREN
          fdevopen(putChar,NULL,0);
        printf("\n\n\rSTART !!!\n\r");
        //HAUPTSCHLEIFE
        while(1)
        {
                //NUR AUFRUFEN, WENN EIN TIMER INTERUPT DA WAR
                if(servo_flag == 1) {
                        calc_steps();
                        keep_moving();
                }
                if(char_flag == 1) {
                        cli();
                        input();
                        sei();
                }
        }
        return 0;
}

void parseInput(void) {
        // ANZAHL DER ZEICHEN: inCnt
        // INDEX DES LETZTEN ZEICHENS inCnt-1
        cli();
        printf("\n\rPARSING %s ...\n\r", inStr);
        int cnt = 0;
        if(inStr[0] == 's') {
                printf("SERVO COMMAND FOUND\n\r");
                int hundreds = (int)inStr[2]-48;
                int tens = (int)inStr[3]-48;
                int ones = (int)inStr[4]-48;
                int number = hundreds*100 + tens*10 + ones;
                printf("NUMBER: %i\n\r", number);
                int servo = (int)inStr[1] - 48;
                switch(servo) {
                case(1):
                        shoulder_dest = number;
                        printf("\n\rSHOULDER_DEST CHANGED\n\r");
                        break;
                case(2):
                        elbow_dest = number;
                        printf("\n\rELBOW_DEST CHANGED\n\r");
                        break;
                case(3):
                        wrist_dest = number;
                        printf("\n\rWRIST_DEST CHANGED\n\r");
                        break;
                case(4):
                        gripper_dest =  number;
                        printf("\n\rGRIPPTER_DEST CHANGED\n\r");
                }
        }
        sei();
}

void input(void) {
        inStr[inCnt] = uart_readChar();

        switch (inStr[inCnt])
        {
        case (stopsign):
                parseInput();
                inCnt=0;
                break;
        case (startsign):
                inCnt=0;
                break;
        default:
                inCnt++;
                break;
        }

        char_flag = 0;
}


// -- METHODEN ZUM BEWEGEN DER SERVOS
void keep_moving() {

        //CALCULATE NEW POSITIONS
        shoulder_pos        = shoulder_pos + shoulder_step;
        elbow_pos        = elbow_pos + elbow_step;
        wrist_pos        = wrist_pos + wrist_step;
        gripper_pos        = gripper_pos + gripper_step;

        //SET STEP=0 IF DEST. POSITION WAS REACHED
        if( (int)(shoulder_pos) == shoulder_dest){ shoulder_step = 0; }
        if( (int)(elbow_pos) == elbow_dest) { elbow_step = 0; }
        if( (int)(wrist_pos) == wrist_dest) { wrist_step = 0; }
        if( (int)(gripper_pos) == gripper_dest) { gripper_step = 0; }

        //POSITIONEN SCHICKEN
        move(1, (int)shoulder_pos);
        move(2, (int)shoulder_pos);
        move(3, (int)elbow_pos);
        move(4, (int)wrist_pos);
        move(5, (int)gripper_pos);
        printf("%c%c", 15, 17);

        printf("POSITION:\tSHOULDER:%i \tELBOW:%i \tWRIST:%i \t GRIPPER:%i\n\r", (int)shoulder_pos,(int)elbow_pos,(int)wrist_pos,(int)gripper_pos);


        servo_flag = 0;
}
void calc_steps(void) {
        float shoulder_to_go        = shoulder_dest - shoulder_pos;
        float elbow_to_go        = elbow_dest - elbow_pos;
        float wrist_to_go        = wrist_dest - wrist_pos;
        float gripper_to_go        = gripper_dest - gripper_pos;

        float shoulder_absolute = abs(shoulder_to_go);
        float elbow_absolute        = abs(elbow_to_go);
        float wrist_absolute        = abs(wrist_to_go);
        float gripper_absolute        = abs(gripper_to_go);

        shoulder_step = 1;
        elbow_step = 1;
        wrist_step = 1;
        gripper_step = 1;


        //GET GREATEST VALUE
        uint8_t largest_way_servo = shoulder_absolute;
        if(elbow_absolute > largest_way_servo) { largest_way_servo = elbow_absolute; }
        if(wrist_absolute > largest_way_servo) { largest_way_servo =  wrist_absolute; }
        if(gripper_absolute > largest_way_servo) { largest_way_servo = gripper_absolute; }

        //SET STEP DEPENDING ON GREATEST VALUE (BIGGEST STEP=1)
        shoulder_step = (shoulder_absolute/largest_way_servo) * signum(shoulder_to_go);
        elbow_step = (elbow_absolute/largest_way_servo) * signum(elbow_to_go);
        wrist_step = (wrist_absolute/largest_way_servo) * signum(wrist_to_go);
        gripper_step = (gripper_absolute/largest_way_servo) * signum(gripper_to_go);

}
void move(int servo, int pos){
      loop_until_bit_is_set(UCSRA, UDRE);
      UDR = '#';
      loop_until_bit_is_set(UCSRA, UDRE);
      UDR = 's';
      loop_until_bit_is_set(UCSRA, UDRE);
      UDR = servo;
      loop_until_bit_is_set(UCSRA, UDRE);
      UDR = pos;
}


//SIGNUM WIRD NUR IN calc_steps BENÖTIGT
int signum(int val) {
        if(val != 0) {
                return val/abs(val);
        } else {
                return 0;
        }
}

//INTERRUPTS
SIGNAL (SIG_OVERFLOW0){
        servo_flag = 1;
}
SIGNAL(SIG_USART_RECV) {
        char_flag = 1;
}

// -- UART METHODEN
void uart_init(int tx, int rx) {
          UBRRL = (F_CPU/(BAUD_RATE*16l)-1);
        if(tx == 1) {
                UCSRB |= (1<<TXEN);
        }
        if(rx == 1) {
                UCSRB |= (1<<RXEN);
        }
}
int putChar(char c){
  while ( !( UCSRA & (1<<UDRE)) );
  UDR=c;
  return 0;
}
uint8_t uart_readChar(void) {
        return UDR;
}

---