Vielen Dank, ich werde mir den mal anschauen.
Ich habe noch eine andere Frage, moechte aber dafuer keinen neuen Thread aufmachen. Ich sizte jetzt schon an die 5 Tage an einem Problem, dessen Ursache ich nicht finde. Ich versuche ueber UART mit dem Pololu Micro Serial Servo Controller zu kommunizieren. Ich dachte, dass das ganz einfach sei, doch leider habe ich mich wohl getaeuscht.
In dem angehaengten Code versuche ich UART zu initialisieren, sowie dem Servo Controller quasi eine Geraetenummer zu geben, da ich vier der Teile nutzen werde. Ich habe die Baudrate in den Bereich gesetzt, der im Manual mir angegeben wurde (ich glaube momentan auf ungefaehr 20.000). Lasse ich den Code laufen sagt mir der Servo Controller, er habe keine Baudrate bekommen, empfaengt demnach natuerlich auch keine Signale. Wenn ich die Baudrate hingegen auf ueber 40k setze (ich habe ueber 900k getestet), dann sagt er mir, dass die Baudrate zu langsam sei.
Kennt irgendwer dieses Phaenomen?
Hier ist der Code, ich entschuldige mich schonmal fuer die Laenge, ich habe sehr viel kommentiert:
//************************************************** ***************
//* main.c *
//************************************************** ***************
//* *
//* Written by: L J Berger *
//* Iensys Ltd *
//* Date: 11th March 2007 *
//* Revision: 1.00 *
//************************************************** ***************
// *
// This programm initializes the servo controller. The ID number *
// is assigned to the device: *
// 0 -> The servo controller reacts to the servo no 0-7 *
// 1 -> The servo controller reacts to the servo no 8-15 *
// 2 -> The servo controller reacts to the servo no 16-23 *
// ... up to servo no 127
//************************************************** ***************
//************************************************** ***************
// Include Files
//************************************************** ***************
#include <p30f6014A.h> //device specific header file
#include <stdlib.h> // for structs being able to refer to itself
//IMPORTANT: Tell the linker to create a 512byte heap. Otherwise
// the dynamic memory allocation cannot be used
//************************************************** ***************
// Config directive to set configuration bits
//************************************************** ***************
/* The internal clock controlling the execution of instructions is obtained
when the clock (from the PLL or directly) is divided by 4.
Example: Let a 10MHz crystal resonator and PLL 4x are selected. This means
that the internal clock is 4x10MHz=40MHz. This value is divided by 4 to
obtain 10MHz (100ns period)
*/
_FOSC(CSW_FSCM_OFF & XT_PLL16); //Fail safe Clock Monitor Off, eXTernal crystal with PLL 4x
/*Configuration of the Watchdog Timer*/
_FWDT(WDT_OFF); // Watchdog Timer off
/* FBORPOR is for voltage protection. The proper execution of the programs
requires a good stability of the power supply. With dsPIC30F one has the
ability of defining a minimum power supply voltage ensuring proper
function of the device. If the supply voltage falls below this limit, the
internal circuit will reset the microcontroller, wait until the supply
voltage returns above the limit, and after the specified power-up delay
time activate the microcontroller starting the execution of the program
from the beginning
*/
// enable Brown-out Reset at 2.0 Volts, initialize Power up Timer to 64ms,
// MCLR pin enabled (not used for I/O)
_FBORPOR(PBOR_ON & BORV_20 & PWRT_64 & MCLR_EN);
//************************************************** ***************
// Macros
//************************************************** ***************
#define FCY 7370000 // 7.37MHz crystal in XT PLL 4x
#define MILLISEC FCY/7370 //definition of a millisecond
//connecting the ports
#define LED1 PORTDbits.RD4
#define LED2 PORTDbits.RD5
#define LED3 PORTDbits.RD6
#define LED4 PORTDbits.RD7
/* The LEDs are used to give an error-code:
RD4 RD5 RD6 RD7 Error
0 0 0 0 No Error
0 0 0 1 Data received fron U2ART
0 0 1 0
0 0 1 1
0 1 0 0 Unable to write to queue, because the heap might be full
0 1 0 1 Unable to delete, queue is empty
*/
//************************************************** ***************
// Definition of global variables and structures
//************************************************** ***************
//UART Initialisation Flags
struct{
unsigned EnTXInterrupt:1;
unsigned TXInterruptMode:1;
unsigned Buffer_free:1;
}UART2Flags;
struct FCFS_queue
{
unsigned data:8;
struct FCFS_queue * next;
};
struct FCFS_queue * UART2TXReg;
//************************************************** ***************
// Definition of functions
//************************************************** ***************
int InitUART(void);
int InitServoController(void);
void DelayNms (unsigned int N);
int queue_add (struct FCFS_queue * head, unsigned int new_data);
int queue_delete (struct FCFS_queue * head);
int generalInits(void);
void UART2Transmission(void);
void __attribute__((__interrupt__))_U2TXInterrupt(void) ;
//************************************************** ***********************
// Implementation of functions
//************************************************** ***********************
//UART is initialized
//data bits has to be either 8 or 9, stop bits either 1 or 2, parity bits either 0 (no parity)
//or 1 (odd parity) or 2 (even parity)
//for more information see Family Reference Manual Section 19 on UART, page 19-3
//for enabling transmission interrupts set EnTXInterrupt and select Transmission Interrupt Mode
//as well as use the Interrupt functions which are currently commented out.
int InitUART(void)
{
U2MODEbits.USIDL = 0; //Continue Operation in Idle mode
U2MODEbits.ALTIO = 0; //Communicate using U2TX and U2RX, not alternate pins
U2MODEbits.WAKE = 0; //Wake-up disabled
U2MODEbits.LPBACK = 0; //Loopback mode disabled
U2MODEbits.ABAUD = 0; //No Autobaud
U2MODEbits.PDSEL = 0; //8-bit data, no parity
U2MODEbits.STSEL = 0; //1 Stop bit
if (UART2Flags.EnTXInterrupt == 1)
{
//Clear Interrupt Status Flag for U2TXIF
IFS1bits.U2TXIF = 0;
//Setting the Interrupt control bit (U2TXIE) in the Interrupt Enable Control register.
IEC1bits.U2TXIE = 1;
//Select Transmit Interrupt Mode:
U1STAbits.UTXISEL = UART2Flags.TXInterruptMode;
}
//Baud Rate: UxBRG = FCY/(16*BaudRate)-1. For 20,000: U2BRG = 23
//BaudRate has to be between 2000 and 40000 for Pololu Micro Serial Servo Controller
U2BRG = 91;
U2STAbits.UTXBRK = 0; //Transmit Break Bit-pin operates normally
//Enable UART2
U2MODEbits.UARTEN = 1;
//Enable Transmission
U2STAbits.UTXEN = 1;
return 0;
}
//Setting and Checking Servo Numbers
int InitServoController(void)
{
if (UART2Flags.Buffer_free)
{
U2TXREG = 0x80;
U2TXREG = 0x02;
U2TXREG = 0x00;
//UART2Flags.Buffer_free = 0;
}
else{
if (!queue_add(UART2TXReg, 0x80)) //first start byte
{
LED2 = 1;
return 1;
}
if (!queue_add(UART2TXReg, 0x02)) //command to change servo numbers
{
LED2 = 1;
return 1;
}
if (!queue_add(UART2TXReg, 0x00)) //servo numbers for this board: 0 -> 0-7, 1 -> 8-15, ...
{
LED2 = 1;
return 1;
}
}
return 0;
}
void DelayNms (unsigned int N)
{
unsigned int j;
while(N--)
for (j=0;j<MILLISEC;j++);
}
//if Interrupts are needed for UART2 Transmission
/*void __attribute__((__interrupt__))_U2TXInterrupt(void)
{
int counter = 0;
if (UART2TXReg != NULL)
{
while (UART2TXReg != NULL && counter < 3)
{
U2TXREG = UART2TXReg->data;
if (queue_delete(UART2TXReg)) return;
counter+=1;
}
UART2Flags.Buffer_free = 0;
}
else UART2Flags.Buffer_free = 1;
//clearing the Interrupt Status Flag
IFS1bits.U2TXIF = 0;
}*/
// Add a new element to the end of the queue
int queue_add (struct FCFS_queue * head, unsigned int new_data)
{
//create new element
struct FCFS_queue * temp = (struct FCFS_queue*) malloc(sizeof(struct FCFS_queue));
//if the heap is full, temp will just carry the NULL pointer.
//to prevent a runtime error this is catched
if (temp == NULL) return 1;
//if temp is not NULL, the data can be written into the struct.
//as this element will be placed at the very end of the queue,
//temp->next can be set to NULL.
temp->data = new_data;
temp->next = NULL;
//go to the end of the queue and add the element
if (head != NULL)
{
while (head->next != NULL) head = head->next;
head->next = temp;
}
//if the queue is empty, then just put it there.
else head = temp;
return 0;
}
// Delete the first element of the queue
int queue_delete (struct FCFS_queue * head)
{
//if head is NULL, no element can be deleted -> ERROR
if (head == NULL)
{
LED2=1;
LED4=1;
return 1;
}
else //there is still at least one element in the queue, that can be deleted
{
struct FCFS_queue * temp = head; //new pointer to the first element
head = head->next; //main pointer of the queue ist shifted one element to the rear
free((void*)temp); //free the allocated memory to prevent memory leaks
}
return 0;
}
//General variables and structures are initialised in this function.
//It is called at the very beginning of main
int generalInits(void)
{
//Information for UART Initialisation
UART2Flags.EnTXInterrupt = 0; // transmission interrupts disabled
UART2Flags.TXInterruptMode = 0; // Interrupt when last character out of the buffer was transferred
UART2Flags.Buffer_free = 1; // at the beginning of course the buffer is free
//Initialisation of Transmitter Register for UART2
UART2TXReg = NULL;
return 0;
}
//This function will be started as a separate task and checks whether there
//is any data in UART2TXReg to be transmitted and whether the buffer is able
//to save this transmission data
//ONLY SUITABLE FOR MULTITASKING
/*void UART2Transmission(void)
{
while (1)
{
if(!U2STAbits.UTXBF && UART2TXReg != NULL)
{
U2TXREG = UART2TXReg->data;
if (queue_delete(UART2TXReg)) return;
}
}
}*/
//************************************************** ***************
// MAIN
//************************************************** ***************
int main (void)
{
//int TaskID_UART2TX = 0;
if (generalInits()) return 1;
if (InitUART()) return 1;
//The task for transmitting via UART cannot be started before
//generalInits and InitUART. Otherwise data will get lost!
//ONLY SUITABLE FOR MULTITASKING
//TaskID_UART2TX = execi(&UART2Transmission, 0, 0, 10, DEFAULT_STACK_SIZE);
if (InitServoController()) return 1;
unsigned int received_data;
while (U2STAbits.URXDA)
{
received_data = U2RXREG;
LED4 = 1;
DelayNms(1000);
LED4= 0;
}
//ONLY SUITABLE FOR MULTITASKING
/*shutdown_task(&TaskID_UART2TX);
kill_task(&TaskID_UART2TX);*/
//Disable UART2:
//U2MODEbits.UARTEN = 0;
return 0;
}
Ich bedanke mich schon mal fuer die Hilfe!
Gruesse,
Kira