Programmation microcontrolée Zigbee

Pocamulan -  
 dgidgis -
Bonjour,
Je dois réaliser un programme en C avec le logiciel Silicon Laboratory, ce programme doit faire communiquer via le sans fil deux module Zigbee entre eux équiper d'antenne. On ma fourni un code déjà existant mais j'ai du mal à en comprendre le fonctionnement. Si quelqu'un pourrais m'aider à déchiffrer tout ça, ca m'aiderais enormement. Alors si vous êtes plutot doué dans la programmation de ce genre dite le moi je vous transmettrer le code qui me bloque.

Merci à tous
Configuration: Windows Vista
Firefox 3.0.8

4 réponses

  1. Pocamulan
     
    J'ai déjà commencer à le commenter voilà ce que ca donne :

    //SPI-RS232
    #include <c8051F120.h>

    #define SYSCLK 24900000 //definition de l'horloge

    /********************************************DEFINITION DES PORTS***************************************/
    sfr16 RCAP2 = 0xCA;
    sfr16 TMR2 = 0xCC;

    sbit MOSI = P0^4; //sortie du CC2420
    sbit MISO = P0^3; //entree du CC2420
    sbit SCK = P0^2; //horloge fournie au CC2420
    sbit NSS = P0^5; //signal d'activation
    sbit RESET = P1^6; //reset du CC2420
    sbit VREGEN = P1^7; //fixe un niveau de tension
    sbit SFD = P1^0; //reception

    sbit BP = P3^0; //definition du bouton1 sur port3
    sbit BP2 = P3^1; // " " du bouton2 " "
    sbit LED = P1^1; //definition de la led sur port 1
    sbit LEDTX = P2^0; // " " de la led pour TX sur port2
    sbit LEDRX = P2^1; // " " de la led pour RX " "
    sbit LEDCX = P2^7; // " " de la led pour CX " "

    /*****************************************DECLARATION SOUS PROGRAMME*************************************/
    void UART_ISR(void);
    void Test_uart();
    void wait_ms (int ms); //temporisation en ms
    void UART_TX_RX ();
    void fiche();
    void vaccin();
    void RF_RX();
    void RF_TX(char RF);
    void Test_RF();
    void SPI_Transfer (char SPI_byte);
    void SPI_TX_RX (char a,char b,char c,char d);
    void ecriture_registre_hf();
    void lecture_registre_hf();

    /**************************************DECLARATION VARIABLE********************************************/
    unsigned char ch;
    unsigned char SPI_read;
    unsigned char SPI1;
    unsigned char SPI2;
    unsigned char SPI3;
    unsigned char UART[50];

    int ts;
    int trf;
    int rf;
    int u;
    int z;

    /*********************************INITIALISATION*************************************/
    void Init_Device(void)
    {
    WDTCN = 0xDE; //Watchdog Timer Control Register (désactivé)
    WDTCN = 0xAD;

    SFRPAGE = TIMER01_PAGE; //Timer 1 UART0
    TCON = 0x40; //Timer Control Register (timer1 active)
    TMOD = 0x20; //Timer Mode Register (mode 8bits counter/timer with auto-reload)
    CKCON = 0x10; //Clock Control Register (timer1 utilise clock)
    TH1 = 0xF9; //Timer 1 High Byte

    SFRPAGE = UART0_PAGE; //UART0
    SCON0 = 0x50; //UART0 Control Register (mode 8bits UART/variable baud rate + mode reception)

    SFRPAGE = CONFIG_PAGE;
    OSCICN = 0x83; //Oscillateur interne 24,5MHz

    XBR0 = 0x04; //Pin UART0
    XBR2 = 0x40; //CrossBar
    //Config PORT PUSH-PULL
    P0MDOUT = 0x35; //Port0 Output (pin 0,2,4,5 mode push pull)
    P1MDOUT = 0xC2; //Port1 Output (pin 1,6,7 mode push pull)
    P2MDOUT = 0xFF; //Port2 Output (toutes les pin mode push pull)

    LEDCX = 1; //LedCX éteinte

    ES0 = 1; //Interruption UART0
    EA = 1; //Interruption général

    VREGEN = 1; //Activation du module CC2420
    RESET = 1;
    wait_ms(10); //tempo de 10ms
    RESET = 0;
    wait_ms(50); //tempo de 10ms
    RESET = 1;
    SCK = 0;

    wait_ms(50); //tempo 50ms
    SPI_TX_RX (0x01,0x00,0x00,1); //Oscillateur CC2420
    wait_ms(50); //tempo 50ms
    SPI_TX_RX (0x03,0x00,0x00,1);

    LED = 0; //Led allume
    ts = 1;
    trf = 1;

    }

    /**************************************PROGRAMME PRINCIPAL******************************************/
    void main ()
    {

    Init_Device(); //initialisation

    while (1) //boucle
    {
    if (SFD == 1) //si mode reception activé
    {
    while(!(SFD == 0)); //tant que mode reception activé
    RF_RX(); //appel de RF_RX : buffer recoi les données recue
    }
    else
    {
    if (BP == 0) //si BP appuyé
    {
    wait_ms(1); //tempo 1ms
    while(!(BP == 1)); //tant que BP appuyé
    RF_TX(0xA9); //appel de RF_TX : transmission de OxA9
    }
    else;
    }
    SFRPAGE = CONFIG_PAGE;
    P2=0xff;
    }
    }

    /***************************************PROGRAMME INTERRUPTION UART******************************************/
    void UART_ISR(void) interrupt 4
    {
    EA = 0;
    if (RI0 == 1)
    {
    SFRPAGE = UART0_PAGE;
    RI0 = 0;
    ch = SBUF0; //ch recoit le contenu du buffer
    switch (ts)
    {
    case 0 : //Réception des 3 caractéres UART
    UART_TX_RX ();
    u++;
    break;

    case 1 : //Réception du caractére UART pour test
    Test_uart(); //appel de test_uart
    break;

    case 2 : //Réception du caractére UART vers RF
    RF_TX(ch);
    ts = 1;
    break;

    case 3 : //Réception des caractéres fiche UART vers RF
    fiche();
    z++;
    break;

    case 4 : //Réception des caractéres vaccin UART vers RF
    vaccin();
    z++;
    break;

    case 5 :
    lecture_registre_hf(); //Réception du caractére pour lir registre autonome
    z++;
    break;

    case 6 : //Réception du caractére pour lir registre autonome
    ecriture_registre_hf();
    z++;
    break;

    }
    }
    else TI0 = 0;
    EA = 1;
    }

    /*************************************PROGRAMME SAUVEGARDE DES DONNEES*********************************/
    void UART_TX_RX ()
    {
    if (u == 0)
    {
    SPI1 = ch;
    }
    if (u == 1)
    {
    SPI2 = ch;
    }
    if (u == 2)
    {
    SPI3 = ch;
    ts = 1;
    }
    }

    /***************************************PROGRAMME TEST UART**********************************************/
    void Test_uart()
    {
    switch (ch)
    {
    case 0x81 :
    SBUF0 = 0x80; //Test connexion
    break;

    case 0x91 : //Réception des 3 commandes pour lire ou ecrire dans registre
    ts = 0;
    u = 0;
    break;

    case 0x92 : //Emission des données UART recut vers CC2420
    SPI_TX_RX (SPI1,SPI2,SPI3,3);
    break;

    case 0x93 : //Emission des données CC2420 recut vers UART
    SFRPAGE = UART0_PAGE;
    SBUF0 = 0x90;
    wait_ms(1);
    SBUF0 = SPI1;
    wait_ms(1);
    SBUF0 = SPI2;
    wait_ms(1);
    SBUF0 = SPI3;
    break;

    case 0x95 : //Reset du module CC2420
    SFRPAGE = CONFIG_PAGE;
    RESET = 0;
    wait_ms(10);
    RESET = 1;
    wait_ms(10);
    break;

    case 0xA1 : //Réception du caractére à envoyer sur liaison RF
    ts = 2;
    break;

    case 0xA2 : //Réception des 28 caractéres à envoyer sur liaison RF
    ts = 3;
    z=0;
    break;

    case 0xA3 : //Réception des 9 caractéres à envoyer sur liaison RF
    ts = 4;
    z=0;
    break;

    case 0xA6 : //Réception du carctere registre lecture rf
    ts = 5;
    z=0;
    break;

    case 0xA7 : //Réception des carcteres registre ecriture rf
    ts = 6;
    z=0;
    break;

    default :
    SFRPAGE = UART0_PAGE;
    SBUF0 = 0x00;
    } // fin switch
    }

    /****************************************LECTURE REGISTRE*************************************************/
    void lecture_registre_hf()
    {
    if (z < 5)
    {
    UART[z] = ch;
    }
    if (z == 4)
    {
    for (z = 0; z < 5; z++)
    {
    RF_TX(UART[z]);
    wait_ms(10);
    }
    ts = 1;
    } //Réception du caractére pour lire registre autonome

    }

    /***********************************ECRITURE REGISTRE********************************************/
    void ecriture_registre_hf()
    {
    if (z < 5)
    {
    UART[z] = ch;
    }
    if (z == 4)
    {
    for (z = 0; z < 5; z++)
    {
    RF_TX(UART[z]);
    wait_ms(10);
    }
    ts = 1;
    }
    }

    /***************************************FICHE?**********************************/
    void fiche()
    {
    if (z < 29)
    {
    UART[z] = ch;
    }
    if (z == 28)
    {
    RF_TX(0xff);
    wait_ms(10);
    RF_TX(0xa8);
    wait_ms(10);
    for (z = 0; z < 29; z++)
    {
    RF_TX(UART[z]);
    wait_ms(10);
    }
    ts = 1;
    }
    }

    /***************************************VACCIN*****************************************/
    void vaccin()
    {
    if (z < 12)
    {
    UART[z] = ch;
    }
    if (z == 11)
    {
    for (z = 0; z < 12; z++)
    {
    RF_TX(UART[z]);
    wait_ms(10);
    }
    ts = 1;
    }
    }

    /***************************************RF Emission***************************************/
    void RF_TX(char RF)
    {
    LEDTX=0; //allume LedTX
    SPI_TX_RX (0x3e,RF,0x00,3); //transfert de 0x3E , RF (0xA9) et 0X00
    wait_ms(10); //tempo 10ms
    SPI_TX_RX (0x04,0x00,0x00,1); //transfert de Ox04
    wait_ms(10); //tempo de 10ms
    SPI_TX_RX (0x09,0x00,0x00,1); //transfert de 0x09
    }

    /******************************************RF Reception************************************/
    void RF_RX()
    {
    LEDRX=0; //allume LedRX
    SPI_TX_RX (0x7f,0x00,0x00,2); //tranfert de 0x7f et 0x00
    SPI_TX_RX (0x8,0x00,0x00,1); //tranfert de 0x8
    SFRPAGE = UART0_PAGE;
    SBUF0 = SPI2; //buffer recoit SPI2
    }

    /*************************************************SPI*******************************************/
    void SPI_TX_RX (char a,char b,char c,char d)
    {
    int i;
    NSS = 0; //signal d'activation à 0
    for (i = 0; i < d; i++) //
    {
    if (i == 0)
    {
    SPI_Transfer (a); //transfert de a
    SPI1 = SPI_read; //SPI1 recoit Miso
    }
    if (i == 1)
    {
    SPI_Transfer (b); //transfert de b
    SPI2 = SPI_read; //SPI2 recoit
    }
    if (i == 2)
    {
    SPI_Transfer (c);
    SPI3 = SPI_read;
    }
    }
    NSS = 1;
    }

    /********************************************SPI TRANSFERT*************************************/
    void SPI_Transfer (char SPI_byte)
    {
    unsigned char SPI_count;
    for (SPI_count = 8; SPI_count > 0; SPI_count--)
    {
    MOSI = SPI_byte & 0x80; // ET logique avec 0X80
    SPI_byte = SPI_byte << 1; //décalage de 1 vers la gauche
    SCK = 0x01;
    SPI_read = SPI_read << 1; //décalage de 1 vers la gauche
    SPI_read |= MISO; // ou inclusif Spi_read avec miso
    SCK = 0x00;
    }
    }

    /************************************************TEMPORISATION***************************************/
    void wait_ms(int ms)
    {
    SFRPAGE = TMR2_PAGE;

    TMR2CN = 0x00;
    TMR2CF = 0x00;

    RCAP2 = -(SYSCLK/1000/12);
    TMR2 = RCAP2;

    ET2 = 0;

    TR2 = 1;

    while(ms)
    {
    TF2 = 0;
    while(!TF2);
    ms--;
    }

    TR2 = 0;
    }
    3
  2. Nabla's Messages postés 18201 Date d'inscription   Statut Contributeur Dernière intervention   3 228
     
    pourrais tu nous envoyer le code en question... sinon, personne ne pourra l'expliquer !
    0
  3. Pocamulan
     
    Le programme précedent est le code charger dans le module relié au pc
    j'en ai un autre pour le module autonome ki envoie les informations
    0
  4. dgidgis
     
    Salut!

    Je suis en train de réaliser un programme comme toi avec 2 module Zigbee avec antennes et ils doivent échanger des datas!!!le problème est que je ne trouve pas un bon logiciel pour programmer!!!tu parle dans ton message de Silicon Laboratory!!!où le trouve tu?pourrai tu me le passer ou me donner le moyen de le trouver?je t'en serai très reconnaissant
    0

Discussions similaires

Manuel de programmation autocommutateur LG
csf -
MOLLA -

5 réponses
code sur digicode extel
bridadad -
Anibal -

3 réponses
standard LG aria soho
djo -
redsam -

2 réponses
Programme caisse Casio vr200
JulienDag23. -
quentin2121 -

8 réponses