Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur l'Assembleur !

Modérateur : mazertoc

transmission uhf
JMarc
Passioné
Passioné
Messages : 488
Enregistré en : août 2016
Localisation : Dans le Sud...

#1 Message par JMarc » lun. 27 févr. 2017 19:53

Bonsoir


ci joint le programme a mettre dans le pic emeteur qui envoie une chaine de caractères toute les 3 secondes avec un caractère qui change a chaque fois

ci cela peut servir dehors!!

dehors!!

Code : Tout sélectionner


                                             
;*****************************************************************************
;
                                                                            *
;
    NOM:      emmission tx                                                         *
;
    Date:     26/02/2017                                                    *
;
    Version:  1.1                                                           *
;
    Circuit:  Platine d'expérimentation                                     *
;    Auteur:   pris des morceaux de partout et modifié par JM                                       *
;                                                                            *
;*****************************************************************************
;                                                                            *
;    Fichier requis: P16F877.inc                                             *
;                                                                            *
;*****************************************************************************
;                                                                            *
;    La liaison s'
effectue au travers d'un MAX232                            *
;    1 start-bit, 8 bits de donnée, 0 bit de parité paire, 1 stop-bit        *
;    Liaison en 9600 bauds (9615 bauds réels)                                *
;    Utilisation du module USART                                             *
;    Le PIC travaille à 4 MHz                                                *
;*****************************************************************************


    LIST      p=16F877            ; Définition de processeur
    #include <p16F877.inc>        ; fichier include
    radix dec                      ; on travaille en décimal par défaut

    __CONFIG   _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_OFF & _CPD_OFF & _LVP_OFF & _BODEN_OFF & _PWRTE_ON & _WDT_OFF & _HS_OSC 
   ;_CP_OFF        Pas de protection
        ;_DEBUG_OFF        RB6 et RB7 en utilisation normale
        ;_WRT_ENABLE_OFF    Le programme ne peut pas écrire dans la flash
        ;_CPD_OFF               Mémoire EEprom déprotégée
        ;_LVP_OFF        RB3 en utilisation normale
        ; _BODEN_OFF        Reset tension hors service
        ;_PWRTE_ON        Démarrage temporisé
        ;_WDT_OFF        Watchdog hors service
        ;_HS_OSC        Oscillateur haute vitesse (4Mhz<F<20Mhz)

;*****************************************************************************
;                               ASSIGNATIONS SYSTEME                         *
;*****************************************************************************

; REGISTRE OPTION_REG (configuration)
; -----------------------------------
OPTIONVAL    EQU    B'
10001111'
            ; RBPU     b7 : 1= Résistance rappel +5V hors service
            ; PSA      b3 : 1= Assignation prédiviseur sur Watchdog
            ; PS2/PS0  b2/b0 valeur du prédiviseur = 128


;*****************************************************************************
;                           ASSIGNATIONS PROGRAMME                           *
;*****************************************************************************
;   (4000000/(9600*16))-1
;   (4000000/153600)-1 = 25,0416 nous prendrons 25
BRGVAL    EQU    D'
25'    ; pour un débit de 9615 bauds en mode high-speed
;**********************************************************************


;***** Variable de temporisation
tempo50µ    EQU    0x20        ; Variable tempo 50 µs
tempo10ms    EQU    0x21        ; Variable tempo 10 ms
tempo1s        EQU    0x22        ; Variable tempo 1s

;*****************************************************************************
;                             MACRO                                          *
;*****************************************************************************
;*********************** MACROS ************************************************
Banque0    MACRO
    BCF STATUS,RP0            ;Acces bank0
    BCF STATUS,RP1
    ENDM

Banque1    MACRO
    BSF STATUS,RP0            ;Acces bank1
    BCF STATUS,RP1
    ENDM

Banque2    MACRO
    BCF STATUS,RP0            ;acces bank2
    BSF STATUS,RP1
    ENDM

Banque3    MACRO
    BSF STATUS,RP0            ;Acces bank4
    BSF STATUS,RP1
    ENDM   



;*****************************************************************************
MESS    macro    a1,a2,a3,a4    ; inscrit le message dans bufout
    BANKSEL    bufout        ; passer en banque 3
      movlw    "["        ; mettre crochet
    movwf    bufout        ; dans bufout
    movlw    a1        ; charger argument 1
    movwf    bufout+1    ; dans bufout
    movlw    a2        ; charger argument 2
    movwf    bufout+2    ; dans bufout
    movlw    a3        ; charger argument 3
    movwf    bufout+3    ; dans bufout
    movlw    a4        ; charger argument 4
    movwf    bufout+4    ; dans bufout
    movlw    "]"        ; mettre crochet
    movwf    bufout+5    ; dans bufout
    movlw    0x0D        ; charger carriage return
    movwf    bufout+6    ; dans bufout
    movlw    0x0A        ; charger line-feed
    movwf    bufout+7    ; dans bufout
    BANKSEL    0        ; repasser banque 0
     endm

;*****************************************************************************
;                        VARIABLES BANQUE 0                                  *
;*****************************************************************************

; Zone de 80 bytes
; ----------------

    CBLOCK    0x20        ; Début de la zone (0x20 à 0x6F)


;***** Variable de temporisation
    tempo50µ   :1       ; Variable tempo 50 µs
    tempo10ms   :1        ; Variable tempo 10 ms
    tempo1s    :1      ; Variable tempo 1s

    
    ptr1 : 1        ; pointeur temporaire 1
    ptr2 : 1        ; pointeur temporaire 2
    octemp : 1        ; sauvegarde temporaire
 
        ENDC            ; Fin de la zone                        

;*****************************************************************************
;                      VARIABLES ZONE COMMUNE                                *
;*****************************************************************************

; Zone de 16 bytes
; ----------------

    CBLOCK 0x70        ; Début de la zone (0x70 à 0x7F)
    w_temp : 1        ; Sauvegarde registre W
    status_temp : 1        ; sauvegarde registre STATUS
    FSR_temp : 1        ; sauvegarde FSR (si indirect en interrupt)
    PCLATH_temp : 1        ; sauvegarde PCLATH (si prog>2K)
    bufinptr : 1        ; pointeur sur caractère courant buffer entrée
    bufoutptr : 1        ; pointeur sur caractère courant buffer sortie
    flags : 1        ; flags divers
                ; b0 : parité calculée
                ; b1 : erreur de parité
                ; b2 : erreur de frame
                ; b3 : erreur overflow
    local1 : 1        ; variable locale pour interruptions
   ComptSu : 1    

    ENDC

#DEFINE PARITE    flags,0        ; parité calculée
#DEFINE ER_PAR    flags,1        ; erreur de parité
#DEFINE    ER_FR    flags,2        ; erreur de frame
#DEFINE    ER_OV    flags,3        ; erreur d'
overflow

;*****************************************************************************
;
                        VARIABLES BANQUE 2                                  *
;*****************************************************************************

;
 Zone de 96 bytes
; ----------------

    CBLOCK    0x110        ; Début de la zone (0x110 à 0x16F)
    bufin : D'96'        ; zone de stockage des données entrées

    ENDC            
; Fin de la zone                        

;*****************************************************************************
;
                        VARIABLES BANQUE 3                                  *
;*****************************************************************************

;
 Zone de 96 bytes
; ----------------

    CBLOCK    0x190        ; Début de la zone (0x190 à 0x1EF)
    bufout : D'96'        ; message à envoyer
    ENDC            
; Fin de la zone                        

;*****************************************************************************
;
                      DEMARRAGE SUR RESET                                   *
;*****************************************************************************

    org 0x000         ; Adresse de départ après reset
     goto    init        
; Initialiser


; ////////////////////////////////////////////////////////////////////////////

;                         I N T E R R U P T I O N S

; ////////////////////////////////////////////////////////////////////////////

;*****************************************************************************
;
                     ROUTINE INTERRUPTION                                   *
;*****************************************************************************
;-----------------------------------------------------------------------------
;
 La suppression des lignes "goto restorereg" permet dans ce cas de traiter
; l'interruption sur réception et sur émission en une seule fois
;-----------------------------------------------------------------------------

            ;sauvegarder registres    
            ;---------------------
    org 0x004        ; adresse d'
interruption
    movwf   w_temp      
; sauver registre W
    swapf    STATUS
,w    ; swap status avec résultat dans w
    movwf    status_temp    
; sauver status swappé
    movf    FSR 
, w        ; charger FSR
    movwf    FSR_temp    
; sauvegarder FSR

            
; switch vers différentes interrupts
            
;-----------------------------------
    
            
; Interruption réception USART
            
; ----------------------------

    BANKSEL    PIE1        ; sélectionner banque 1
    btfss    PIE1
,RCIE    ; tester si interrupt autorisée
    goto     intsw1        
; non sauter
    bcf    STATUS
,RP0    ; oui, sélectionner banque0
    btfss    PIR1
,RCIF    ; oui, tester si interrupt en cours
    goto     intsw1        
; non sauter
    call    intrc        
; oui, traiter interrupt

            
; Interruption transmission USART
            
; -------------------------------
intsw1
    bsf    STATUS
,RP0    ; sélectionner banque1
    btfss    PIE1
,TXIE    ; tester si interrupt autorisée
    goto     restorereg    
; non sauter
    bcf    STATUS
,RP0    ; oui, sélectionner banque0
    btfss    PIR1
,TXIF    ; oui, tester si interrupt en cours
    goto     restorereg    
; non sauter
    call    inttx        
; oui, traiter interrupt

            
;restaurer registres
            
;-------------------
restorereg
    movf    FSR_temp 
, w    ; charger FSR sauvé
    movwf    FSR        
; restaurer FSR
    swapf    status_temp
,w    ; swap ancien status, résultat dans w
    movwf   STATUS        
; restaurer status
    swapf   w_temp
,f    ; Inversion L et H de l'ancien W
                               ; sans modifier Z
    swapf   w_temp,w      ; Réinversion de L et H dans W
                ; W restauré sans modifier status
    retfie          ; return from interrupt

;*****************************************************************************
;                     INTERRUPTION RECEPTION USART                           *
;*****************************************************************************
;-----------------------------------------------------------------------------
; Reçoit le caractère de l'
USART et le place dans le buffer d'entrée.
; Si la longueur atteint D'
94', on n'encode plus, et on place 0x0D en avant-
;
 dernière position et 0x0A en dernière position
; Si la réception est terminée (longueur atteinte ou 0x0A reçu), on stoppe les
; interruptions de réception et on repositionne le pointeur au début du buffer
; Les erreurs sont détectées et signalées
;-----------------------------------------------------------------------------
intrc
            
; tester si erreur de frame
            
; -------------------------    
    btfsc    RCSTA
,FERR    ; tester si erreur de frame
    bsf    ER_FR        
; oui, signaler erreur de frame

            
; lire la parité
            
; --------------
;
    bcf    PARITE        ; par défaut, parité = 0
;    btfsc    RCSTA,RX9D    ; parité lue = 1?
;
    bsf    PARITE        ; oui, le signaler

            
; lire octet reçu
            
; ---------------
    bsf    STATUS,IRP    ; pointer banques 2 et 3 en indirect
    movf    bufinptr
,w    ; charger pointeur destination
    movwf    FSR        
; dans pointeur d'adresse
    movf    RCREG,w        ; charger octet reçu
    movwf    INDF        ; sauver dans buffer

            ; vérifier la parité
            ; ------------------
intrc1
;    movf    INDF,w        ; charger caractère reçu
;    call    calcpar        ; calculer la parité
;    movf    RCSTA,w        ; charger registre commande
;    xorwf    flags,w        ; comparer parité reçue et calculée
;    andlw    0x01        ; ne garder que le résultat
;    btfss    STATUS,Z    ; b0 = b1? (parité calculée = parité reçue?)
;    bsf    ER_PAR        ; non, signaler erreur de parité

            ; tester si erreur d'
overflow
            
; ---------------------------
    btfsc    PIR1,RCIF    ; encore d'autres octets dans RCREG?
    goto    intrc2        ; oui, vérifier caractère
    btfss    RCSTA,OERR    ; non, erreur d'
overflow?
    goto    intrc2        ; non, vérifier caractère
    bcf    RCSTA
,CREN    ; oui, arrêt de la réception (reset de OERR)
    bsf    RCSTA,CREN    ; remise en service de la réception
    bsf    ER_OV        
; signaler erreur overflow
    goto    intrcend    
; et fin d'interruption

            ; tester si caractère reçu = 0x0A
            ; -------------------------------
intrc2
    movf    INDF,w        ; charger caractère reçu
    xorlw    0x0A        ; comparer avec line-feed
    btfsc    STATUS,Z    ; identique?
    goto    intrcend    ; oui, fin de message

            ; vérifier si buffer plein
            ; ------------------------
    incf    bufinptr,f    ; incrémenter pointeur de caractères
    movf    FSR,w        ; charger pointeur
    xorlw    0x6D        ; comparer avec dernièr emplacement possible
    btfss    STATUS,Z    ; identique?
    return            ; non, fin de réception
    incf    FSR,f        ; pointeur sur emplacement suivant
    movlw    0x0D        ; mettre carriage-return
    movwf    INDF        ; en avant-dernière position
    incf    FSR,f        ; pointer sur dernière position
    movlw    0x0A        ; charger line-feed
    movwf    INDF        ; en dernière position

            ; fin de message
            ; --------------
intrcend
    movlw    LOW bufin    ; oui, adresse de départ du buffer d'
entrée
    movwf    bufinptr    
; prochain caractère sera le premier
    bsf    STATUS
,RP0    ; passer banque 1
    bcf    PIE1
,RCIE    ; fin des interruptions de réception
    bcf    STATUS
,RP0    ; repasser banque 0
    return            
; et retour


;*****************************************************************************
;
                     INTERRUPTION EMISSION USART                            *
;*****************************************************************************
;-----------------------------------------------------------------------------
;
 envoie le caractère pointé par bufoutptr, puis incrémente le pointeur
; Si ce caractère est le "line-feed", alors on arrête l'émission et on pointe de
; nouveau au début du buffer
;-----------------------------------------------------------------------------
inttx
            ; prendre octet à envoyer
            ; -----------------------

    bsf    STATUS,IRP    ; pointer banques 3 et 4
    movf    bufoutptr,w    ; charger pointeur d'
octets
    movwf    FSR        
; dans pointeur
    movf    INDF
,w        ; charger octet à envoyer

            
; calculer parité
            
; ---------------
;
    call    calcpar        ; calculer parité
;    bsf    STATUS,RP0    ; passer banque1
;    bcf    TXSTA,TX9D    ; par défaut, parité = 0
;    btfsc    PARITE        ; parité = 1?
;
    bsf    TXSTA,TX9D    ; oui, positionner parité

            
; envoyer octet
            
; -------------
    movf    INDF,w        ; charger octet à envoyer
    bcf    STATUS
,RP0    ; passer banque 0
    movwf    TXREG        
; envoyer octet + parité
    incf    bufoutptr
,f    ; pointer sur octet suivant

            
; tester si dernier octet
            
; -----------------------
    xorlw    0x0A        ; comparer octet envoyé avec Line-feed
    btfss    STATUS
,Z    ; égalité?
    return            ; non, retour d'interruption

            ; traiter fin d'
émission
            
; ----------------------
    bsf    STATUS,RP0    ; passer en banque 1
    bcf    PIE1
,TXIE    ; fin des interruptions émission USART
    bcf    STATUS
,RP0    ; repasser banque 0
    movlw    LOW bufout    
; adresse du buffer de sortie
    movwf    bufoutptr    
; prochain caractère = premier
    return            
; fin d'interruption



; ////////////////////////////////////////////////////////////////////////////
;                           P R O G R A M M E
; ////////////////////////////////////////////////////////////////////////////

;*****************************************************************************
;                          INITIALISATIONS                                   *
;*****************************************************************************
init

            ; Registre d'
options (banque 1)
            ; -----------------------------
    BANKSEL    OPTION_REG    ; sélectionner banque 1
    movlw    OPTIONVAL    
; charger masque
    movwf    OPTION_REG    
; initialiser registre option

            
; registres interruptions (banque 1)
            ; ----------------------------------
    bsf    INTCON,PEIE    ; autoriser interruptions périphériques

            
; initialiser USART
            
; -----------------
    movlw    B'00000100'    ; émission sur 8 bits, mode haute vitesse
    movwf    TXSTA        
; dans registre de contrôle
    movlw    BRGVAL        
; valeur pour baud rate generator
    movwf    SPBRG        
; dans SPBRG
    bcf    STATUS
,RP0    ; passer banque 0
    movlw    B
'10000000'    ; module USART en service, réception 8 bits
    movwf    RCSTA        
; dans registre de contrôle

            
; Initialiser message de bienvenue
            
; --------------------------------
    MESS    "P","R","E","T"    ; inscrire PRET dans le buffer de sortie

            
; initialiser variables
            
; ---------------------
    clrf    flags        ; effacer flags
    movlw    LOW bufin    
; adresse du buffer de réception
    movwf    bufinptr    
; dans pointeur
    movlw    LOW bufout    
; adresse basse du buffer d'émission
    movwf    bufoutptr    ; dans pointeur

            ; autoriser interruptions (banque 0)
            ; ----------------------------------

    bsf    INTCON,GIE    ; valider interruptions
    goto    start        ; programme principal

;*****************************************************************************
;                      PREPARER LA REPONSE                                   *
;*****************************************************************************
;-----------------------------------------------------------------------------
; copie le buffer d'
entrée inversé dans le buffer de sortie
; en modifiant cette sous-routine, vous pouvez changer le fonctionnement
; de votre programme. Vous pouvez inventer ici de nouvelles règles de 
; réponse
;-----------------------------------------------------------------------------
preprep
            
; rechercher la fin du message
            
; ----------------------------

    movlw    LOW bufin-1    ; pointer sur début du message-1
    movwf    FSR        
; dans pointeur
    bsf    STATUS
,IRP    ; pointer banques 3 et 4 en indirect
prep1
    incf    FSR
,f        ; pointer sur suivant
    movf    INDF
,w        ; charger caractère
    xorlw    0x0A        
; comparer avec line-feed
    btfss    STATUS
,Z    ; tester si car = 0x0A
    goto    prep1        
; non, suivant
    decf    FSR
,w        ; oui, prendre pointeur trouvé-1
    movwf    ptr1        
; sauver dans pointeur temporaire1

            
; traiter ligne vide
            
; ------------------
    xorlw    0x10        ; tester position pointeur
    btfss    STATUS
,Z    ; ligne vide?
    goto    prep3        ; non, sauter
    MESS    
"V","I","D","E"    ; inscrire "vide dans le buffer de sortie
    return            ; fin du traitement

            ; copier message inversé
            ; ----------------------
prep3
;*********************************************************************************
    



;*****************************************************************************
;                      PROGRAMME PRINCIPAL                                   *
;*****************************************************************************

start
        ; lancer l'émission, message de bienvenue
        ; ---------------------------------------

    bsf    STATUS,RP0    ; passer en banque 1
    bcf STATUS,RP1
    bsf    TXSTA,TXEN    ; émission en service.
    bsf    PIE1,TXIE    ; envoyer message "
pret"


            ; attendre fin de l'émission
            ; --------------------------
    clrwdt            ; effacer watch dog
    btfsc    PIE1,TXIE    ; reste des caractères à envoyer?
    goto    $-2        ; oui, attendre
    btfss    TXSTA,TRMT    ; buffer de sortie vide?
    goto    $-4        ; non, attendre

            ; revevoir le message
            ; -------------------
    bsf    STATUS,RP0    ; passer banque 1
loop

    

    ; Attendre fin émission précédente
        ; --------------------------------
    clrwdt            ; effacer watchdog
    btfsc    PIE1,TXIE    ; message précédent envoyé?
    goto    $-2        ; non, attendre
    btfss    TXSTA,TRMT    ; buffer de sortie vide?
    goto    $-4        ; non, attendre

            ; traiter erreurs
            ; ----------------
    movf    flags,w        ; charger flags
    andlw    B'00001110'    ; conserver flags d'erreur
    btfsc    STATUS,Z    ; tester si au moins une erreur
    goto    messprep    ; non, traitement normal

    btfss    ER_PAR        ; tester si erreur de parité
    goto    err2        ; non, sauter
    MESS    "
P","A","R"," "    ; écrire "PAR" dans le buffer de sortie
    bcf    ER_PAR        ; acquitter l'erreur
err2
    btfss    ER_FR        ; tester si erreur de frame
    goto    err3        ; non, sauter
    MESS    "
F","E","R","R"    ; écrire "FERR" dans le buffer de sortie
    bcf    ER_FR        ; acquitter l'erreur
err3
    btfss    ER_OV        ; tester si erreur d'overflow
    goto    msuite        ; envoyer le message
    MESS    "
O","E","R","R"    ; écrire "OERR" dans le buffer de sortie
    bcf    ER_OV        ; acquitter l'erreur
    goto    msuite        ; envoyer message d'erreur

        ; traitement normal du message
        ; ----------------------------
messprep
    bcf    STATUS,RP0    ; passer banque 0



msuite

    
            ; envoyer réponse
            ; ---------------


    MESS    "
J","M","P","1"
    BANKSEL ComptSu
    decf    ComptSu,f
    movfw   ComptSu
    BANKSEL bufout
    movwf   bufout+4
    BANKSEL 0
        ; pause de 1 s
    CALL    Wait1s

    bsf    STATUS,RP0    ; passer banque 1
    bsf    PIE1,TXIE    ; lancer le message

   


    goto    loop        ; traiter message suivant


;**********************************************************************
;                                                                     *
;    Les pauses a 20Mhz                                        *
;                                                                     *
;                                                                     *
;**********************************************************************


;***** Attente de 1 s (exactement 1.00204 s)
Wait1s
        MOVLW    D'99'        ;    99 fois
        MOVWF    tempo1s        ; stockage dans la variable tempo1s
T1sboucle    CALL    Wait10ms
        DECFSZ    tempo1s,1    ; décremente et test
        GOTO    T1sboucle    ; on boucle tant que <>0  
        RETURN

;***** Attente de 15 ms (exactement 14.99 ms)
Wait15ms
        MOVLW    D'149'        ;    149 fois
        MOVWF    tempo10ms    ; stockage dans la variable tempo10ms
T15msboucle    CALL    Wait100µs
        DECFSZ    tempo10ms,1    ; décremente et test
        GOTO    T15msboucle    ; on boucle tant que <>0
        RETURN


;***** Attente de 10 ms (exactement 10.02 ms)
Wait10ms
        MOVLW    D'198'        ;    198 fois
        MOVWF    tempo10ms    ; stockage dans la variable tempo10ms
T10msboucle    CALL    Wait50µs
        DECFSZ    tempo10ms,1    ; décremente et test
        GOTO    T10msboucle    ; on boucle tant que <>0
        RETURN

;***** Attente de 1.5 ms (exactement ? ms)
Wait1.5ms
        MOVLW    D'29'        ;    29 fois
        MOVWF    tempo10ms    ; stockage dans la variable tempo10ms
T1.5msboucle    CALL    Wait50µs
        DECFSZ    tempo10ms,1    ; décremente et test
        GOTO    T1.5msboucle    ; on boucle tant que <>0
        RETURN

;***** Attente de 100 µs (exactement, en comptant le temps d'appel)
Wait100µs    
        MOVLW    D'165'        ;    165 fois
        MOVWF    tempo50µ    ; stockage dans la variable tempo50µ
T100µsboucle    DECFSZ    tempo50µ,1    ; décremente et test
        GOTO    T100µsboucle    ; on boucle tant que <>0  0.2*3=0.6 µs en tout
        RETURN


;***** Attente de 50 µs (exactement, en comptant le temps d'appel)
Wait50µs    NOP
        NOP
        MOVLW    D'81'        ;    81 fois
        MOVWF    tempo50µ    ; stockage dans la variable tempo50µ
T50µsboucle    DECFSZ    tempo50µ,1    ; décremente et test
        GOTO    T50µsboucle    ; on boucle tant que <>0  0.2*3=0.6 µs en tout
        RETURN


;***** Attente de 1 µs (exactement, en comptant le temps d'appel)
Wait1µs        NOP
        RETURN



    END             ; directive fin de programme


transmission uhf
JMarc
Passioné
Passioné
Messages : 488
Enregistré en : août 2016
Localisation : Dans le Sud...

#2 Message par JMarc » lun. 27 févr. 2017 19:54

et ici le code du recepteur qui envoie la chaine recu sur un afficheur LCD 2 lignes

Code : Tout sélectionner

;*****************************************************************************
;                                                                            *
;    
NOM:      RS232                                                         *
;    
Date:     26/02/2017                                                    *
;    
Version:  1.1                                                           *
;    
Circuit:  Platine d'expérimentation                                     *
;    Auteur:   pris des morceaux de partout et modifié par JM                                       *
;                                                                            *
;*****************************************************************************
;                                                                            *
;    Fichier requis: P16F877.inc                                             *
;                                                                            *
;*****************************************************************************
;                                                                            *
;    La liaison s'
effectue au travers d'un MAX232 pour le port rs232
;    ou bien en direct pour un autre pic                                     *
;    1 start-bit, 8 bits de donnée, 0 bit de parité paire, 1 stop-bit        *
;    Liaison en 9600 bauds                                 *
;    Utilisation du module USART                                             *
;    Le PIC travaille à 4 MHz                                                *
;*****************************************************************************

;*****************************************************************************
;   Exemple de communication série asynchrone.                               *
;   Communication avec le port RS232 d'
un PC.                                *
;   
Le programme reçoit une série de caractères (maximum 96)                 *
;   
Il répond par la chaine de caractères inversée.                          *
;   
La fin de la chaine est détectée par le caractère "line-feed" (0x0A)     *
;  

;   
rajout d'un module lcd
;  Brochage du PIC sur la carte :
;
;  Port | Broche | E/S | Nom             | Description
;       |        |     |                 | Port D affecté à la commande de LCD
;  RD0  |    19  |  S  | RS         | Sortie Broche RS du LCD 
;  RD1  |    20  |  S  | R/W         | Sortie Broche Read/write du LCD
;  RD2  |    21  |  S  | E         | Sortie broche Enable du LCD
;  RD3  |    22  |     |                 | NC
;  RD4  |    27  |  S  | DB4          | Sortie bit 4 du LCD
;  RD5  |    28  |  S  | DB5             | Sortie bit 5 du LCD
;  RD6  |    29  |  S  | DB6           | Sortie bit 6 du LCD
;  RD7  |    30  |  S  | DB7         | Sortie bit 7 du LCD


;                                                                          *


    LIST      p=16F877            ; Définition de processeur
    #include <p16F877.inc>        ; fichier include
    radix dec                      ; on travaille en décimal par défaut

    __CONFIG   _CP_OFF & _DEBUG_OFF & _WRT_ENABLE_OFF & _CPD_OFF & _LVP_OFF & _BODEN_OFF & _PWRTE_ON & _WDT_OFF & _HS_OSC 
   ;_CP_OFF        Pas de protection
        ;_DEBUG_OFF        RB6 et RB7 en utilisation normale
        ;_WRT_ENABLE_OFF    Le programme ne peut pas écrire dans la flash
        ;_CPD_OFF               Mémoire EEprom déprotégée
        ;_LVP_OFF        RB3 en utilisation normale
        ; _BODEN_OFF        Reset tension hors service
        ;_PWRTE_ON        Démarrage temporisé
        ;_WDT_OFF        Watchdog hors service
        ;_HS_OSC        Oscillateur haute vitesse (4Mhz<F<20Mhz)

;*****************************************************************************
;                               ASSIGNATIONS SYSTEME                         *
;*****************************************************************************

; REGISTRE OPTION_REG (configuration)
; -----------------------------------
OPTIONVAL    EQU    B'
10001111'
            ; RBPU     b7 : 1= Résistance rappel +5V hors service
            ; PSA      b3 : 1= Assignation prédiviseur sur Watchdog
            ; PS2/PS0  b2/b0 valeur du prédiviseur = 128


;*****************************************************************************
;                           ASSIGNATIONS PROGRAMME                           *
;*****************************************************************************
;   (4000000/(9600*16))-1
;   (4000000/153600)-1 = 25,0416 nous prendrons 25
BRGVAL    EQU    D'
25'    ; pour un débit de 9615 bauds en mode high-speed
;**********************************************************************
;                                                                     *
;   autres Defines                                                  *
LCD_DATA_PORT    EQU    PORTD        ; le port du LCD
LCD_DATA_TRIS    EQU    TRISD        ; la config du port du LCD

LCD_RS        EQU    0        ; Sortie Broche RS du LCD 
LCD_RS_VALUE    EQU    1        ;  correspond a 1 en decimal
LCD_RW        EQU    1        ; Sortie Broche Read/write du LCD
LCD_E        EQU    2        ; Sortie broche Enable du LCD
;**************************************************************************

 ;***** LCD Config
LCD_SET_MATRIX    EQU    0        ; 1 -> Matrices de 5*11, 0 -> Matrices de 5*8 (defaut 0)
LCD_SET_DISPLAY    EQU    1        ; 1 -> Display LCD On, 0 -> Display LCD Off (defaut 1)
LCD_SET_CURSOR    EQU    1        ; 1 -> Cursor On, 0 -> Cursor Off (defaut 1)
LCD_SET_BLINK    EQU    0        ; 1 -> blink character at cursor position On, 0 -> Off (defaut 0)
LCD_SET_DIRECT    EQU    1        ; 1 -> to the right, 0 -> to the left (defaut 1)
LCD_SET_SCROLL    EQU    0        ; 1 -> Scroll display, 0 -> do not scroll (defaut 0)

;***** LCD Var
LCD_TEMP    EQU    0x23        ; Variable temporaire pour le LCD
LCD_CHAR    EQU    0x24        ; Variable temporaire pour les caracteres du LCD
LCD_CHAR_HEXA    EQU    0x25        ; Variable temporaire pour les nombres hexadecimaux du LCD
LCD_CMP_PRINTF    EQU    0x26        ; Compteur pour le printf

;***** Variable de temporisation
tempo50µ    EQU    0x20        ; Variable tempo 50 µs
tempo10ms    EQU    0x21        ; Variable tempo 10 ms
tempo1s        EQU    0x22        ; Variable tempo 1s

;*****************************************************************************
;                             MACRO                                          *
;*****************************************************************************
;*********************** MACROS ************************************************
Banque0    MACRO
    BCF STATUS,RP0            ;Acces bank0
    BCF STATUS,RP1
    ENDM

Banque1    MACRO
    BSF STATUS,RP0            ;Acces bank1
    BCF STATUS,RP1
    ENDM

Banque2    MACRO
    BCF STATUS,RP0            ;acces bank2
    BSF STATUS,RP1
    ENDM

Banque3    MACRO
    BSF STATUS,RP0            ;Acces bank4
    BSF STATUS,RP1
    ENDM   



;*****************************************************************************
MESS    macro    a1,a2,a3,a4    ; inscrit le message dans bufout
    BANKSEL    bufout        ; passer en banque 3
      movlw    "["        ; mettre crochet
    movwf    bufout        ; dans bufout
    movlw    a1        ; charger argument 1
    movwf    bufout+1    ; dans bufout
    movlw    a2        ; charger argument 2
    movwf    bufout+2    ; dans bufout
    movlw    a3        ; charger argument 3
    movwf    bufout+3    ; dans bufout
    movlw    a4        ; charger argument 4
    movwf    bufout+4    ; dans bufout
    movlw    "]"        ; mettre crochet
    movwf    bufout+5    ; dans bufout
    movlw    0x0D        ; charger carriage return
    movwf    bufout+6    ; dans bufout
    movlw    0x0A        ; charger line-feed
    movwf    bufout+7    ; dans bufout
    BANKSEL    0        ; repasser banque 0
     endm

;*****************************************************************************
;                        VARIABLES BANQUE 0                                  *
;*****************************************************************************

; Zone de 80 bytes
; ----------------

    CBLOCK    0x20        ; Début de la zone (0x20 à 0x6F)   
    ptr1 : 1        ; pointeur temporaire 1
    ptr2 : 1        ; pointeur temporaire 2
    octemp : 1        ; sauvegarde temporaire
 
        ENDC            ; Fin de la zone                        

;*****************************************************************************
;                      VARIABLES ZONE COMMUNE                                *
;*****************************************************************************

; Zone de 16 bytes
; ----------------

    CBLOCK 0x70        ; Début de la zone (0x70 à 0x7F)
    w_temp : 1        ; Sauvegarde registre W
    status_temp : 1        ; sauvegarde registre STATUS
    FSR_temp : 1        ; sauvegarde FSR (si indirect en interrupt)
    PCLATH_temp : 1        ; sauvegarde PCLATH (si prog>2K)
    bufinptr : 1        ; pointeur sur caractère courant buffer entrée
    bufoutptr : 1        ; pointeur sur caractère courant buffer sortie
    flags : 1        ; flags divers
                ; b0 : parité calculée
                ; b1 : erreur de parité
                ; b2 : erreur de frame
                ; b3 : erreur overflow
    local1 : 1        ; variable locale pour interruptions
   ComptSu : 1    

ENDC

#DEFINE PARITE    flags,0        ; parité calculée
#DEFINE ER_PAR    flags,1        ; erreur de parité
#DEFINE    ER_FR    flags,2        ; erreur de frame
#DEFINE    ER_OV    flags,3        ; erreur d'
overflow

;*****************************************************************************
;                        
VARIABLES BANQUE 2                                  *
;*****************************************************************************

Zone de 96 bytes
; ----------------

    
CBLOCK    0x110        Début de la zone (0x110 à 0x16F)
    
bufin D'96'        zone de stockage des données entrées

    ENDC            
Fin de la zone                        

;*****************************************************************************
;                        
VARIABLES BANQUE 3                                  *
;*****************************************************************************

Zone de 96 bytes
; ----------------

    
CBLOCK    0x190        Début de la zone (0x190 à 0x1EF)
    
bufout D'96'        message à envoyer
    ENDC            
Fin de la zone                        

;*****************************************************************************
;                      
DEMARRAGE SUR RESET                                   *
;*****************************************************************************

    
org 0x000         Adresse de départ après reset
     
goto    init        Initialiser


////////////////////////////////////////////////////////////////////////////

;                         I N T E R R U P T I O N S

////////////////////////////////////////////////////////////////////////////

;*****************************************************************************
;                     
ROUTINE INTERRUPTION                                   *
;*****************************************************************************
;-----------------------------------------------------------------------------
La suppression des lignes "goto restorereg" permet dans ce cas de traiter
l'interruption sur réception et sur émission en une seule fois
;-----------------------------------------------------------------------------

            ;sauvegarder registres    
            ;---------------------
    org 0x004        ; adresse d'
interruption
    movwf   w_temp      
sauver registre W
    swapf    STATUS
,w    swap status avec résultat dans w
    movwf    status_temp    
sauver status swappé
    movf    FSR 
w        charger FSR
    movwf    FSR_temp    
sauvegarder FSR

            
; switch vers différentes interrupts
            
;-----------------------------------
    
            ; 
Interruption réception USART
            
; ----------------------------

    
BANKSEL    PIE1        sélectionner banque 1
    btfss    PIE1
,RCIE    tester si interrupt autorisée
    
goto     intsw1        non sauter
    bcf    STATUS
,RP0    ouisélectionner banque0
    btfss    PIR1
,RCIF    ouitester si interrupt en cours
    
goto     intsw1        non sauter
    call    intrc        
ouitraiter interrupt

            
Interruption transmission USART
            
; -------------------------------
intsw1
    bsf    STATUS
,RP0    sélectionner banque1
    btfss    PIE1
,TXIE    tester si interrupt autorisée
    
goto     restorereg    non sauter
    bcf    STATUS
,RP0    ouisélectionner banque0
    btfss    PIR1
,TXIF    ouitester si interrupt en cours
    
goto     restorereg    non sauter
    call    inttx        
ouitraiter interrupt

            
;restaurer registres
            
;-------------------
restorereg
    movf    FSR_temp 
w    charger FSR sauvé
    movwf    FSR        
restaurer FSR
    swapf    status_temp
,w    swap ancien statusrésultat dans w
    movwf   STATUS        
restaurer status
    swapf   w_temp
,f    Inversion L et H de l'ancien W
                               ; sans modifier Z
    swapf   w_temp,w      ; Réinversion de L et H dans W
                ; W restauré sans modifier status
    retfie          ; return from interrupt

;*****************************************************************************
;                     INTERRUPTION RECEPTION USART                           *
;*****************************************************************************
;-----------------------------------------------------------------------------
; Reçoit le caractère de l'
USART et le place dans le buffer d'entrée.
; Si la longueur atteint D'
94', on n'encode pluset on place 0x0D en avant-
dernière position et 0x0A en dernière position
Si la réception est terminée (longueur atteinte ou 0x0A reçu), on stoppe les
interruptions de réception et on repositionne le pointeur au début du buffer
Les erreurs sont détectées et signalées
;-----------------------------------------------------------------------------
intrc
            
tester si erreur de frame
            
; -------------------------    
    
btfsc    RCSTA,FERR    tester si erreur de frame
    bsf    ER_FR        
ouisignaler erreur de frame

            
lire la parité
            
; --------------
;    
bcf    PARITE        par défautparité 0
;    btfsc    RCSTA,RX9D    parité lue 1?
;    
bsf    PARITE        ouile signaler

            
lire octet reçu
            
; ---------------
    
bsf    STATUS,IRP    pointer banques 2 et 3 en indirect
    movf    bufinptr
,w    charger pointeur destination
    movwf    FSR        
dans pointeur d'adresse
    movf    RCREG,w        ; charger octet reçu
    movwf    INDF        ; sauver dans buffer

        
            ; ------------------
intrc1
            ; tester si erreur d'
overflow
            
; ---------------------------
    
btfsc    PIR1,RCIF    encore d'autres octets dans RCREG?
    goto    intrc2        ; oui, vérifier caractère
    btfss    RCSTA,OERR    ; non, erreur d'
overflow?
    goto    
intrc2        nonvérifier caractère
    bcf    RCSTA
,CREN    ouiarrêt de la réception (reset de OERR)
    
bsf    RCSTA,CREN    remise en service de la réception
    bsf    ER_OV        
signaler erreur overflow
    
goto    intrcend    et fin d'interruption

            ; tester si caractère reçu = 0x0A
            ; -------------------------------
intrc2
    movf    INDF,w        ; charger caractère reçu
    xorlw    0x0A        ; comparer avec line-feed
    btfsc    STATUS,Z    ; identique?
    goto    intrcend    ; oui, fin de message

            ; vérifier si buffer plein
            ; ------------------------
    incf    bufinptr,f    ; incrémenter pointeur de caractères
    movf    FSR,w        ; charger pointeur
    xorlw    0x6D        ; comparer avec dernièr emplacement possible
    btfss    STATUS,Z    ; identique?
    return            ; non, fin de réception
    incf    FSR,f        ; pointeur sur emplacement suivant
    movlw    0x0D        ; mettre carriage-return
    movwf    INDF        ; en avant-dernière position
    incf    FSR,f        ; pointer sur dernière position
    movlw    0x0A        ; charger line-feed
    movwf    INDF        ; en dernière position

            ; fin de message
            ; --------------
intrcend
    movlw    LOW bufin    ; oui, adresse de départ du buffer d'
entrée
    movwf    bufinptr    
prochain caractère sera le premier
    bsf    STATUS
,RP0    passer banque 1
    bcf    PIE1
,RCIE    fin des interruptions de réception
    bcf    STATUS
,RP0    repasser banque 0
    
return            ; et retour


;*****************************************************************************
;                     
INTERRUPTION EMISSION USART                            *
;*****************************************************************************
;-----------------------------------------------------------------------------
envoie le caractère pointé par bufoutptrpuis incrémente le pointeur
Si ce caractère est le "line-feed"alors on arrête l'émission et on pointe de
; nouveau au début du buffer
;-----------------------------------------------------------------------------
inttx
            ; prendre octet à envoyer
            ; -----------------------

    bsf    STATUS,IRP    ; pointer banques 3 et 4
    movf    bufoutptr,w    ; charger pointeur d'
octets
    movwf    FSR        
dans pointeur
    movf    INDF
,w        charger octet à envoyer


            
envoyer octet
            
; -------------
    
movf    INDF,w        charger octet à envoyer
    bcf    STATUS
,RP0    passer banque 0
    movwf    TXREG        
envoyer octet parité
    incf    bufoutptr
,f    pointer sur octet suivant

            
tester si dernier octet
            
; -----------------------
    
xorlw    0x0A        comparer octet envoyé avec Line-feed
    btfss    STATUS
,Z    égalité?
    return            ; 
nonretour d'interruption

            ; traiter fin d'
émission
            
; ----------------------
    
bsf    STATUS,RP0    passer en banque 1
    bcf    PIE1
,TXIE    fin des interruptions émission USART
    bcf    STATUS
,RP0    repasser banque 0
    movlw    LOW bufout    
adresse du buffer de sortie
    movwf    bufoutptr    
prochain caractère premier
    
return            ; fin d'interruption



;-----------------------------------------------------------------------------
calcpar
    movwf    local1        ; sauver dans variable locale (temporaire)
    bcf    PARITE        ; effacer bit de parité

calcparl
    andlw    0x01        ; garder bit 0 de l'
octet
    xorwf    flags
,f        si " 1 "inverser parité
    bcf    STATUS
,C    effacer carry pour décalage
    rrf    local1
,f    amener bit suivant en b0
    movf    local1
,w    charger ce qui reste de l'octet
    btfss    STATUS,Z    ; il reste des bits à " 1 " ?
    goto    calcparl    ; oui, poursuivre
    return            ; non, retour

; ////////////////////////////////////////////////////////////////////////////
;                           P R O G R A M M E
; ////////////////////////////////////////////////////////////////////////////

;*****************************************************************************
;                          INITIALISATIONS                                   *
;*****************************************************************************
init

            ; Registre d'
options (banque 1)
            ; -----------------------------
    
BANKSEL    OPTION_REG    sélectionner banque 1
    movlw    OPTIONVAL    
charger masque
    movwf    OPTION_REG    
initialiser registre option

            
registres interruptions (banque 1)
            ; ----------------------------------
    
bsf    INTCON,PEIE    autoriser interruptions périphériques

            
initialiser USART
            
; -----------------
    
movlw    B'00000100'    émission sur 8 bitsmode haute vitesse
    movwf    TXSTA        
dans registre de contrôle
    movlw    BRGVAL        
valeur pour baud rate generator
    movwf    SPBRG        
dans SPBRG
    bcf    STATUS
,RP0    passer banque 0
    movlw    
B'10000000'    module USART en serviceréception 8 bits
    movwf    RCSTA        
dans registre de contrôle

            
Initialiser message de bienvenue
            
; --------------------------------
    
MESS    "P","R","E","T"    inscrire PRET dans le buffer de sortie

            
initialiser variables
            
; ---------------------
    
clrf    flags        effacer flags
    movlw    LOW bufin    
adresse du buffer de réception
    movwf    bufinptr    
dans pointeur
    movlw    LOW bufout    
adresse basse du buffer d'émission
    movwf    bufoutptr    ; dans pointeur

            ; autoriser interruptions (banque 0)
            ; ----------------------------------

    bsf    INTCON,GIE    ; valider interruptions
    goto    start        ; programme principal

;*****************************************************************************
;                      PREPARER LA REPONSE                                   *
;*****************************************************************************
;-----------------------------------------------------------------------------
; copie le buffer d'
entrée inversé dans le buffer de sortie
en modifiant cette sous-routinevous pouvez changer le fonctionnement
de votre programmeVous pouvez inventer ici de nouvelles règles de 
réponse
;-----------------------------------------------------------------------------
preprep
            
rechercher la fin du message
            
; ----------------------------

    
movlw    LOW bufin-1    pointer sur début du message-1
    movwf    FSR        
dans pointeur
    bsf    STATUS
,IRP    pointer banques 3 et 4 en indirect
prep1
    incf    FSR
,f        pointer sur suivant
    movf    INDF
,w        charger caractère
    xorlw    0x0A        
comparer avec line-feed
    btfss    STATUS
,Z    tester si car 0x0A
    
goto    prep1        nonsuivant
    decf    FSR
,w        ouiprendre pointeur trouvé-1
    movwf    ptr1        
sauver dans pointeur temporaire1

            
traiter ligne vide
            
; ------------------
    
xorlw    0x10        tester position pointeur
    btfss    STATUS
,Z    ligne vide?
    goto    
prep3        nonsauter
    MESS    
"V","I","D","E"    inscrire "vide dans le buffer de sortie
    return            ; fin du traitement

            ; copier message inversé
            ; ----------------------
prep3
;*********************************************************************************
   BANKSEL 0
   CALL    LCD_CLEAR
  
       CALL LCD_LOCATE_LINE0
       MOVLW    Printf_jmp
       CALL    LCD_PRINTF

    CALL LCD_LOCATE_LINE1
 
    BANKSEL bufin   ; adresse tempon entrée
    bsf STATUS,IRP  ; indirect banque 2 et 3
    movlw  bufin-1
    movwf   FSR     ;adresse tempon dans indirect

    BANKSEL 0


prep1jm
    incf    FSR,f        ; pointer sur suivant
    movf    INDF,w        ; charger caractère
    xorlw    0x0D        ; comparer carriage-return
    btfsc    STATUS,Z    ; tester si car = 0x0D
    goto    prep1jmsuite
    movf    INDF,w
    CALL    LCD_SEND_CHAR
    goto    prep1j        ; non, suivant
prep1jmsuite



    movlw    LOW bufout-1    ; adresse du buffer d'émission -1
    movwf    ptr2        ; dans pointeur temporaire2            
prep2
    decf    ptr1,f        ; pointer sur source suivante
    incf    ptr2,f        ; pointer sur destination suivante
    movf    ptr1,w        ; charger pointeur source
    movwf    FSR        ; dans pointeur d'adresse
    movf    INDF,w        ; charger octet
    movwf    octemp        ; le sauver
    movf    ptr2,w        ; charger pointeur destination
    movwf    FSR        ; dans pointeur d'adresse
    movf    octemp,w    ; prendre octet source
    movwf    INDF        ; dans destination
    movf    ptr1,w        ; charger pointeur source
    xorlw    0x10        ; comparer avec première position
    btfss    STATUS,Z    ; on a tout copié?
    goto    prep2        ; non, suivant

    incf    ptr2,w        ; charger position octet suivant bufout
    movwf    FSR        ; dans pointeur d'adresses
    movlw    0x0D        ; charger carriage-return
    movwf    INDF        ; dans buffer de sortie
    incf    FSR,f        ; pointer sur suivant
    movlw    0x0A        ; charger line-feed
    movwf    INDF        ; dans buffer de sortie
    return            ; et fin

;*****************************************************************************
;                      PROGRAMME PRINCIPAL                                   *
;*****************************************************************************

start
    BANKSEL 0
 
        CALL    LCD_INIT

        CALL LCD_LOCATE_LINE0
        MOVLW    Printf_Coucou
        CALL    LCD_PRINTF


        CALL LCD_LOCATE_LINE1
        MOVLW    Printf_jmp_Made
        CALL    LCD_PRINTF

        ; pause de 3 s
        CALL    Wait1s
 

 
       CALL    LCD_CLEAR
  
       CALL LCD_LOCATE_LINE0
       MOVLW    Printf_jmp
       CALL    LCD_PRINTF

    CALL LCD_LOCATE_LINE1


    bsf STATUS,IRP
    movlw  bufout-1
    movwf   FSR

    BANKSEL 0


prep1j
    incf    FSR,f        ; pointer sur suivant
    movf    INDF,w        ; charger caractère
    xorlw    0x0D        ; comparer carriage-return
    btfsc    STATUS,Z    ; tester si car = 0x0D
    goto    prep1jsuite
    movf    INDF,w
    CALL    LCD_SEND_CHAR
    goto    prep1j        ; non, suivant
prep1jsuite
        ; lancer l'émission, message de bienvenue
        ; ---------------------------------------

    bsf    STATUS,RP0    ; passer en banque 1
    bcf STATUS,RP1
    bsf    TXSTA,TXEN    ; émission en service.
    bsf    PIE1,TXIE    ; envoyer message "
pret"


            ; attendre fin de l'émission
            ; --------------------------
    clrwdt            ; effacer watch dog
    btfsc    PIE1,TXIE    ; reste des caractères à envoyer?
    goto    $-2        ; oui, attendre
    btfss    TXSTA,TRMT    ; buffer de sortie vide?
    goto    $-4        ; non, attendre

            ; lancer la réception
            ; --------------------
    bcf    STATUS,RP0    ; passer banque 0
    bsf    RCSTA,CREN    ; lancer la réception

            ; revevoir le message
            ; -------------------
    bsf    STATUS,RP0    ; passer banque 1
loop
    bsf    PIE1,RCIE    ; autoriser interruption réception
    clrwdt            ; effacer watchdog
    btfsc    PIE1,RCIE    ; tester si message complet reçu
    goto    $-2        ; non, attendre


    

    ; Attendre fin émission précédente
        ; --------------------------------
    clrwdt            ; effacer watchdog
    btfsc    PIE1,TXIE    ; message précédent envoyé?
    goto    $-2        ; non, attendre
    btfss    TXSTA,TRMT    ; buffer de sortie vide?
    goto    $-4        ; non, attendre

            ; traiter erreurs
            ; ----------------
    movf    flags,w        ; charger flags
    andlw    B'00001110'    ; conserver flags d'erreur
    btfsc    STATUS,Z    ; tester si au moins une erreur
    goto    messprep    ; non, traitement normal

    btfss    ER_PAR        ; tester si erreur de parité
    goto    err2        ; non, sauter
    MESS    "
P","A","R"," "    ; écrire "PAR" dans le buffer de sortie
    bcf    ER_PAR        ; acquitter l'erreur
err2
    btfss    ER_FR        ; tester si erreur de frame
    goto    err3        ; non, sauter
    MESS    "
F","E","R","R"    ; écrire "FERR" dans le buffer de sortie
    bcf    ER_FR        ; acquitter l'erreur
err3
    btfss    ER_OV        ; tester si erreur d'overflow
    goto    msuite        ; envoyer le message
    MESS    "
O","E","R","R"    ; écrire "OERR" dans le buffer de sortie
    bcf    ER_OV        ; acquitter l'erreur
    goto    msuite        ; envoyer message d'erreur

        ; traitement normal du message
        ; ----------------------------
messprep
    bcf    STATUS,RP0    ; passer banque 0
    call    preprep        ; préparer réponse
;*************************************************************

msuite
    bsf    STATUS,RP0    ; passer banque 1
    bsf    PIE1,RCIE    ; réautoriser interruption réception
    
            ; envoyer réponse
            ; ---------------
    bsf    PIE1,TXIE    ; lancer le message
    goto    loop        ; traiter message suivant



;**********************************************************************
;    Routine pour l'afficheur LCD                                     *
;                                                                     *
;**********************************************************************


;***** Attente de 1 s (exactement 1.00204 s)
Wait1s      
        MOVLW    D'99'        ;    99 fois
        MOVWF    tempo1s        ; stockage dans la variable tempo1s
T1sboucle    CALL    Wait10ms
        DECFSZ    tempo1s,1    ; décremente et test
        GOTO    T1sboucle    ; on boucle tant que <>0  
        RETURN

;***** Attente de 15 ms (exactement 14.99 ms)
Wait15ms
        MOVLW    D'149'        ;    149 fois
        MOVWF    tempo10ms    ; stockage dans la variable tempo10ms
T15msboucle    CALL    Wait100µs
        DECFSZ    tempo10ms,1    ; décremente et test
        GOTO    T15msboucle    ; on boucle tant que <>0
        RETURN


;***** Attente de 10 ms (exactement 10.02 ms)
Wait10ms
        MOVLW    D'198'        ;    198 fois
        MOVWF    tempo10ms    ; stockage dans la variable tempo10ms
T10msboucle    CALL    Wait50µs
        DECFSZ    tempo10ms,1    ; décremente et test
        GOTO    T10msboucle    ; on boucle tant que <>0
        RETURN

;***** Attente de 1.5 ms (exactement ? ms)
Wait1.5ms
        MOVLW    D'29'        ;    29 fois
        MOVWF    tempo10ms    ; stockage dans la variable tempo10ms
T1.5msboucle    CALL    Wait50µs
        DECFSZ    tempo10ms,1    ; décremente et test
        GOTO    T1.5msboucle    ; on boucle tant que <>0
        RETURN

;***** Attente de 100 µs (exactement, en comptant le temps d'appel)
Wait100µs    
        MOVLW    D'165'        ;    165 fois
        MOVWF    tempo50µ    ; stockage dans la variable tempo50µ
T100µsboucle    DECFSZ    tempo50µ,1    ; décremente et test
        GOTO    T100µsboucle    ; on boucle tant que <>0  0.2*3=0.6 µs en tout
        RETURN


;***** Attente de 50 µs (exactement, en comptant le temps d'appel)
Wait50µs    NOP
        NOP
        MOVLW    D'81'        ;    81 fois
        MOVWF    tempo50µ    ; stockage dans la variable tempo50µ
T50µsboucle    DECFSZ    tempo50µ,1    ; décremente et test
        GOTO    T50µsboucle    ; on boucle tant que <>0  0.2*3=0.6 µs en tout
        RETURN


;***** Attente de 1 µs (exactement, en comptant le temps d'appel)
Wait1µs        NOP
        RETURN


;**********************************************************************
;                                                                     *
;    Programmes de gestion de l'afficheur LCD                            *
;                                                                     *
;                                                                     *
;**********************************************************************

LCD_INIT
    CLRF    LCD_DATA_PORT    ; effacement du LCD_DATA_PORT

    ; Selectionne le LCD_DATA_PORT en sortie

    BSF    STATUS, RP0    ; Bank 1 selectonnee
    CLRF    LCD_DATA_TRIS    ; Port en sortie
    BCF     STATUS,    RP0    ; Bank 0 selectonnee

    CALL    Wait15ms    ; attente de 15ms pour que le LCD boote

    ; system set (premier)

    MOVLW    B'00110000'    ; Demande du mode 4 bit
    CALL    LCD_SEND
    CALL    LCD_SEND
    CALL    LCD_SEND
    MOVLW    B'00100000'    ; Demande du mode 4 bit
    CALL    LCD_SEND    

    ; System set (deuxieme) + reglage de la taille des matrices
    MOVLW    B'00100000'
    CALL    LCD_SEND
    MOVLW    B'10000000' + LCD_SET_MATRIX * B'01000000'
    CALL     LCD_SEND
            
    ; Set ON/OFF
    MOVLW    B'00000000'
    CALL     LCD_SEND
    ; Display off, cursor off, blink off
    MOVLW    B'10000000' + LCD_SET_DISPLAY * B'01000000' + LCD_SET_CURSOR * B'00100000' + LCD_SET_BLINK * B'00010000'
    CALL     LCD_SEND

    CALL     LCD_CLEAR    ; Clear screen    

    ; Set entry mode
    MOVLW    B'00000000'
    CALL     LCD_SEND
    ; Increment cursor to the right. when writing, don't shift screen
    MOVLW    B'01000000' + LCD_SET_DIRECT * B'00100000' + LCD_SET_SCROLL * B'00010000'
    CALL     LCD_SEND

    RETURN


;    Envois d'une donnee sur le LCD. Passee en parametre dans W
LCD_SEND_NO_WAIT
    MOVWF    LCD_TEMP        ; On met W sans LCD_TEMP

    MOVF    LCD_TEMP, W        ; mise sur le port D de la donnee
    MOVWF    LCD_DATA_PORT        ;    /
    NOP
    BSF    LCD_DATA_PORT,LCD_E    ; mise à 1 de E (validation)
    NOP
    NOP
    NOP                ; delai de 450 ns a respecter ...
    BCF    LCD_DATA_PORT,LCD_E    ; mise à 0 de E

    RETURN

;    Envois d'une donnee sur le LCD. Passee en parametre dans W
;    Attente de 40 µs mini ensuite
LCD_SEND

    CALL    LCD_SEND_NO_WAIT

    CALL    Wait50µs        ; on attends plus de 40us (prise en compte de la commande, et attente de la fin de celle-ci)

    RETURN


;    Envois d'un caractere ASCII sur le LCD. Passe en parametre dans W
LCD_SEND_CHAR
    MOVWF    LCD_CHAR        ; On met W sans LCD_CHAR

    ANDLW    0xF0            ; masquage des bit de poids faible
    ADDLW    LCD_RS_VALUE        ; on y ajoute LCD_RS_VALUE
    CALL    LCD_SEND_NO_WAIT    ; on envoit a l'afficheur


    SWAPF    LCD_CHAR, W            ; passage des bits de poids faibles en poids fort
    ANDLW    0xF0            ; masquage des bit de poids faible
    ADDLW    LCD_RS_VALUE        ; on y ajoute LCD_RS_VALUE            

    CALL    LCD_SEND        ; on envoit a l'afficheur
    
    ; fini

    RETURN


;    Envois d'un nombre sur le LCD, ecrit en hexa. Passe en parametre dans W
LCD_SEND_HEXA

    SWAPF    LCD_CHAR_HEXA, W    ; On met W sans LCD_CHAR_HEXA, 
                    ; passage des bits de poids faibles en poids fort
    ANDLW    0xF0            ; masquage des bit de poids faible
    
    ADDLW    6            ; on y ajoute 6
    MOVWF    LCD_TEMP        ; On met W sans LCD_TEMP
    BTFSC    LCD_TEMP, 4            ; si le bit 3 est a 1
    ADDLW    "
A"-"9"-1        ; on ajoute le code ascii de A moins celui de 0
    ADDLW    "
0" - 6         ; on ajoute le code ascii de 0, moins les 5
                    ;     on a maintenant le code ascii dans W
    CALL    LCD_SEND_CHAR        ; qu'on affiche ...

    MOVF    LCD_CHAR_HEXA, W    ; on remet LCD_CHAR_HEXA dans W
    ANDLW    0x0F            ; masquage des bit de poids forts
    ADDLW    6            ; on y ajoute 6
    MOVWF    LCD_TEMP        ; On met W sans LCD_TEMP
    BTFSC    LCD_TEMP, 4            ; si le bit 3 est a 1
    ADDLW    "
A"-"9"-1        ; on ajoute le code ascii de A moins celui de 0
    ADDLW    "
0" - 6         ; on ajoute le code ascii de 0, moins les 6
                    ;     on a maintenant le code ascii dans W
    CALL    LCD_SEND_CHAR        ; qu'on affiche ...
    
    RETURN    

;
;    Envois d'un octet sur le LCD, ecrit en decimal toujours sur 3 chiffres. Passe en parametre dans W
;
LCD_SEND_DECI

    MOVWF    LCD_CHAR_HEXA        ; On met W sans LCD_CHAR_HEXA, 

    ; Calcul des centaines

    MOVLW    "
0"            ; On met le code ascii de 0 dans LCD_CHAR
    MOVWF    LCD_CHAR        ;    "

LCD_SEND_DECIMAL_100
    MOVF    LCD_CHAR_HEXA
W
    ADDLW    
-D'100'
    
BTFSS    STATUSC
    
GOTO    $ + 4
    INCF    LCD_CHAR
F
    MOVWF    LCD_CHAR_HEXA
    
GOTO    LCD_SEND_DECIMAL_100

    
Affiche les centaines
    MOVF    LCD_CHAR
W
    CALL    LCD_SEND_CHAR
        
    
Calcul des dixaines

    MOVLW    
"0"            On met le code ascii de 0 dans LCD_CHAR
    MOVWF    LCD_CHAR        
;    "
    
LCD_SEND_DECIMAL_10
    MOVF    LCD_CHAR_HEXA, W
    ADDLW    -D'10'
    BTFSS    STATUS, C
    GOTO    $ + 4
    INCF    LCD_CHAR, F
    MOVWF    LCD_CHAR_HEXA
    GOTO    LCD_SEND_DECIMAL_10

    ; Affiche les dixaines
    MOVF    LCD_CHAR, W
    CALL    LCD_SEND_CHAR

    MOVLW    "
0"            ; On met le code ascii de 0 dans LCD_CHAR
    MOVWF    LCD_CHAR        ;    "

    
Calcul des unitees

LCD_SEND_DECIMAL_1
    MOVF    LCD_CHAR_HEXA
W
    ADDLW    
-D'1'
    
BTFSS    STATUSC
    
GOTO    $ + 4
    INCF    LCD_CHAR
F
    MOVWF    LCD_CHAR_HEXA
    
GOTO    LCD_SEND_DECIMAL_1

    
Affiche les unitees
    MOVF    LCD_CHAR
W
    CALL    LCD_SEND_CHAR    

    
Fini !
    RETURN    


;
;    
Envois d'un octet sur le LCD, ecrit en binaire toujours sur 8 0 ou 1. Passe en parametre dans W
;
LCD_SEND_BIN
    MOVWF    LCD_CHAR_HEXA        ; On met W sans LCD_CHAR_HEXA, 

    ; generation de code automatique avec MPLAB
    VARIABLE    I
I = D'
7'

    while I >= 0
    
        MOVLW    "0"            ; On met le code ascii de 0 dans W
        BTFSC    LCD_CHAR_HEXA, I    ; si le bit I est a 1;
        MOVLW    "1"            ; On met le code ascii de 1 dans W
        CALL    LCD_SEND_CHAR    

I--
    endW
    
    RETURN

    
; Efface l'
ecran LCD    
LCD_CLEAR

    MOVLW    0
    CALL    LCD_SEND_NO_WAIT

    MOVLW    D
'16'
    
CALL    LCD_SEND        envoit de la commande pour effacer

    CALL    Wait1.5ms        
on attends plus de 1.64 ms
    CALL    Wait100µs
    CALL    Wait100µs

    
RETURN

Scroll de l'ecran LCD    
LCD_SCROLL

    MOVLW    D'
16'
    CALL    LCD_SEND_NO_WAIT

    MOVLW    D'
128'
    CALL    LCD_SEND        ; envoit de la commande pour le scroll

    RETURN

; LOCATE de l'
ecran LCDavec la position dans W64 positions par lignes
;    0 debut de la premiere ligne
;    64 debut de la deuxieme ligne
LCD_LOCATE

    MOVWF    LCD_CHAR        
On met W sans LCD_CHAR

    ANDLW    0xF0            
masquage des bit de poids faible
    ADDLW    D
'128'            on y ajoute 128
    CALL    LCD_SEND_NO_WAIT    
on envoit a l'afficheur

    SWAPF    LCD_CHAR, W        ; On remet LCD_CHAR dans W
                    ; passage des bits de poids faibles en poids fort

    ANDLW    0xF0            ; masquage des bit de poids faible
    CALL    LCD_SEND        ; on envoit a l'
afficheur
    
    
fini

    
RETURN


Place le curseur en debut de la 1ere ligne
LCD_LOCATE_LINE0

    MOVLW    D
'0'
    
CALL    LCD_LOCATE

    
RETURN


Place le curseur en debut de la 2eme ligne
LCD_LOCATE_LINE1

    MOVLW    D
'64'
    
CALL    LCD_LOCATE

    
RETURN

Place le curseur en debut de la 3eme ligne
LCD_LOCATE_LINE2

    MOVLW    D
'20'
    
CALL    LCD_LOCATE

    
RETURN

Place le curseur en debut de la 4eme ligne
LCD_LOCATE_LINE3

    MOVLW    D
'84'
    
CALL    LCD_LOCATE

    
RETURN

affiche un espace
LCD_PRINT_SPACE
    MOVLW    
" "
    
CALL    LCD_SEND_CHAR
    
RETURN
    


;**********************************************************************
;
Fonction Printf %s
avec en parametre W le numero du printf a afficher (defini par des EQU)
Definitions des printfs en fin de programmes
;
;**********************************************************************
LCD_PRINTF

    MOVWF    LCD_CMP_PRINTF    
on met W dans LCD_AFF_PRINTF qui contient le printf a afficher

    
initialisation de EEADRH et de EEADR

    BSF    STATUS
RP1
    BCF    STATUS
RP0    Bank 2

    MOVLW    High Printf_START    
    MOVWF    EEADRH        
MSBytes of Program address to read
        
    MOVLW    Low Printf_START
    MOVWF    EEADR        
LSByte of program address to read

LCD_PRINTF_boucle
    BSF    STATUS
RP0    
    
BSF    STATUSRP1    Bank 3

    BSF    EECON1
EEPGD    Point to PROGRAM memory

    BSF    EECON1
RD    EEPROM read
    NOP
    NOP            
Memory is read in the next 2 cycles

    BCF    STATUS
RP0    bank 2

    MOVF     EEDATA
W    LSByte of Program EEDATA
;    MOVF     EEDATHW    MSByte of Program EEDATA -> pas utile ici
        
    BCF    STATUS
RP1
    BCF    STATUS
RP0    Bank 0
    
    BTFSC    STATUS
Z    Si W 0 va en LCD_PRINTF_Null
    
GOTO    LCD_PRINTF_Null

    DECFSZ    LCD_CMP_PRINTF
on decremente LCD_CMP_PRINTF
    
GOTO     LCD_PRINTF_Next_add  si il est different de 0donc de 1 avant decrementationon va en LCD_PRINTF_Next_add
                  
sinon il faut afficher le caractere qui est toujours dans W

    CALL    LCD_SEND_CHAR    

    
GOTO     LCD_PRINTF_Next_add

LCD_PRINTF_Null

    DECFSZ    LCD_CMP_PRINTF
F
    
GOTO    LCD_PRINTF_Next
    
RETURN

LCD_PRINTF_Next_add
    INCF    LCD_CMP_PRINTF
on reajoute 1 a LCD_CMP_PRINTF
        
LCD_PRINTF_Next

    BSF    STATUS
RP1
    BCF    STATUS
RP0    Bank 2

    INCF    EEADR
F    ajoute 1 a l'adresse de lecture
    BTFSC    STATUS, Z
    INCF    EEADRH, F    ; si = 0, on ajoute 1 au poid fort

    MOVLW    High Printf_STOP
    SUBWF    EEADRH,W
    BTFSS    STATUS, Z
    GOTO    LCD_PRINTF_Next2 ; si EEADRH != High Printf_STOP on continue
    
    MOVLW    low Printf_STOP
    SUBWF    EEADR,W
    BTFSS    STATUS, Z
    GOTO    LCD_PRINTF_Next2 ; si EEADR != low Printf_STOP on continue

    ; Fin du printf
    BCF    STATUS, RP1
    BCF    STATUS, RP0    ; Bank 0
    RETURN
    

LCD_PRINTF_Next2

    BCF    STATUS, RP1
    BCF    STATUS, RP0    ; Bank 0
    GOTO    LCD_PRINTF_boucle
    

;**********************************************************************
;
; Les printf definis (1 mot par caractere).
;  Places à la fin du programme
;
;**********************************************************************

Printf_START     

    VARIABLE    PRINTF_CMP =    1    ; Variable MPLAB (pas d'
existence en assembleurpour trouver le bon printf.


Printf_Coucou         EQU    PRINTF_CMP
PRINTF_CMP
++
    
DT    " initialisation"0

Printf_jmp     EQU    PRINTF_CMP
PRINTF_CMP
++
    
DT     "essai de J-Marc",0
Printf_jmp1     EQU    PRINTF_CMP
PRINTF_CMP
++
    
DT     "pour voir",0

Printf_jmp_Made     EQU    PRINTF_CMP
PRINTF_CMP
++
    
DT     "Made by J-Marc",0

Printf_legende    EQU    PRINTF_CMP
PRINTF_CMP
++
    
DT     "Compt Tmr0 Tr/mn",0

Printf_Ok         EQU    PRINTF_CMP
PRINTF_CMP
++
    
DT     "OK",0

Printf_Error         EQU    PRINTF_CMP
PRINTF_CMP
++
    
DT     "ERROR",0

Printf_toursminute         EQU    PRINTF_CMP
PRINTF_CMP
++
    
DT    "0 tr/m"0

Printf_STOP


    END             
directive fin de programme


transmission uhf
venom
Avatar de l’utilisateur
Passioné
Passioné
Messages : 371
Âge : 32
Enregistré en : avril 2016
Localisation : . <------ ici
Contact :

#3 Message par venom » lun. 27 févr. 2017 22:08

Bonsoir,

Trop compliqué pour moi, mais je te remercie pour le travail partager :bravo:






@++
En fait tout est une question de BIT ? :-D

transmission uhf
Temps-x
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 874
Enregistré en : juillet 2016
Localisation : Terre

#4 Message par Temps-x » mar. 28 févr. 2017 01:41

Bonjour JMarc, venom, et à vous tous,

Et bien j'ai qu'une chose à dire :bravo:, tu vas pouvoir le paramétrer (la paramétrer :lol:), j'ai un programme pour
paramétrer c'est module là, avec le PC.

Régler la force du signal
Régler ton canal
Régler la vitesse de transmission en bauds
Régler ta parité, et ton bits de stop
Régler si data = 7, ou Data = 8

je suis en train de lire le cours de Monsieur Bigonoff sur les 18Fxxx, 73 intructions - 33 que je connais déjà, ça promets !!

C'est émetteur, et récepteur son génial, si tu sais écrire un programme sur un PC, tu vas vraiment t'amuser à créer plein de chose.

Exemple, gérer, et piloté un robot, prendre le relevé géographique d'un espace, déclencher l'ouverture d'une porte à telle heure,
relevé du niveau d'eau de ta cuve, surveillance de ta voiture, ou camion, contrôle de la puissance sur divers appareille, pilotage de CNC
sans aucun câble, et bien d'autre, pas de limite, quand on à de l'imagination, ce qui manque cruellement dans notre société actuelle.

Tu voies Ebay c'est pas mal, malgré les critiques de certain.

écrit par HULK28 :

1 euro la pièce port compris, faut qu'on m'explique...
[mode HS]
Je ne suis pas certain du tout que ça aille dans le sens COP21 tout ce "commerce"...
[/mode HS]
Et les Module ne son pas HS
viewtopic.php?p=5588#p5588


humour!! Et en plus il fonctionne, et ne son pas HS !! :langue:


écrit par Jérémy :

Pour ma part je cherche un truc plus "PRO" que du Ebay !
viewtopic.php?p=5627#p5627


écrit par Jérémy :

J'ai essayé d'envoyer un e-mail mais pas de nouvelle !
viewtopic.php?p=5627#p5627


humour!! Là !! y à pas à dire, pour des "PRO" chapeau !! :lol:

A+
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

transmission uhf
JMarc
Passioné
Passioné
Messages : 488
Enregistré en : août 2016
Localisation : Dans le Sud...

#5 Message par JMarc » mar. 28 févr. 2017 19:51

Bonjour

Merci temps-x pour tes encouragements :-D

Je n'ai rien programmé, juste brancher l'alim et relié au pic donc tout les paramètres sont ceux par défauts.
A par que comme d'habitude je n'ai pas lu la notice et donc mal câblé :mur: , ça a fonctionné pour ainsi dire au second coup :langue:


J'ai lu la notice pour le changement de canal, puissances, débits,exc... Mais se sera pour plus tard

Le prix est effectivement impressionnant et cela ne me gêne pas de payer beaucoup plus cher pour un produit fabriqué en France mais je ne veux pas que le vendeur français l'achète en Chine pour me le revendre plus cher :wink:

Il me reste a faire les essais de distances, il faut me laisser un peut de temps et je vous donne les résultats :langue:

transmission uhf
Temps-x
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 874
Enregistré en : juillet 2016
Localisation : Terre

#6 Message par Temps-x » mer. 1 mars 2017 01:50

Bonjour JMarc, venom, et à vous tous,

cela ne me gêne pas de payer beaucoup plus cher pour un produit fabriqué en France mais je ne veux pas que le vendeur
français l'achète en Chine pour me le revendre plus cher :wink:


Tu as tous compris, moi non plus ça me gêne pas de payer un peu plus chère, pour acheté français, j'ai bien dit
un peu plus chère, mais pas 6 fois ou dix fois plus chère.

Comme on peut trouver chez la plupart des commerçants français, que ça soit dans l'électronique, ou autre produit.

La plupart des produits à 95% des cas, c'est commandé en chine, Amérique, Taïwan, Japon, et bien d'autre, et revendu en France,
tu paies juste l'intermédiaire.

Quand au Microcontrôleur PIC que l'on utilise, c'est pas fabriquer en France, donc quand tu achètes un Microcontrôleur PIC en France,
tu paies l'intermédiaire.

La notice que tu as, pour tes modules HC-12, tu peux ma la faire parvenir, pour que je vois comment il faut programmer tous cela Merci !

A+
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

transmission uhf
JMarc
Passioné
Passioné
Messages : 488
Enregistré en : août 2016
Localisation : Dans le Sud...

#7 Message par JMarc » jeu. 2 mars 2017 13:52

Bonjour à tous

Je vais partir sur ce protocole, quand pensez vous ?

Code : Tout sélectionner

- [$A5][$5A][DIP][$A5][ING][$A5][DIP][$A5][ING][$AA]
    [$A5][$5A] Représente le “header” (l’en-tête) du flux.
    [DIP]      Est l’état des micro-interrupteurs (envoyé 2 fois par sécurité).
    [$A5]      “Fillers” (compléments) permettant de maintenir stable
               le modulateur AM 
(est répété après chaque donnée significative).
    [ING]      Est l’état des entrées (répété 2 fois par sécurité).
    [$AA]      “Terminator” (bouchon) du flux.

- [$A5][$5A][DIP][$AA][ING][$AA][DIP][$AA][ING][$AA]
    [$AA]      “Filler” remplaçant [$A5] dans le message d’état. Ainsi, le
               récepteur peut distinguer le message normaldu message d’état
.



Cela vient de ce projet déjà cité dans un autre post

http://www.schema-electronique.net/2011/10/une-liaison-radio-8-canaux-sur-433-mhz.html?m=1

transmission uhf
Temps-x
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 874
Enregistré en : juillet 2016
Localisation : Terre

#8 Message par Temps-x » ven. 3 mars 2017 01:54

Bonjour JMarc, et à vous tous,

Avec quoi tu émets, et reçois, HC-12 ou émetteur classique ?

A+
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

transmission uhf
JMarc
Passioné
Passioné
Messages : 488
Enregistré en : août 2016
Localisation : Dans le Sud...

#9 Message par JMarc » ven. 3 mars 2017 06:01

Bonjour temps-x

Oui avec les HC-12 cela doit être réalisable même si je ne me sert pas des deux sens de communication :sifflotte:

transmission uhf
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1028
Âge : 67
Enregistré en : juillet 2015
Localisation : 01120
Contact :

#10 Message par paulfjujo » ven. 3 mars 2017 17:06

bonjour à Tous ,


Les HC12 n'englobent_t_ils pas la gestion protocolaire , pour rendre transparent la liaison ?
comme le ferait un HC05 ou HC06 en bluetooth .


Retourner vers « Langage ASM »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 4 invités