Config UART1 pour faire du DMX

[flolarajasse]

Bonjour à tous,

Comme le titre l'évoque, je souhaite faire du DMX avec un PIC18F45K22. Je programme sous MPLABX et mon compilateur est XC8.
Les codes en C que j'ai trouvé sont totalement inboufables, donc je souhaite réaliser le mien.
Sachant que je vais utiliser l'UART1 pour arriver à mes fins, je voulais savoir si la config de base de l'UART est correct :

void config_UART1 (void)
{
    TXSTA1bits.TXEN = 1; // Transmission activée
    TXSTA1bits.TX9 = 0; // Transmission sur 8 bits
    TXSTA1bits.SYNC = 0; // Mode Asynchrone
    TXSTA1bits.SENDB = 1; // Envoi un Break sur la prochaine transmission
    BAUDCON1bits.CKTXP = 0; // Repos = niveau haut
    BAUDCON1bits.BRG16 = 0;  // Générateur 8 bits
}

int main(int argc, char** argv)
{
    TRISCbits.RC6 = 0; // On met RC6 en sortie
    config_UART1 ();

    while(1)
    {
      
    }
}

Ensuite, je voulais savoir quelle était les instructions spécifiques à l'UART, par exemple, envoyer des données sur l'UART, lire sur l'UART,... Je n'ai pas trouvé, à moins que je n'ai pas cherché au bon endroit

Merci d'avance.
-----

[flolarajasse]

Petite modif, est ce normal que je n'ai rien à l'oscillo sur ma pin TX1?

void config_UART1 (void)
{
    PMD0bits.UART1MD = 0; // UART1 est activée
    BAUDCON1bits.BRG16 = 0;  // Générateur 8 bits
    SPBRG1 = 9; // Vitesse de transmission 250kbits/seconde
    TXSTA1bits.BRGH = 1; //Haute vitesse
    TXSTA1bits.SYNC = 0; // Mode Asynchrone
    TXSTA1bits.TX9 = 0; // Transmission sur 8 bits
    TXSTA1bits.TXEN = 1; // Transmission activée
}

int main(int argc, char** argv)
{
    //config_UART1 ();

    while(1)
    {
      config_UART1 ();
    }
}

[vincent66]

Hello,
Ben si tu ne transmets rien tu ne vas rien observer à l'oscillo aurait dit La Palisse...

[flolarajasse]

Oui, je me suis mal exprimé.

Quelles sont les instructions pour transmettre des trames?

[A voir en vidéo sur Futura]

[vincent66]

Je ne connais pas son nom par coeur mais il faut écrire les bytes à envoyer dans le "transmit data register", l'envoi se fait alors automatiquement et un flag ou une interrupt signale la fin de transmission...

[flolarajasse]

J'ai beau fouillé dans le datasheet du PIC, je ne trouve rien. Mise à part les registres de configuration de l'UART...

[flolarajasse]

Peut-être l'instruction :

TxREG1 = 255 ; //Si on veut envoyer un niveau haut sur 8 bits

Mais toujours rien à l'oscillo... A approfondir.

[flolarajasse]

Je procède exactement comme spécifié dans le datasheet :

void config_UART1 (void)
{
    PMD0bits.UART1MD = 0; // UART1 est activée
    RCSTA1bits.SPEN = 1; // Configure TX1 comme une sortie
    BAUDCON1bits.BRG16 = 0;  // Générateur 8 bits
    SPBRG1 = 9; // Vitesse de transmission 250kbits/seconde
    TXSTA1bits.BRGH = 1; //Haute vitesse
    TXSTA1bits.SYNC = 0; // Mode Asynchrone
    TXSTA1bits.TX9 = 0; // Transmission sur 8 bits
    BAUDCON1bits.CKTXP = 0; // Repos = niveau haut
}

int main(int argc, char** argv)
{
    config_UART1 ();

    TXSTA1bits.TXEN = 1; // Transmission activée, efface le buffer de transmission TXREG1
    PIE1bits.TX1IE = 1; // Autorise les interruptions de l'UART1
    TXREG1 = 170; // j'envoie les 8 data 0b10101010
}

Sans grand succès.

[flolarajasse]

Si quelqu'un peut me venir en aide =(.
Nouvelle modif' :

void config_UART1 (void)
{
    PMD0bits.UART1MD = 0; // UART1 est activée
    RCSTA1bits.SPEN = 1; // Configure TX1 comme une sortie
    BAUDCON1bits.BRG16 = 0;  // Générateur 8 bits
    SPBRG1 = 9; // Vitesse de transmission 250kbits/seconde
    TXSTA1bits.BRGH = 1; //Haute vitesse
    TXSTA1bits.SYNC = 0; // Mode Asynchrone
    TXSTA1bits.TX9 = 0; // Transmission sur 8 bits
    BAUDCON1bits.CKTXP = 0; // Repos = niveau haut
    TXSTA1bits.TXEN = 1; // Transmission activée, efface le buffer de transmission TXREG1
    PIE1bits.TX1IE = 1; // Autorise les interruptions de l'UART1
}


int main(int argc, char** argv)
{
    config_UART1();
}

void interrupt high_priority buffer_tx ()
{
    if (PIR1bits.TX1IF == 1) // Si buffer vide
    {
        TXREG1 = 170 ; // On envoie des données, TX1IF doit passer à 1 (buffer plein)
    }
}

Que doit faire mon programme principal en attendant une interruption? Est ce que je procède bien?
C'est mon interruption qui est mal déclarée?

[extremgear]

Ton code est incomplet, où sont les initialisations ?

Je pencherais sur une mauvaise initialisation des entrées sorties (voir data sheet) , en plus de ce qui a été dit précédement .

Il faut que tu t'inspire des exemples livrés avec le compilo , normalement c'est pas trop mal foutu et assez simple .

[RISC]

Salut,

Il existe pas mal de programmes pour les PIC18 et PIC16 sur le DMX512 qui peuvent t'aider :

1/ PIC16 (en C)
http://www.microchip.com/pagehandler...nications.html
tu vas en bas de la page et sous l'onglet Software tu pourras télécharger le code source en C pour un PIC16F1947 sous XC8

2/ PIC18
AN1076 pourPIC18F2550 (en ASM) : http://ww1.microchip.com/downloads/e...tes/01076A.pdf

a+

[flolarajasse]

@ extremgear,

Je mettrais mes initialisations demain, mais je ne pense pas que le soucis vient de là.

@RISC,

J'ai regardé le code, mais honnêtement, je ne sais pas par quel bout y prendre, le code est énorme!!

[flolarajasse]

Code + initialisations : (code non fonctionnel)

/* 
 * File:   Test_UART1.c
 * Author: Flo
 *
 * Created on 17 septembre 2014, 15:41
 */

#include <stdio.h>
#include <stdlib.h>
#include <xc.h>

// #pragma config statements should precede project file includes.
// Use project enums instead of #define for ON and OFF.

// CONFIG1H
#pragma config FOSC = HSHP      // Oscillator Selection bits (HS oscillator (high power > 16 MHz))
#pragma config PLLCFG = ON      // 4X PLL Enable (Oscillator multiplied by 4)
#pragma config PRICLKEN = ON    // Primary clock enable bit (Primary clock is always enabled)
#pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enable bit (Fail-Safe Clock Monitor disabled)
#pragma config IESO = OFF       // Internal/External Oscillator Switchover bit (Oscillator Switchover mode disabled)

// CONFIG2L
#pragma config PWRTEN = OFF     // Power-up Timer Enable bit (Power up timer disabled)
#pragma config BOREN = SBORDIS  // Brown-out Reset Enable bits (Brown-out Reset enabled in hardware only (SBOREN is disabled))
#pragma config BORV = 285       // Brown Out Reset Voltage bits (VBOR set to 2.85 V nominal)

// CONFIG2H
#pragma config WDTEN = OFF      // Watchdog Timer Enable bits (Watch dog timer is always disabled. SWDTEN has no effect.)
#pragma config WDTPS = 1024     // Watchdog Timer Postscale Select bits (1:1024)

// CONFIG3H
#pragma config CCP2MX = PORTC1  // CCP2 MUX bit (CCP2 input/output is multiplexed with RC1)
#pragma config PBADEN = OFF     // PORTB A/D Enable bit (PORTB<5:0> pins are configured as digital I/O on Reset)
#pragma config CCP3MX = PORTB5  // P3A/CCP3 Mux bit (P3A/CCP3 input/output is multiplexed with RB5)
#pragma config HFOFST = ON      // HFINTOSC Fast Start-up (HFINTOSC output and ready status are not delayed by the oscillator stable status)
#pragma config T3CMX = PORTC0   // Timer3 Clock input mux bit (T3CKI is on RC0)
#pragma config P2BMX = PORTD2   // ECCP2 B output mux bit (P2B is on RD2)
#pragma config MCLRE = INTMCLR  // MCLR Pin Enable bit (RE3 input pin enabled; MCLR disabled)

// CONFIG4L
#pragma config STVREN = ON      // Stack Full/Underflow Reset Enable bit (Stack full/underflow will cause Reset)
#pragma config LVP = ON         // Single-Supply ICSP Enable bit (Single-Supply ICSP enabled if MCLRE is also 1)
#pragma config XINST = OFF      // Extended Instruction Set Enable bit (Instruction set extension and Indexed Addressing mode disabled (Legacy mode))

// CONFIG5L
#pragma config CP0 = OFF        // Code Protection Block 0 (Block 0 (000800-001FFFh) not code-protected)
#pragma config CP1 = OFF        // Code Protection Block 1 (Block 1 (002000-003FFFh) not code-protected)
#pragma config CP2 = OFF        // Code Protection Block 2 (Block 2 (004000-005FFFh) not code-protected)
#pragma config CP3 = OFF        // Code Protection Block 3 (Block 3 (006000-007FFFh) not code-protected)

// CONFIG5H
#pragma config CPB = OFF        // Boot Block Code Protection bit (Boot block (000000-0007FFh) not code-protected)
#pragma config CPD = OFF        // Data EEPROM Code Protection bit (Data EEPROM not code-protected)

// CONFIG6L
#pragma config WRT0 = OFF       // Write Protection Block 0 (Block 0 (000800-001FFFh) not write-protected)
#pragma config WRT1 = OFF       // Write Protection Block 1 (Block 1 (002000-003FFFh) not write-protected)
#pragma config WRT2 = OFF       // Write Protection Block 2 (Block 2 (004000-005FFFh) not write-protected)
#pragma config WRT3 = OFF       // Write Protection Block 3 (Block 3 (006000-007FFFh) not write-protected)

// CONFIG6H
#pragma config WRTC = OFF       // Configuration Register Write Protection bit (Configuration registers (300000-3000FFh) not write-protected)
#pragma config WRTB = OFF       // Boot Block Write Protection bit (Boot Block (000000-0007FFh) not write-protected)
#pragma config WRTD = OFF       // Data EEPROM Write Protection bit (Data EEPROM not write-protected)

// CONFIG7L
#pragma config EBTR0 = OFF      // Table Read Protection Block 0 (Block 0 (000800-001FFFh) not protected from table reads executed in other blocks)
#pragma config EBTR1 = OFF      // Table Read Protection Block 1 (Block 1 (002000-003FFFh) not protected from table reads executed in other blocks)
#pragma config EBTR2 = OFF      // Table Read Protection Block 2 (Block 2 (004000-005FFFh) not protected from table reads executed in other blocks)
#pragma config EBTR3 = OFF      // Table Read Protection Block 3 (Block 3 (006000-007FFFh) not protected from table reads executed in other blocks)

// CONFIG7H
#pragma config EBTRB = OFF      // Boot Block Table Read Protection bit (Boot Block (000000-0007FFh) not protected from table reads executed in other blocks)

void config_UART1 (void)
{
    PMD0bits.UART1MD = 0; // UART1 est activée
    RCSTA1bits.SPEN = 1; // Configure TX1 comme une sortie
    BAUDCON1bits.BRG16 = 0;  // Générateur 8 bits
    SPBRG1 = 9; // Vitesse de transmission 250kbits/seconde
    TXSTA1bits.BRGH = 1; //Haute vitesse
    TXSTA1bits.SYNC = 0; // Mode Asynchrone
    TXSTA1bits.TX9 = 0; // Transmission sur 8 bits
    BAUDCON1bits.CKTXP = 0; // Repos = niveau haut
    TXSTA1bits.TXEN = 1; // Transmission activée, efface le buffer de transmission TXREG1
    PIE1bits.TX1IE = 1; // Autorise les interruptions de l'UART1
}

int main(int argc, char** argv)
{
    config_UART1();
    //send_Break();
}

void interrupt high_priority buffer_tx ()
{
    if (PIR1bits.TX1IF == 1) // Si buffer vide
    {
        TXREG1 = 170 ; // On envoie des données, TX1IF doit passer à 1 (buffer plein)
    }
}

[flolarajasse]

J'utilise un Quartz externe (10Mhz), et pour faire mon Break de 100µs, j'utilise les débordements Timer0. Pouvez vous me dire ce qui ne va pas dans mon code?
Je retrouve 0 à l'oscillo sur ma Pin RC6 (on utilise RD4 pour forcer à 0).
Qu'est ce qui ne va pas dans mon code?

int compte = 0;

void config_UART1 (void)
{
    PMD0bits.UART1MD = 0; // UART1 est activée
    //RCSTA1bits.SPEN = 1; // Configure TX1 comme une sortie
    BAUDCON1bits.BRG16 = 0;  // Générateur 8 bits
    SPBRG1 = 9; // Vitesse de transmission 250kbits/seconde
    TXSTA1bits.BRGH = 1; //Haute vitesse
    TXSTA1bits.SYNC = 0; // Mode Asynchrone
    TXSTA1bits.TX9 = 0; // Transmission sur 8 bits
    BAUDCON1bits.CKTXP = 0; // Repos = niveau haut
    //TXSTA1bits.TXEN = 1; // Transmission activée, efface le buffer de transmission TXREG1
    //PIE1bits.TX1IE = 1; // Autorise les interruptions de l'UART1
}


void send_Break_MAB (void) // Sous programme d'envoi du break
{
    compte = 0;
    TRISCbits.RC6 = 0; //On configure RC6 comme une sortie
    T0CONbits.TMR0ON = 1; // On lance Timer0
    while (compte < 2) // Tant que < 102,4µs
    {
        LATDbits.LATD4 = 0; // On force la ligne à 0
        LATCbits.LATC6 = 0; // On force la ligne à 0
    }
    T0CONbits.TMR0ON = 0; // On arrête Timer0
    LATDbits.LATD4 = 1; // On remet la ligne au repos
    LATCbits.LATC6 = 1; // On remet la ligne au repos
    compte = 0; // On réinitialise compte à 0
    __delay_us(10); // On envoie le MAB
    INTCONbits.TMR0IE = 0; // On désactive les interruptions Timer0
}


void config_TIMER0 (void)
{
    T0CONbits.T08BIT = 1; //Timer configuré en 8 bits
    T0CONbits.PSA = 0; //prédiviseur activé
    T0CONbits.T0PS2 = 0; //prédiviseur de 2 (pour avoir 51,2µs)
    T0CONbits.T0PS1 = 0; //prédiviseur de 2 (pour avoir 51,2µs)
    T0CONbits.T0PS0 = 0; //prédiviseur de 2 (pour avoir 51,2µs)
    INTCONbits.TMR0IE = 1; // On active les interruptions Timer0

}

int main(int argc, char** argv)
{
    TRISDbits.RD4 = 0; // On configure RD4 (Tx_CS) en sortie

    //config_UART1();
    config_TIMER0();
    send_Break_MAB();
}


void interrupt low_priority deb_Timer0 ()
{
   if (INTCONbits.TMR0IF = 1) // Si débordement Timer0 (51,2µs)
   {
       compte++;
       INTCONbits.TMR0IF = 0; // On réinitialise débordement Timer0 à 0
   }

}

[r4ph]

Est-ce que tu es capable d'allumer une led avec ton setup?

je sais pas trop si ça change quelque chose, mais peut-etre que cette phrase est plus importante qu'elle en à l'air:

// #pragma config statements should precede project file includes.

A+

[extremgear]

Je pense qu'effectivement il faut que tu te fasses un prog simple qui allume une led avant d'aller plus loin , histoire de vérifier que l'oscillateur fonctionne !

Bien lire le data sheet , sur ce pic la plupart des entrées sont configurées en entrées analogique par défaut et il y a pas mal de possibilités/pièges .

schéma de câblage du pic ?