CAN First-TF

Exemple de programme en C écrit dans le microcontrôleur MSP430F169

Ce microcontrôleur dispose de 2 ports SPI.

Mode SPI : Single-bit serial 2-wire mode (default mode)

initialisation et chargement des registres CSR et CFTW0:

  int  CSR_ADDRESS = 0x00;   AD9959 CSR adresss Byte
  int CSR_NUM_BYTE = 0x01;   CSR nombre d'octet du registre
  long CSR0 = 0x10;          AD9959 du channel 0 MSB first SPI par défaut
     
  int  FTW_ADDRESS = 0x04;   AD9959 FTW adresss Byte
  int FTW_NUM_BYTE = 0x04;   FTW nombre d'octet du registre
  long FTW0 = 0x28F5C28F;    frequence en hex fout x2^32/fclock
     

dans le main:

  P4OUT = 0x40;          AD9959 master reset bit de validation du MSP430
  P4OUT = 0x00;          AD9959 master set   bit de validation du MSP430
  
  write_serial_port(CSR_ADDRESS, CSR0, CSR_NUM_BYTE);
  P5OUT = 0x40;          I/O update du DDS bit de validation du MSP430 
  P5OUT = 0x00;          I/O update du DDS bit de validation du MSP430  
  
  write_serial_port(FTW_ADDRESS, FTW0, FTW_NUM_BYTE);
  P5OUT = 0x40;          I/O update du DDS bit de validation du MSP430 
  P5OUT = 0x00;          I/O update du DDS bit de validation du MSP430  
  

Pour initialiser le DDS on applique cette procédure : RESET-DATA_SEND_to_BUFFER-IO_UPDATE.

RESET du DDS (pin 3), on charge les données de chaque registre au travers du port SPI write_serial_port… Puis on réalise un I/O UPDATE pin 46 du DDS pour la validation et le transfert des données. Ce bout de programme permet de charger le channel 0 avec une fréquence de 80MHz et une amplitude par défaut FULL DAC.

I/O_UPDATE is synchronous to the SYNC_CLK (Pin 54) = Master clock/4. Voir figure 40 du datasheet du DDS.

Ci-dessous le sous programme d'initialisation des ports du microcontrôleur et du SPI pour le MSP430F169 : TI fourni de nombreux exemples de codes de bases pour configurer les modes SPI, I2C et utiliser la mémoire Flash: slac015p.zip

  
  void_init_SPI(void)
  {
    BCSCTL1 |= XTS;               ACLK= LFXT1= HF XTAL 
    BCSCTL2 |= SELM_3;            MCLK = LFXT1 (safe) pin 8,9 du MSP430
    P1SEL = 0x00;                 P1 I/O select
    P2SEL = 0x00;                 P2 I/O select
    P3SEL = 0x00;                 P3 I/O select
    P4SEL = 0x00;                 P4 I/O select
    P5SEL = 0x0A;                 P5.1,3 SPI option select
    P6SEL = 0x00;                 P6 I/O select
    P1DIR = 0xFF;                 P1.output direction
    P2DIR = 0xFF;                 P2 output direction
    P3DIR = 0xFF;                 P3 output direction
    P4DIR = 0xFF;                 P4 output direction
    P5DIR = 0xFF;                 P5 output direction
    P6DIR = 0xFF;                 P6 output direction
    ME2 |= USPIE1;                Enable USART1 SPI
    UCTL1 |= CHAR + SYNC + MM;    8-bit SPI Master **SWRST**
    UTCTL1 = CKPH + SSEL1 + STC;  SMCLK delayed, 3-pin
    UBR01 = 0x2;                  ACLK/2 for baud rate
    UBR11 = 0x0;                  ACLK/2 for baud rate
    UMCTL1 = 0x0;                 Clear modulation
    UCTL1 &= ~SWRST;              Initialize USART state machine
  }

BCSCTL1 |= XTS; et BCSCTL2 |= SELM_3; permet d'être en mode HF XTAL le MSP430 fonctionnera à 8MHz au lieu de 32KHz par défaut.

           MSP430F169
         -----------------
     /|\|              XIN|-
      | |                 | HF XTAL (455k - 8Mhz)
      --|RST          XOUT|-
        |                 |
        |             P5.4|-->MCLK = XTAL

D'après : M. Buccini Texas Instruments Inc. Feb 2005 Built with CCE Version: 3.2.0 and IAR Embedded Workbench Version: 3.21A

la routine pour le chargement des données en mode SPI du MSP430F169 :

    void write_serial_port(int instruction, long data, int num_byte)
    {
     int i=0;

     TXBUF1 = instruction;
      do
     {
     TXBUF1 = data >>(num_byte-1-i)*8;
     i++;
     }
      while (i < num_byte);
    }

Exemple de programme en C écrit dans le microcontrôleur ARM TM4C123GH6PM

Ce microcontrôleur dispose de 4 ports SPI. Horloge par défaut = 80MHz

Mode SPI : Single-bit serial 3-wire mode

la routine pour le chargement des données en mode SPI de l'ARM TM4C123GH6PM :

int i=0;
SSI0_DR_R =  instruction; 
while( num_byte )
 {
      while(!(SSI0_SR_R & SSI_SR_TNF)) {} // SPI0 du TM4C123GH6PM
      SSI0_DR_R =  data >>(num_byte-1-i)*8;
      num_byte--;           
 }

while( !( SSI0_SR_R & SSI_SR_TNF ) )
      {
        ;
      }
      

La routine init (SPI) pour l'ARM TM4C123GH6PM:

// Enable Peripheral SSI0
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); //Enable GPIO port A SSI0.
SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
GPIOPinConfigure(GPIO_PA2_SSI0CLK); 
GPIOPinConfigure(GPIO_PA3_SSI0FSS);
GPIOPinConfigure(GPIO_PA5_SSI0TX);
GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_3 | GPIO_PIN_2);
//GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_2);
SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_0,
SSI_MODE_MASTER, 10000000, 8);    
SSIEnable(SSI0_BASE); // Enable the SSI 

Exemple d'initialisation d'un PORT sur l'ARM TM4C123GH6PM:

 //void PortB_Init(void)
 volatile unsigned long delay;
 SYSCTL_RCGC2_R |= 0x00000002;     // 1) activate clock for Port B
 delay = SYSCTL_RCGC2_R;           // allow time for clock to start
 GPIO_PORTB_AMSEL_R = 0x00;        // 3) disable analog on PB
 GPIO_PORTB_PCTL_R = 0x00000000;   // 4) PCTL GPIO on PB0
 GPIO_PORTB_DIR_R |= 0xFF;         // 5) PB0-PB7 is out
 //GPIO_PORTB_AFSEL_R &= ~0x01;      // 6) disable alt funct on PB0
 GPIO_PORTB_AFSEL_R &= ~0xFF;      // 6) disable alt funct on PB0-PB7
 GPIO_PORTB_DEN_R |= 0xFF;         // 7) enable digital I/O on PB0-PB7
 
 

Exemple d'initialisation d'un PORT pour la communication série USB-UART0 sur l'ARM TM4C123GH6PM:

 //void init_UART0(void)
 SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
 SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
 GPIOPinConfigure(GPIO_PA0_U0RX);
 GPIOPinConfigure(GPIO_PA1_U0TX);
 GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
 UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 9600,                      
 (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
 
    

Exemple de déclaration et d'initialisation des registres mot de fréquences:

 //AD9852//
 int  FTW0_ADRESS = 0x02; 
 //unsigned long long FTW0 = 0x17E4B17E4B1; //1.75MHz@300MHz clk
 unsigned long long FTW0;
 //float FTW0 = 0x17E4B17E4B1; //1.75MHz@300MHz clk
 int  FTW0_NUM_BYTE = 0x06;
 //AD9858//
 int  FTW1_ADRESS = 0x03; 
 unsigned  long FTW1 = 0x418937; //1MHz@1000MHz clk
 int  FTW1_NUM_BYTE = 0x04;
 //AD9858//
 int  CFR_ADRESS = 0x00; 
 unsigned  long CFR = 0x79; // MSB first
 int  CFR_NUM_BYTE = 0x04;