LPC176x uart-baudrate

[Jürgen (jliegner)]

Ich habe festgestellt, dass selbst bei den ganzen uart-Examples zum 
LPCXpresso die Einstellung der Baudrate nur über die Register DLM/DLL 
erfolgt und die Möglichkeiten der fractalen Baudratengeneration nicht 
benutzt werden. Damit wird u.U. ein nicht nötiger Baudratenfehler in 
Kauf genommen. Im Folgenden stelle ich mal einen kleinen Codeschnipsel 
vor der diese Werte zur Laufzeit berechnet. Das mache ich mit der 
Holzhammermethode in dem ich alle 54 Möglichkeiten der Register für die 
fraktalen Werte mal 4 Möglichkeiten des Taktvorteilers durchrechne und 
die Parameter mit der kleinsten Abweichung verwende. Wenn gleiche 
Abweichungen zustande kommen, wird die mit dem größten Vorteiler 
verwendet. Eventuell kann das ja jemand gebrauchen bzw. noch Fehler oder 
Verbesserungen finden.

 

#include <stdlib.h>
#include "LPC17xx.h" 
#include "gpio.h"

struct uartBaudRateParam
{
  int nSysClk;
  int nPclkArg;   // zum setzen des Vorteilers
  int nMulVal;  
  int nDivAddVal;  
  int nDlm;  
  int nDll;  
  int nBaudRate;
  int nBaudRateHas;
  int nDiff;    
  int nClkDiv;
};
  
void uartCalcBaudRate(struct uartBaudRateParam *pP)
{
  int mindiff=pP->nBaudRate; 
  
  for (int n=0; n<4; n++)
    {
    int nClkDiv;  // uart clock vorteiler
    int nPclkArg; // for PCLKSELx Registers
    switch (n)
      {
      case 0: nClkDiv=8; nPclkArg=0x03; break;
      case 1: nClkDiv=4; nPclkArg=0x00; break;
      case 2: nClkDiv=2; nPclkArg=0x02; break;
      case 4: nClkDiv=1; nPclkArg=0x01; break;
      } 
    
    // Zwischenergebnis (mit 10 multipl.)     
    int dzw=((uint32_t)(pP->nSysClk)*10)/(16*pP->nBaudRate*nClkDiv);  

    for (int nMulVal=1; nMulVal<=15; nMulVal++)
      {
      for (int nDivAddVal=0; nDivAddVal<nMulVal; nDivAddVal++)
        {
        // errechnen was in dlm/dll stehen wird incl Rundung
        int dl=((dzw*nMulVal)/(nMulVal+nDivAddVal)+5)/10; 
        
        // resultierende Baudrate
        // die Gleichung aus der Dokumentation:
        //
        //    UARTnbaud=PCLK/(16*(DLM*256+DLL)*(1+DivAddVal/MulVal))
        //
        // wurde mit MulVal multipliziert und ergibt damit:
        //
        //    UARTnbaud=(PCLK*MulVal)/(16*(DLM*256+DLL)*(MulVal+DivAddVal))
        //
        // damit wird der Divident schoen gross und es braucht kein float oder double
        // verwendet werden        
        int br=((uint32_t)pP->nSysClk*nMulVal)/(16*dl*(nMulVal+nDivAddVal)*nClkDiv);

        // differenz zur gewünschten Baudrate
        int diff=abs(br-pP->nBaudRate);

        if (diff<mindiff)
          {
          pP->nBaudRateHas=br;
          pP->nDiff=diff;
          pP->nPclkArg=nPclkArg;
          pP->nMulVal=nMulVal;
          pP->nDivAddVal=nDivAddVal;;
          pP->nDlm=dl/256;
          pP->nDll=dl%256;
          pP->nClkDiv=nClkDiv;
          mindiff=diff;
          }
        }          
      }
    }
}

Und hier ein erweiterbares Beispiel der Verwendung:

LPC_UART_TypeDef *uart_init(int uartnr, int baudrate)
{
  struct uartBaudRateParam aP;

  // die gewünschte Baudrate setzen 
  aP.nBaudRate=baudrate;

  // und die Systemfrequenz
  aP.nSysClk=SystemFrequency;

  // jetzt rechnen lassen 
  uartCalcBaudRate(&aP);

  LPC_UART_TypeDef *LPC_UART;
  switch (uartnr)
    {
    case 0:
      LPC_SC->PCONP |= (1<<3);
      LPC_UART=LPC_UART0;
      LPC_SC->PCLKSEL0 &= ~(0x03<<6);  
      LPC_SC->PCLKSEL0 |= (aP.nPclkArg<<6);
      GPIO_PINSEL(0,02,0x01);
      GPIO_PINSEL(0,03,0x01);              // rx0
      GPIO_PINMODE_IN(0,01,GPIO_IN_FLOAT); // rx0 float
      break;
    
    case 1:
      LPC_SC->PCONP |= (1<<4);
      // UART1 ist anders als die anderen, aber nicht
      // an den hier relevanten Stellen. s.u.
      LPC_UART=(LPC_UART_TypeDef *)LPC_UART1;
      LPC_SC->PCLKSEL0 &= ~(0x03<<8);  
      LPC_SC->PCLKSEL0 |= (aP.nPclkArg<<8);
      GPIO_PINSEL(0,15,0x01);
      GPIO_PINSEL(0,16,0x01);              // rx1
      GPIO_PINMODE_IN(0,16,GPIO_IN_FLOAT); // rx1 float
      break;

    case 2:
      LPC_SC->PCONP |= (1<<24);
      LPC_UART=LPC_UART2;
      LPC_SC->PCLKSEL1 &= ~(0x03<<16);  
      LPC_SC->PCLKSEL1 |= (aP.nPclkArg<<16);
      GPIO_PINSEL(0,10,0x01);
      GPIO_PINSEL(0,11,0x01);  // rx2
      GPIO_PINMODE_IN(0,11,GPIO_IN_FLOAT); // rx2 float
      break;
    
    case 3:
      LPC_SC->PCONP |= (1<<25);
      LPC_UART=LPC_UART3;
      LPC_SC->PCLKSEL1 &= ~(0x03<<18);  
      LPC_SC->PCLKSEL1 |= (aP.nPclkArg<<18);
      GPIO_PINSEL(0,0,0x02);
      GPIO_PINSEL(0,1,0x02);  // rx3
      GPIO_PINMODE_IN(0,1,GPIO_IN_FLOAT); // rx3 float
      break;
    }

  // Zugrif auf das DLL und DLM Register
  LPC_UART->LCR|=(1<<7);        
  LPC_UART->DLM = aP.nDlm;
  LPC_UART->DLL = aP.nDll;
  // Zugrif auf das DLL und DLM Register ausschalten
  LPC_UART->LCR&=~(1<<7);       
  LPC_UART->FDR=aP.nMulVal << 4 | aP.nDivAddVal;

  LPC_UART->LCR=0x03;   // 8bit  1Stopbit keine Parität 

  // rx tx-buffer reseten
  LPC_UART->FCR=0x07;
  return LPC_UART; 
}

Der Code ist an einer Stelle unsauber. Die Strukturen für UART0,2,3 sind 
etwas anders als bei UART1. Da aber alle Register, die ich verwende, an 
der selben stelle in den Structuren liegen kann ich den Pointer 
LPC_UART1 auf (LPC_UART_TypeDef *) casten;
Die GPIO Macros sind von mir, wenn die noch einer benötigen sollte bitte 
melden.
Ist es richtiger den Beitrag in dei Codesammlung zu stellen oder hier 
her?

[N. Müller (Gast)]

Jürgen Liegner schrieb:
> Die GPIO Macros sind von mir, wenn die noch einer benötigen sollte bitte
> melden.

Ja, wäre cool wenn Du die auch noch mit reinstellst...dann ist es 
vollständig.

Grüße und Danke.
N. Müller

[Jürgen (jliegner)]

na dann bitte:

#ifndef GPIO_H
#define GPIO_H

#define  PINSEL     ((volatile uint32_t*)&LPC_PINCON->PINSEL0)
#define  PINMODE     ((volatile uint32_t*)&LPC_PINCON->PINMODE0)
#define  PINMODE_OD ((volatile uint32_t*)&LPC_PINCON->PINMODE_OD0)

#define GPIO_PINSEL(p,b,v)      PINSEL[(p) * 2 + (b) / 16] = (PINSEL[(p) * 2 + (b) / 16] & ~(3 << ((b) * 2 % 32))) | (v << ((b) * 2 % 32))
#define GPIO_PINMODE_IN(p,b,v)  PINMODE[(p) * 2 + (b) / 16] = (PINMODE[(p) * 2 + (b) / 16] & ~(3 << ((b) * 2 % 32))) | (v << ((b) * 2 % 32))
#define GPIO_PINMODE_OUT(p,b,v) PINMODE_OD[(p)] = ((PINMODE_OD[(p)] & ~(1 << b))) | (v << (b))

#define GPIO_IN_PULLUP     0x00
#define GPIO_IN_REPEATER   0x01
#define GPIO_IN_FLOAT      0x02
#define GPIO_IN_PULLDOWN   0x03

#define GPIO_OUT_NORMAL    0x00
#define GPIO_OUT_OPENDRAIN 0x01

#define LPC_GPIO(a)       (LPC_GPIO0 + a*(LPC_GPIO1-LPC_GPIO0))
#define GPIO_DIR_OUT(a,b) (LPC_GPIO(a)->FIODIR |=  (1<<b))
#define GPIO_DIR_IN(a,b)  (LPC_GPIO(a)->FIODIR &= ~(1<<b))
#define GPIO_SET(a,b)     (LPC_GPIO(a)->FIOSET  =  (1<<b)) 
#define GPIO_CLR(a,b)     (LPC_GPIO(a)->FIOCLR  =  (1<<b)) 
#define GPIO_IS_SET(a,b)  ((LPC_GPIO(a)->FIOPIN & (1<<b)) !=0)

#endif

[Jim M. (turboj)]

@OP: Hast Du das Errata-sheet gelesen?
PCLKSELx kann man bei aktiver PLL0 nicht mehr verstellen.

Übrigens gibt es so eine Funktion in der "lpc17xx CMSIS driver" library:
Link von:
http://support.code-red-tech.com/CodeRedWiki/NXPDriverLibraries
zeigt auf:
http://ics.nxp.com/support/documents/microcontrollers/zip/lpc17xx.cmsis.driver.library.zip

Auf einer der Seiten für den LPC1768 bei NXP.com ist das ebenfalls 
verlinkt.

[Jürgen (jliegner)]

Hallo Jim Meba,

danke für deine Infos. Das wusste ich bisher noch nicht. Das Setzten von 
PCLKSELx findet man in fast jedem Beispielcode. Ich denke in der Regel 
immer nachdem die PLL0 gesetzt ist. Ich muss nochmal debuggen, ob bei 
meinen Tests immer 0x00 für das Bitpaar (CLK/4) rauskam und es deshalb 
nicht zum Fehler kam oder ob ich ICs habe bei denen das trotzdem geht.
Die "lpc17xx CMSIS driver" habe ich mir zwar schon mal angesehen aber 
nicht den uart-Teil. Ich habe gesehen, daß das Setzen eines Bits bei den 
Gpio Funktionen ganz schönen Overhead produziert (2 Function-Calls). 
Deshalb wollte ich auf diese Lib ganz verzichten. Ausserdem will ich die 
Register des MC verstehen und nicht nur wissen wie man entsprechende 
Funktionen aufruft. Wenns um die Fehlersuche geht sind ja dann trotzdem 
wieder die Register gefragt und ich muss eigentlich alles doppelt lernen 
wenn ich die Lib für alles benutze.
Vor diesem gesamten Hintergrund hat meine Funktion der 
Baudratenberechnung noch den Vorteil, dass man die Werte berechnen kann 
bevor die PLL0 gesetzt und connectetd wird. Dann die PCLKSELx-Register 
mit den berechnetetn Werten setzten, die PLL0 starten (oder den normalen 
sysinit) und dann die UARTs mit den restlichen Parametern 
initaialisieren.
Danke nochmal.