MSP430F2274 DCO Daten über externen Taktgeber kalibrieren

[mesut (Gast)]

hallo,

ich habe aus versehen die DCO kaliebrierungsdaten gelöscht und die PINs 
2.6 & 2.7 also XIN und XOUT schon auf dem SMD-Board als Signalausgänge 
für was anderes fest verdrahtet.

Ich habe auch schon die Suchfunktion benutzt und wie verückt gegooglet. 
ich finde aber immer nur das Beispielprogramm von TI 
msp430x22x4_dco_flashcal.c was ich leider nicht benutzen kann, da ich ja 
keinen Uhrenquarz mehr an XIN und XOUT anschließen kann.
Ich habe ein Osziloskop und auch Taktquellen mit 1Mhz und anderen 
Frequenzen zur Verfügung.
Als freie PINs habe ich nur noch die Ports P2.0 bis P2.4.

Ist vielleicht jemand so fit und kann mir Hilfestellung geben um das 
Beispielprogramm von TI zur kalibrierung eventuell so anzupassen, dass 
ich das mit meinen freien Ports zur kalibrierung verwenden kann. Wie 
erwähnt es stehen mir ein Oszi und auch eine Taktgenerator zur 
Verfügung.

Für Tipps oder Codeschnipsel wäre ich euch echt sehr dankbar oder kann 
man eventuell den quarz nich an einen der freien PINs hängen?

mfg mesut

[mesut (Gast)]

hallo,

hat keiner einen Rat?
Ich habe den CODE von thomas, der hat wohl so ein ähnliches bzw. gleiche 
Problem TOPIC: (Beitrag "Flashspeicher Segment A bei ez430-rf2500 gelöscht wie wiederherstellen?") etwas 
modifiziert und P2.1 an den Taktgeber mit 135,14 KHz angeschlossen.
und mir die Funktion SETDCO() von den MSP430F20xx Code Examples genommen 
und als Quelle für den Timer einfach INCLK (TASSEL_3) genommen.

Nur kommt das Programm nur bis zur Zeile:
 while (!(CCIFG & TACCTL0)); // Wait until capture occured

mit einer anderen Frequenz wie z.B. 32Khz usw. ist das Problem immer 
noch da. das heißt er erkennt das Signal nicht.

Weiß jemand Rat?

please, bitte,  por favor, per favore, 不客气 ［不客氣

//******************************************************************************
//           MSP430F22x4
//         ---------------
//     /|\|            XIN|-
//      | |               | 32kHz
//      --|RST        XOUT|-
//        |               |
//        |           P1.0|--> LED
//        |           P1.4|--> SMLCK = target DCO
//        |           P2.1|<-- INCLK  mit 135,14KHz
//
//  A. Dannenberg
//  Texas Instruments Inc.
//  April 2006
//  Built with CCE Version: 3.2.0 and IAR Embedded Workbench Version: 3.41A
//******************************************************************************
#include "msp430x22x4.h"

#define DELTA_1MHZ    999
#define DELTA_8MHZ    8000
#define DELTA_12MHZ   11995
#define DELTA_16MHZ   15990

unsigned char CAL_DATA[8];                  // Temp. storage for constants
volatile unsigned int i;
int j;
char *Flash_ptrA;                           // Segment A pointer
void Set_DCO(unsigned int Delta);

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  for (i = 0; i < 0xfffe; i++);             // Delay for XTAL stabilization
  P1OUT = 0x00;                             // Clear P1 output latches
  P1SEL = 0x10;                             // P1.4 SMCLK output
  P1DIR = 0x11;                             // P1.0,4 output
  P2SEL |= 0x02;                            // Select P2.1 INCLK options

  j = 0;                                    // Reset pointer

  Set_DCO(DELTA_16MHZ);                     // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Set_DCO(DELTA_12MHZ);                     // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Set_DCO(DELTA_8MHZ);                      // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Set_DCO(DELTA_1MHZ);                      // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Flash_ptrA = (char *)0x10C0;              // Point to beginning of seg A
  FCTL2 = FWKEY + FSSEL0 + FN1;             // MCLK/3 for Flash Timing Generator
  FCTL1 = FWKEY + ERASE;                    // Set Erase bit
  FCTL3 = FWKEY + LOCKA;                    // Clear LOCK & LOCKA bits
  *Flash_ptrA = 0x00;                       // Dummy write to erase Flash seg A
  FCTL1 = FWKEY + WRT;                      // Set WRT bit for write operation
  Flash_ptrA = (char *)0x10F8;              // Point to beginning of cal consts
  for (j = 0; j < 8; j++)
    *Flash_ptrA++ = CAL_DATA[j];            // re-flash DCO calibration data
  FCTL1 = FWKEY;                            // Clear WRT bit
  FCTL3 = FWKEY + LOCKA + LOCK;             // Set LOCK & LOCKA bit

  while (1)
  {
    P1OUT ^= 0x01;                          // Toggle LED
    for (i = 0; i < 0x4000; i++);           // SW Delay
  }
}

void Set_DCO(unsigned int Delta)            // Set DCO to selected frequency
{
  unsigned int Compare, Oldcapture = 0;

  BCSCTL1 |= DIVA_3;                        // ACLK = LFXT1CLK/8
  TACCTL0 = CM_1 + CCIS_1 + CAP;            // CAP, ACLK
  TACTL = TASSEL_3 + MC_2 + TACLR;          // INCLK, cont-mode, clear

  while (1)
  {
    while (!(CCIFG & TACCTL0));             // Wait until capture occured
    TACCTL0 &= ~CCIFG;                      // Capture occured, clear flag
    Compare = TACCR0;                       // Get current captured SMCLK
    Compare = Compare - Oldcapture;         // SMCLK difference
    Oldcapture = TACCR0;                    // Save current captured SMCLK

    if (Delta == Compare)
      break;                                // If equal, leave "while(1)"
    else if (Delta < Compare)
    {
      DCOCTL--;                             // DCO is too fast, slow it down
      if (DCOCTL == 0xFF)                   // Did DCO roll under?
        if (BCSCTL1 & 0x0f)
          BCSCTL1--;                        // Select lower RSEL
    }
    else
    {
      DCOCTL++;                             // DCO is too slow, speed it up
      if (DCOCTL == 0x00)                   // Did DCO roll over?
        if ((BCSCTL1 & 0x0f) != 0x0f)
          BCSCTL1++;                        // Sel higher RSEL
    }
  }
  TACCTL0 = 0;                              // Stop TACCR0
  TACTL = 0;                                // Stop Timer_A
  BCSCTL1 &= ~DIVA_3;                       // ACLK = LFXT1CLK
}

[Stefan (Gast)]

Quelle für den Timer muss SMCLCK bleiben.
Was verändert werden muss ist das Capture Compare Signal. Statt des 
internen ACLCK, was hier nicht verfügbar ist, muss ein externes Signal 
genutzt werden. CCI0B an P2.2 sollte nutzbar sein.
Mit 4096 Hz an P2.2 können die DELTA_xMHz Werten aus dem 
Beispielprogramm unverändert bleiben.
Bei höheren Frequenzen an P2.2 müssen die DELTA_xMHz entsprechend 
kleiner werden und der DCO lässt sich nur noch grob einstellen.
Bei z.B. 32KHz müssten statt
#define DELTA_1MHZ    244    // 244 x 4096 Hz = 999424 Hz
entweder
#define DELTA_1MHZ    30     // 30 x 32768 Hz = 983040 Hz
oder
#define DELTA_1MHZ    31     // 31 x 32768 Hz =1015808 Hz
genutzt werden

[mesut (Gast)]

danke für die antwort werde es gleich mal ausprobieren

[mesut (Gast)]

kannst du mir einen tipp geben wie ich den timer einzustellen habe. ich 
bekomme das irgentwie nicht hin.

mfg mesut

[mesut (Gast)]

ich habe das jetzt so umgesetzt:

//******************************************************************************
//
//           MSP430F22x4
//         ---------------
//     /|\|            XIN|-
//      --|RST        XOUT|-
//        |               |
//        |           P1.0|--> LED
//        |           P2.1|--> SMLCK = target DCO
//        |           P2.2|<-- 4096 Hz
//
//  A. Dannenberg
//  Texas Instruments Inc.
//  April 2006
//  Built with CCE Version: 3.2.0 and IAR Embedded Workbench Version: 3.41A
//******************************************************************************
#include "msp430x22x4.h"

#define DELTA_1MHZ    244                   // 244 x 4096Hz = 999.4Hz
#define DELTA_8MHZ    1953                  // 1953 x 4096Hz = 7.99MHz
#define DELTA_12MHZ   2930                  // 2930 x 4096Hz = 12.00MHz
#define DELTA_16MHZ   3906                  // 3906 x 4096Hz = 15.99MHz

unsigned char CAL_DATA[8];                  // Temp. storage for constants
volatile unsigned int i;
int j;
char *Flash_ptrA;                           // Segment A pointer
void Set_DCO(unsigned int Delta);

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  for (i = 0; i < 0xfffe; i++);             // Delay for XTAL stabilization
  P1OUT = 0x00;                             // Clear P1 output latches
  P1DIR = 0x01;                             // P1.0 output
  P2SEL |= BIT2;                            // P2.1 SMCLK output
  P2DIR |= 0x02;                            // P2.1 output

  j = 0;                                    // Reset pointer
/*
  Set_DCO(DELTA_16MHZ);                     // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Set_DCO(DELTA_12MHZ);                     // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Set_DCO(DELTA_8MHZ);                      // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;
*/
  Set_DCO(DELTA_1MHZ);                      // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Flash_ptrA = (char *)0x10C0;              // Point to beginning of seg A
  FCTL2 = FWKEY + FSSEL0 + FN1;             // MCLK/3 for Flash Timing Generator
  FCTL1 = FWKEY + ERASE;                    // Set Erase bit
  FCTL3 = FWKEY + LOCKA;                    // Clear LOCK & LOCKA bits
  *Flash_ptrA = 0x00;                       // Dummy write to erase Flash seg A
  FCTL1 = FWKEY + WRT;                      // Set WRT bit for write operation
  Flash_ptrA = (char *)0x10F8;              // Point to beginning of cal consts
  for (j = 0; j < 8; j++)
    *Flash_ptrA++ = CAL_DATA[j];            // re-flash DCO calibration data
  FCTL1 = FWKEY;                            // Clear WRT bit
  FCTL3 = FWKEY + LOCKA + LOCK;             // Set LOCK & LOCKA bit

  while (1)
  {
    P1OUT ^= 0x01;                          // Toggle LED
    for (i = 0; i < 0x4000; i++);           // SW Delay
  }
}

void Set_DCO(unsigned int Delta)            // Set DCO to selected frequency
{
  unsigned int Compare, Oldcapture = 0;

  BCSCTL1 |= DIVA_3;                        // ACLK = LFXT1CLK/8
  TBCCTL2 = CM_1 + CCIS_1 + CAP;            // CAP, ACLK
  TBCTL = TASSEL_2 + MC_2 + TACLR;          // SMCLK, cont-mode, clear

  while (1)
  {
    while (!(CCIFG & TBCCTL2));             // Wait until capture occured
    TBCCTL2 &= ~CCIFG;                      // Capture occured, clear flag
    Compare = TBCCR2;                       // Get current captured SMCLK
    Compare = Compare - Oldcapture;         // SMCLK difference
    Oldcapture = TBCCR2;                    // Save current captured SMCLK

    if (Delta == Compare)
      break;                                // If equal, leave "while(1)"
    else if (Delta < Compare)
    {
      DCOCTL--;                             // DCO is too fast, slow it down
      if (DCOCTL == 0xFF)                   // Did DCO roll under?
        if (BCSCTL1 & 0x0f)
          BCSCTL1--;                        // Select lower RSEL
    }
    else
    {
      DCOCTL++;                             // DCO is too slow, speed it up
      if (DCOCTL == 0x00)                   // Did DCO roll over?
        if ((BCSCTL1 & 0x0f) != 0x0f)
          BCSCTL1++;                        // Sel higher RSEL
    }
  }
  TBCCTL2 = 0;                              // Stop TACCR2
  TBCTL = 0;                                // Stop Timer_A
  BCSCTL1 &= ~DIVA_3;                       // ACLK = LFXT1CLK
}

nur ist da irgent etwas falsch.
als taktquelle habe 4096Hz an P2.2

[Stefan (Gast)]

Die Änderungen auf Timer_B sind falsch.
P2.2 kann als Timer_A.CCI0B genutzt werden wenn diese Funktion per P2SEL 
ausgewählt wird, sonst ist Timer_A.CCI0B intern mit ACLK verbunden.
Das Originalprogramm müsste mit nur einer kleinen Änderung laufen:
P2SEL |= 0x06;        // P2.1 SMCLK output, P2.2  CCI0B input

[mesut (Gast)]

hallo stefan,

ich habe die zeile :

  P2SEL |= 0x02;                            // P2.1 SMCLK output

gegen diese ausgetauscht:

P2SEL |= 0x06;        // P2.1 SMCLK output, P2.2  CCI0B input

leider bleibt das programm nach wie vor an der zeile:

while (!(CCIFG & TACCTL0)); // Wait until capture occured

hängen und läuft nicht weiter.
habe ich an den einstellungen was falsch.


ich poste nochmal den ganzen code mit der veränderten zeile:

//******************************************************************************
//  MSP430F22x4 Demo - DCO Calibration Constants Programmer
//
//
//           MSP430F22x4
//         ---------------
//     /|\|            XIN|-
//      | |               | 32kHz
//      --|RST        XOUT|-
//        |               |
//        |           P1.0|--> LED
//        |           P2.1|--> SMLCK = target DCO
//
//  A. Dannenberg
//  Texas Instruments Inc.
//  April 2006
//  Built with CCE Version: 3.2.0 and IAR Embedded Workbench Version: 3.41A
//******************************************************************************
#include "msp430x22x4.h"

#define DELTA_1MHZ    244                   // 244 x 4096Hz = 999.4Hz
#define DELTA_8MHZ    1953                  // 1953 x 4096Hz = 7.99MHz
#define DELTA_12MHZ   2930                  // 2930 x 4096Hz = 12.00MHz
#define DELTA_16MHZ   3906                  // 3906 x 4096Hz = 15.99MHz

unsigned char CAL_DATA[8];                  // Temp. storage for constants
volatile unsigned int i;
int j;
char *Flash_ptrA;                           // Segment A pointer
void Set_DCO(unsigned int Delta);

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  for (i = 0; i < 0xfffe; i++);             // Delay for XTAL stabilization
  P1OUT = 0x00;                             // Clear P1 output latches
  P1DIR = 0x01;                             // P1.0 output
  P2SEL |= 0x06;                            // P2.1 SMCLK output, P2.2  CCI0B input
  P2DIR |= 0x02;                            // P2.1 output

  j = 0;                                    // Reset pointer

  Set_DCO(DELTA_16MHZ);                     // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Set_DCO(DELTA_12MHZ);                     // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Set_DCO(DELTA_8MHZ);                      // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Set_DCO(DELTA_1MHZ);                      // Set DCO and obtain constants
  CAL_DATA[j++] = DCOCTL;
  CAL_DATA[j++] = BCSCTL1;

  Flash_ptrA = (char *)0x10C0;              // Point to beginning of seg A
  FCTL2 = FWKEY + FSSEL0 + FN1;             // MCLK/3 for Flash Timing Generator
  FCTL1 = FWKEY + ERASE;                    // Set Erase bit
  FCTL3 = FWKEY + LOCKA;                    // Clear LOCK & LOCKA bits
  *Flash_ptrA = 0x00;                       // Dummy write to erase Flash seg A
  FCTL1 = FWKEY + WRT;                      // Set WRT bit for write operation
  Flash_ptrA = (char *)0x10F8;              // Point to beginning of cal consts
  for (j = 0; j < 8; j++)
    *Flash_ptrA++ = CAL_DATA[j];            // re-flash DCO calibration data
  FCTL1 = FWKEY;                            // Clear WRT bit
  FCTL3 = FWKEY + LOCKA + LOCK;             // Set LOCK & LOCKA bit

  while (1)
  {
    P1OUT ^= 0x01;                          // Toggle LED
    for (i = 0; i < 0x4000; i++);           // SW Delay
  }
}

void Set_DCO(unsigned int Delta)            // Set DCO to selected frequency
{
  unsigned int Compare, Oldcapture = 0;

  BCSCTL1 |= DIVA_3;                        // ACLK = LFXT1CLK/8
  TACCTL2 = CM_1 + CCIS_1 + CAP;            // CAP, ACLK
  TACTL = TASSEL_2 + MC_2 + TACLR;          // SMCLK, cont-mode, clear

  while (1)
  {
    while (!(CCIFG & TACCTL2));             // Wait until capture occured
    TACCTL2 &= ~CCIFG;                      // Capture occured, clear flag
    Compare = TACCR2;                       // Get current captured SMCLK
    Compare = Compare - Oldcapture;         // SMCLK difference
    Oldcapture = TACCR2;                    // Save current captured SMCLK

    if (Delta == Compare)
      break;                                // If equal, leave "while(1)"
    else if (Delta < Compare)
    {
      DCOCTL--;                             // DCO is too fast, slow it down
      if (DCOCTL == 0xFF)                   // Did DCO roll under?
        if (BCSCTL1 & 0x0f)
          BCSCTL1--;                        // Select lower RSEL
    }
    else
    {
      DCOCTL++;                             // DCO is too slow, speed it up
      if (DCOCTL == 0x00)                   // Did DCO roll over?
        if ((BCSCTL1 & 0x0f) != 0x0f)
          BCSCTL1++;                        // Sel higher RSEL
    }
  }
  TACCTL2 = 0;                              // Stop TACCR2
  TACTL = 0;                                // Stop Timer_A
  BCSCTL1 &= ~DIVA_3;                       // ACLK = LFXT1CLK
}

kannst du mir bitte nochmal einen tipp geben?

mfg mesut

[Stefan (Gast)]

Ersetze mal alle TACCTL2 durch TACCTL0 und TACCR2 durch TACCR0.

[mesut (Gast)]

hallo stefan,

hat alles wunderbar geklappt, bis auf die 16MHz kalibrierung da hängt 
sich das programm auf.ich brauche aber eh nur die 1MHz und 8Mhz daher 
reicht das für mich alle mal.

vielen dank nochmals du hast echt fett ein gut bei mir. wenn du um die 
gegend köln um rum wohnst, würde ich dir gerne ein ausgeben oder mich 
sonstig erkenntlich zeigen. Ohne dich hätte ich das wohl erst nach 
einigen Dutzend Nächten hinbekommen und bei meiner diplomarbeit hinke 
ich schon zeitlich gut hinterher.

mfg mesut

[Stefan (Gast)]

Freut mich, dass ich helfen konnte.
Ich habe selbst bisher nur mit den kleineren MSP430 auf dem Launchpad 
gearbeitet und konnte daher keine fertige Lösung liefern sondern nur ein 
paar Hinweise geben. Dafür brauchst du mir keinen auszugeben. Köln ist 
dafür außerdem zu weit weg.
Dass die 16 MHz Kalibrierung nicht klappt könnte an einer zu niedrigen 
Versorgungsspannung für diese Taktfrequenz liegen.