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

Programmer l'AD9850
F6FCO
Avatar de l’utilisateur
Expert
Expert
Messages : 1413
Âge : 70
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#61 Message par F6FCO » lun. 29 nov. 2021 18:34

Hello tout le monde,

Désinstallé/réinstallé MPLab8.92 et j'ai pu me remettre au boulot.
Le code est abouti pour un affichage sur LCD, reste à graver un PCB et le VFO sera opérationnel.

Ci-dessous affichage sur le petit fréquencemètre chinois 7 segments en sortie du DDS, et affichage LCD qui n'est pas un fréquencemètre mais un affichage dédié par calculs en déconstruisant le mot de prog du DDS.

P1050136.JPG


je vais maintenant m'amuser à faire des affichages sur d'autres supports plus fun qu'un LCD.
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Une porte nand prend 2 bits en entrée... la cochonne !!! :langue:

Programmer l'AD9850
Lulu
Avatar de l’utilisateur
Membre
Membre
Messages : 9
Enregistré en : octobre 2016
Localisation : sud est

#62 Message par Lulu » mar. 30 nov. 2021 08:59

Bonjour F6FCO, pas une mince affaire cet AD9850. Dans la formule que tu as mis:
Pour cela j'utilise à l'envers la formule de calcul donnée pour le DDS: MotBinaire de prog= fq*(2^32/125000) .

c'est pas 125000000 (Mhz) au lieu de 125000 ?

Quant à la division, tu peuxpeut-être t'en passer en faisant suivre une deuxième variable en même temps que MotBinaire. Si tu lui additionne/soustrait 100 ou 250 ou 500 suivant le mode où tu es, elle devrait donner la fréquence que l'AD9850 est en train de produire. J'imagine que cette variable devra être aussi sur plusieurs octets comme MotBinaire.

Programmer l'AD9850
F6FCO
Avatar de l’utilisateur
Expert
Expert
Messages : 1413
Âge : 70
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#63 Message par F6FCO » mar. 30 nov. 2021 09:44

Bonjour Lulu,
c'est pas 125000000 (Mhz) au lieu de 125000 ?

Le nombre de zéros dépends si tu calcules en Mhz ou en Khz, en l'occurence c'est 1250 000 parce que j'ai voulu avoir un chiffre après la virgule pour afficher les centaines de hertz.

Quant à la division, tu peuxpeut-être t'en passer en faisant suivre une deuxième variable en même temps que MotBinaire. Si tu lui additionne/soustrait 100 ou 250 ou 500 suivant le mode où tu es, elle devrait donner la fréquence que l'AD9850 est en train de produire. J'imagine que cette variable devra être aussi sur plusieurs octets comme MotBinaire.

Je n'avais pas pensé à cette solution. Plutôt que de refaire faire tous les calculs par le PIC j'en ai tiré une constante 2^32/1250 000 qui donne 3435.97 que j'ai arrondi à 3436 (0x0d6c), ce qui ne pose aucun pbm sur le résultat.
C'est pour faire ce travail qu'il me fallait une division 32/16bits, par exemple pour "décalculer" 0x 0e5c4eb5 qui correspond à 7012Khz il faut faire :
0x0e5c4eb5/0x0d6c

PS: j'ai réfléchi à ton idée et effectivement comme au démarrage MotBinaire= 0x0e5c4eb5 j'aurai pu déclarer une variable Freq=d'070120' et incrémenter ou décrémenter MotBinaire et Freq d'une certaine valeur à chaque variation de l'encodeur.
Je garde mon système parce que çà fonctionne bien maintenant mais comme j'envisage de faire un affichage sur tubes VFD Russes il va falloir créer d'autres routines pour gérer le multiplexage et il est possible que le PIC avoue ses limites, dans ce cas je mettrais en pratique ton idée.
Une porte nand prend 2 bits en entrée... la cochonne !!! :langue:

Programmer l'AD9850
F6FCO
Avatar de l’utilisateur
Expert
Expert
Messages : 1413
Âge : 70
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#64 Message par F6FCO » mer. 8 déc. 2021 19:47

Salut tous,
Petit retour sur le projet qui est terminé en mode LCD. Ca fonctionne bien avec affichage LCD, qui comme je l'ai dit plus haut n'est pas un fréquencemètre, la base est le mot binaire de programmation que je "décalcule" pour arriver à la fréquence, cette valeur qui représente la fréquence est décomposée pour isoler chaque chiffre, par exemple pour 7012,0Khz je me retrouver avec "7", "0", "1","2","0" dans des octets différents. Ce qui me permet d'ajouter à chaque chiffre la valeur décimale 48 et ainsi obtenir la valeur ascii de chaque caractère. Il ne reste plus qu'à afficher çà sur le LCD.

https://www.youtube.com/watch?v=X6w4vGLfLRc

Je ne pense pas faire de circuit imprimé pour l'instant, je verrai çà plus tard, je vais continuer ce projet pour un affichage sur des tubes vintages Russes type IV3, un peu le genre tubes nixies mais en 7 segments.
Une porte nand prend 2 bits en entrée... la cochonne !!! :langue:

Programmer l'AD9850
F6FCO
Avatar de l’utilisateur
Expert
Expert
Messages : 1413
Âge : 70
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#65 Message par F6FCO » ven. 10 déc. 2021 23:25

Le code du VFO avec affichage LCD intégré. Merci Microchip d'avoir prévu assez de mémoire :wink: :

Code : Tout sélectionner

;************************************************************************************************
;
                         F6FCO - AD9850                        ;
;
                                                                                      ;
;**********************************************************************************************
 ;


        Errorlevel-302 
        list            p
=18f4525                
        
#include        <p18f4525.inc>
        #include    <LCD_18F.inc>            
    
 
;
 ;CONFIG OSC = HS
 
;CONFIG OSC = XT                        ; Oscillateur ext 4MHz 
 
;CONFIG OSC = HSPLL                        ; Oscillateur interne 32Mhz 
 CONFIG OSC 
= INTIO67    ; Oscillateur interne 8MHz 
 CONFIG FCMEN 
= OFF
 CONFIG IESO 
= OFF    ; Délai au démarrage (ON/OFF)
 CONFIG BOREN = OFF    ; Reset si chute de tension (ON/OFF)
 CONFIG BORV = 0    ; Tension de reset en 1/10ème Volts 
 CONFIG WDT 
= OFF    ; Mise hors service du watchdog (ON/OFF)
 CONFIG PBADEN = OFF    ; PORTB<4:0> les broches sont configurées comme E/S numériques lors de la réinitialisation
 CONFIG LPT1OSC 
= OFF    ; Timer1 configuré pour un fonctionnement plus puissant
 CONFIG MCLRE 
= ON    ; Mclr configuré comme entrée
 CONFIG STVREN 
= ON    ; Reset sur débordement de pile (ON/OFF)
 CONFIG LVP = OFF    ; Programmation basse tension autorisée (ON/OFF)
 CONFIG XINST = OFF    ; L'extension du jeu d'instructions et le mode d'adressage indexé sont désactivés(mode hérité)
 CONFIG DEBUG = OFF    ; Debugger hors service
 CONFIG CP0 = OFF    ; Code protection sur block 0 (ON/OFF)
 CONFIG CP1 = OFF    ; Code protection sur block 1 (ON/OFF)
 CONFIG CP2 = OFF    ; Code protection sur block 2 (ON/OFF)
 CONFIG CPB = OFF    ; Code protection sur bootblock  (ON/OFF)
 CONFIG CPD = OFF    ; Code protection sur eeprom (ON/OFF)
 CONFIG WRT0 = OFF    ; Protection écriture block 0 (ON/OFF)
 CONFIG WRT1 = OFF    ; Protection écriture block 1 (ON/OFF)
 CONFIG WRT2 = OFF    ; Protection écriture block 2 (ON/OFF)
 CONFIG WRTB = OFF    ; Protection écriture bootblock (ON/OFF)
 CONFIG WRTC = OFF    ; Protection écriture configurations (ON/OFF)
 CONFIG WRTD = OFF    ; Protection écriture zone eeprom (ON/OFF)
 CONFIG EBTR0 = OFF    ; Protection lecture de table block 0 (ON/OFF)
 CONFIG EBTR1 = OFF    ; Protection lecture de table block 1 (ON/OFF)
 CONFIG EBTR2 = OFF    ; Protection lecture de table block 2 (ON/OFF)
 CONFIG EBTRB = OFF    ; Protection lecture de table bootblock (ON/OFF)

; ------------------------------------ #define
;
; ---------- encodeur
#define EncA        LATB,0        ; encodeur
#define EncB        LATB,1        ; encodeur
; ----------- AD9850
#define    w_clk        LATB,2        ; horloge AD9850
#define fq_ud        LATB,3        ; validation AD9850
#define    datas        LATB,4        ; datas AD9850
#define    raz        LATB,5        ; raz AD9850
; -----------
#define    pous30m        PORTC,0        ; 30m
#define    pous40m        PORTC,1        ; 40m
#define    pous80m        PORTC,2        ; 80m
#define pousAppel    PORTC,3        ; appel perso

; ------------------------------------ 
     CBLOCK H'
0
        mem5            :5
        Reg_1            :1
        Reg_2            :1
        Reg_3            :1
        MotBinaireOld        :5
        MotBinaire        :5    ; mot de programmation AD9850 
        frq_affichage        :6    ; frq à afficher avec 100khz derrière la virgule
        dividende32        :4
        diviseur32        :4
        quotient32        :4
        reste32            :4        
        dividende48        :6
        diviseur24        :3
        Shift            :6
        Rem            :3
        valeur1            :6
        valeur2            :6
        report16        :1
        EncA_old        :1     ; état de la pin A de l'
encodeur au tour d'avant
        EncB_old        :1     ; état de la pin B de l'
encodeur au tour d'avant
        Sens            :1    ; sens de rotation de l'
encodeur
        LcdLigne        
:1
        LcdColonne        
:1
        tampon            
:1    ; poubelle à tout faire
        ptr            
:1
    ENDC

    ORG H
'0'
    
; ------------------------------------ 
init

     movlw     B
'01110011'
        movwf     OSCCON            
    movlw    b
'00000011'
    movwf    TRISB
    movlw    b
'00000000'
    movwf    TRISD
    movlw    b
'00001111'
    movwf    TRISC
    
    LCD_INIT        
; initialisation du LCD
    call    tempo100ms
    LCD_CURSEUR_OFF
    
    
    
; raz des variables
    
    clrf    MotBinaire
+0
    clrf    MotBinaire
+1
    clrf    MotBinaire
+2
    clrf    MotBinaire
+3
    clrf    MotBinaire
+4
    clrf    frq_affichage
+0
    clrf    frq_affichage
+1
    clrf    frq_affichage
+2
    clrf    frq_affichage
+3
    clrf    frq_affichage
+4
    clrf    frq_affichage
+5
    clrf    dividende32
+0
    clrf    dividende32
+1
    clrf    dividende32
+2
    clrf    dividende32
+3
    clrf    diviseur32
+0
    clrf    diviseur32
+1
    clrf    diviseur32
+2
    clrf    diviseur32
+3
    clrf    quotient32
+0
    clrf    quotient32
+1
    clrf    quotient32
+2
    clrf    quotient32
+3
    clrf    reste32
+0
    clrf    reste32
+1
    clrf    reste32
+2
    clrf    reste32
+3
    clrf    valeur1
+0
    clrf    valeur1
+1
    clrf    valeur1
+2
    clrf    valeur1
+3
    clrf    valeur1
+4
    clrf    valeur1
+5
    clrf    valeur2
+0
    clrf    valeur2
+1
    clrf    valeur2
+2
    clrf    valeur2
+3
    clrf    valeur2
+4
    clrf    valeur2
+5
    
    nop
    nop            
        


Code : Tout sélectionner

#include     <VFO serie init V.2.asm>
; -----------------------------------
;
initialisations variables encodeur
    movlw    2
    movwf    Sens
    movf    PORTB
,w
    andlw    b
'00000001'
    movwf    EncA_old
    movf    PORTB
,w
    andlw    b
'00000010'
    movwf    EncB_old
    
    call    fq7012        
; Initialisation du mot binaire de programmation AD9850


    LCD_CLEAR
    call    tempo100ms
    
    
;call    F6FCO
    
;call    tempo1000ms
    
;call    tempo1000ms
    
;call    tempo1000ms
    
;call    tempo1000ms
    
    LCD_CLEAR
    call    tempo100ms
    call    conversion_frq
    call    conversion_ascii
    call    Lcd_affichage

main    
    btfss    pous30m
    call    fq10112
    btfss    pous40m
    call    fq7012
    btfss    pous80m    
    call    fq3564
    btfss    pousAppel
    call    bipbip

    
    bcf    raz
    call    prog_AD9850
    call    gestion_encodeur
    call    modif_frq
    bra    main
    
    
; ----------------------------------------

#include    <VFO serie routines V.2.asm>
#include    <VFO serie tempos V.2.asm>
#include    <LCD_18F_4Mhz.asm>
    end


Code : Tout sélectionner

; ----------------------------------------------------------------------
bipbip
    
    nop
    movff    MotBinaire
+1,MotBinaireOld+1
    movff    MotBinaire
+2,MotBinaireOld+2
    movff    MotBinaire
+3,MotBinaireOld+3
    movff    MotBinaire
+4,MotBinaireOld+4
    nop
    call    blanc
    call    tempo1000ms
    call    tempo1000ms
    call    do
    call    blanc
    call    do
    call    blanc
    call    do
    call    blanc
    call    re
    call    tempo100ms
    call    blanc
    call    mi
    
;call    tempo200ms
    call    blanc
    call    tempo200ms
    
    call    tempo200ms
    call    do
    call    blanc
    call    do
    call    blanc
    call    do
    call    blanc
    call    re
    call    tempo100ms
    call    blanc
    call    mi
    
;call    tempo200ms
    call    blanc
    call    tempo200ms
    
    call    tempo200ms
    call    sol
    call    blanc
    call    sol
    call    blanc
    call    sol
    call    blanc
    call    sol
    call    blanc
    call    sol
    call    blanc
    call    tempo1000ms
    call    tempo1000ms
    

    nop
    movff    MotBinaireOld
+1,MotBinaire+1
    movff    MotBinaireOld
+2,MotBinaire+2
    movff    MotBinaireOld
+3,MotBinaire+3
    movff    MotBinaireOld
+4,MotBinaire+4
    nop
    call    prog_AD9850
    nop
    nop


    return
    

; ----------------------------------------------------------------------
ut    ; 
    movff    MotBinaireOld
+1,MotBinaire+1
    movff    MotBinaireOld
+2,MotBinaire+2
    movff    MotBinaireOld
+3,MotBinaire+3
    movff    MotBinaireOld
+4,MotBinaire+4
    movff    MotBinaire
+1,valeur1+3
    movff    MotBinaire
+2,valeur1+2
    movff    MotBinaire
+3,valeur1+1
    movff    MotBinaire
+4,valeur1+0
    nop
    movlw    0x94
    movwf    valeur2
+0
    movlw    0x06
    movwf    valeur2
+1
    clrf    valeur2
+2
    clrf    valeur2
+3
    call    addition32    
; résultat dans valeur1
    nop
    movff    valeur2
+3,MotBinaire+1
    movff    valeur2
+2,MotBinaire+2
    movff    valeur2
+1,MotBinaire+3
    movff    valeur2
+0,MotBinaire+4
    call    prog_AD9850
    nop
    call    tempoNote
    return

; ----------------------------------------------------------------------
sol    ;
    movff    MotBinaireOld+1,MotBinaire+1
    movff    MotBinaireOld
+2,MotBinaire+2
    movff    MotBinaireOld
+3,MotBinaire+3
    movff    MotBinaireOld
+4,MotBinaire+4
    movff    MotBinaire
+1,valeur1+3
    movff    MotBinaire
+2,valeur1+2
    movff    MotBinaire
+3,valeur1+1
    movff    MotBinaire
+4,valeur1+0
    nop
    movlw    0x6e
    movwf    valeur2
+0
    movlw    0x04
    movwf    valeur2
+1
    clrf    valeur2
+2
    clrf    valeur2
+3
    call    addition32    
; résultat dans valeur1
    nop
    movff    valeur2
+3,MotBinaire+1
    movff    valeur2
+2,MotBinaire+2
    movff    valeur2
+1,MotBinaire+3
    movff    valeur2
+0,MotBinaire+4
    call    prog_AD9850
    nop
    call    tempoNote
    return

; ----------------------------------------------------------------------
do
    movff    MotBinaireOld+1,MotBinaire+1
    movff    MotBinaireOld
+2,MotBinaire+2
    movff    MotBinaireOld
+3,MotBinaire+3
    movff    MotBinaireOld
+4,MotBinaire+4
    movff    MotBinaire
+1,valeur1+3
    movff    MotBinaire
+2,valeur1+2
    movff    MotBinaire
+3,valeur1+1
    movff    MotBinaire
+4,valeur1+0
    nop
    movlw    0x48
    movwf    valeur2
+0
    movlw    0x02
    movwf    valeur2
+1
    clrf    valeur2
+2
    clrf    valeur2
+3
    call    addition32    
; résultat dans valeur1
    nop
    movff    valeur2
+3,MotBinaire+1
    movff    valeur2
+2,MotBinaire+2
    movff    valeur2
+1,MotBinaire+3
    movff    valeur2
+0,MotBinaire+4
    call    prog_AD9850
    nop
    call    tempoNote
    return

; ----------------------------------------------------------------------
mi
    nop
    movff    MotBinaireOld
+1,MotBinaire+1
    movff    MotBinaireOld
+2,MotBinaire+2
    movff    MotBinaireOld
+3,MotBinaire+3
    movff    MotBinaireOld
+4,MotBinaire+4
    call    prog_AD9850
    nop
    call    tempoNote
    return
    
; ----------------------------------------------------------------------
sib
    movff    MotBinaireOld
+1,MotBinaire+1
    movff    MotBinaireOld
+2,MotBinaire+2
    movff    MotBinaireOld
+3,MotBinaire+3
    movff    MotBinaireOld
+4,MotBinaire+4
    movff    MotBinaire
+1,valeur1+3
    movff    MotBinaire
+2,valeur1+2
    movff    MotBinaire
+3,valeur1+1
    movff    MotBinaire
+4,valeur1+0
    nop
    movlw    0x5e
    movwf    valeur2
+0
    movlw    0x05
    movwf    valeur2
+1
    clrf    valeur2
+2
    clrf    valeur2
+3
    call    soustraction32    
; résultat dans valeur1
    nop
    movff    valeur1
+3,MotBinaire+1
    movff    valeur1
+2,MotBinaire+2
    movff    valeur1
+1,MotBinaire+3
    movff    valeur1
+0,MotBinaire+4
    call    prog_AD9850
    nop
    call    tempoNote
    return

; ----------------------------------------------------------------------
doo
    movff    MotBinaireOld
+1,MotBinaire+1
    movff    MotBinaireOld
+2,MotBinaire+2
    movff    MotBinaireOld
+3,MotBinaire+3
    movff    MotBinaireOld
+4,MotBinaire+4
    movff    MotBinaire
+1,valeur1+3
    movff    MotBinaire
+2,valeur1+2
    movff    MotBinaire
+3,valeur1+1
    movff    MotBinaire
+4,valeur1+0
    nop
    movlw    0xb6
    movwf    valeur2
+0
    movlw    0x06
    movwf    valeur2
+1
    clrf    valeur2
+2
    clrf    valeur2
+3
    call    soustraction32    
; résultat dans valeur1
    nop
    movff    valeur1
+3,MotBinaire+1
    movff    valeur1
+2,MotBinaire+2
    movff    valeur1
+1,MotBinaire+3
    movff    valeur1
+0,MotBinaire+4
    call    prog_AD9850
    nop
    call    tempoNote
    return
    
; ----------------------------------------------------------------------
re    ; 
    movff    MotBinaireOld
+1,MotBinaire+1
    movff    MotBinaireOld
+2,MotBinaire+2
    movff    MotBinaireOld
+3,MotBinaire+3
    movff    MotBinaireOld
+4,MotBinaire+4
    movff    MotBinaire
+1,valeur1+3
    movff    MotBinaire
+2,valeur1+2
    movff    MotBinaire
+3,valeur1+1
    movff    MotBinaire
+4,valeur1+0
    nop
    movlw    0xff
    movwf    valeur2
+0
    movlw    0x08
    movwf    valeur2
+1
    clrf    valeur2
+2
    clrf    valeur2
+3
    call    soustraction32    
; résultat dans valeur1
    nop
    movff    valeur1
+3,MotBinaire+1
    movff    valeur1
+2,MotBinaire+2
    movff    valeur1
+1,MotBinaire+3
    movff    valeur1
+0,MotBinaire+4
    call    prog_AD9850
    nop
    call    tempoNote
    return

; ----------------------------------------------------------------------
blanc
    clrf    MotBinaire
+0
    clrf    MotBinaire
+1
    clrf    MotBinaire
+2
    clrf    MotBinaire
+3
    clrf    MotBinaire
+4
    call    prog_AD9850
    nop
    call    tempoBlanc
    return
    

; ----------------------------------------------------------------------
;
 3500Khz: 00 07 2B 02 0C
; 3564Khz: 00 07 4C 8F FB
; 5500Khz: 00 0B 43 95 81
; 6981Khz; 00 0E 4C 0D F5
; 7000Khz: 00 0E 56 04 18
; 7011Khz: 00 0E 5C 4E 00
; 7012Khz: 00 0E 5C 4E B5
; 7020Khz: 00 0E 60 80 73
; 7043khz: 00 0E 6C 8F 75


prog_AD9850
    
; 
    movff    MotBinaire
+4,tampon    ;      1011 0011
    call    traitement_octet
    
; 
    movff    MotBinaire
+3,tampon    ;     1010 0111
    call    traitement_octet
    
; 
    movff    MotBinaire
+2,tampon    ;     0111 0000
    call    traitement_octet
    
; 
    movff    MotBinaire
+1,tampon    ;     0000 1101
    call    traitement_octet
    
; toujours initialisé à 0x00
    movff    MotBinaire
,tampon    ;     0000 0000
    call    traitement_octet
    
; validation
    bsf    fq_ud
    bcf    fq_ud    
    return        

; traite chaque bit de l'octet et les valides par un front montant w_clk
traitement_octet
    movlw    8
    movwf    ptr
    movff    tampon,WREG
loop_octet
    rrcf    WREG,w        
    bcf    datas
    btfsc    STATUS,C
    bsf    datas
    bsf    w_clk
    bcf    w_clk
    decfsz    ptr
    bra    loop_octet
    return

; ----------------------------------------------------------------------
soustraction16    ; by F6FCO
    movf    valeur2,w
    subwf    valeur1
    movf    valeur2+1,w
    subwfb    valeur1+1
    movf    valeur2+2,w
    subwfb    valeur1+2
    return


; ----------------------------------------------------------------------
soustraction32    ; by F6FCO
    movf    valeur2,w
    subwf    valeur1
    movf    valeur2+1,w
    subwfb    valeur1+1
    movf    valeur2+2,w
    subwfb    valeur1+2
    movf    valeur2+3,w
    subwfb    valeur1+3
    movf    valeur2+4,w
    subwfb    valeur1+4
    return
    

; ----------------------------------------------------------------------
addition32    ; by F6FCO
    movf    valeur1,w
    addwf    valeur2,f
    movf    valeur1+1,w
    addwfc    valeur2+1,f
    movf    valeur1+2,w
    addwfc    valeur2+2,f
    movf    valeur1+3,w
    addwfc    valeur2+3,f
    ; s'
il y a carry il sera stocké dans report16
    movf    STATUS
,w
    andlw    0x1
    movwf    report16
    return    

;========================================================================================
;
 Unsigned 32/16 bit division  (approx 552 to 712 cycles)
;
 déclarer variables tampon:1 dividende32:4, diviseur32:4
;
;
 Inputs:    Dividende -> dividende32+3 à dividende32 (32 bits)
;
        Diviseur  -> diviseur32+1 à diviseur32 (16 bits)
;
Temporary:    compteur -> tampon
; Output:    Quotient -> dans dividende32 (32 bits)
;
        Reste -> dans diviseur32+2 à diviseur32+(16 bits)
;
            by Peter G. Harrison
;========================================================================================
div32_16    
    movlw    d
'32'                ; 32-bit divide by 16-bit
    movwf    tampon
    clrf    diviseur32
+3        ; clear remainder
    clrf    diviseur32
+2

dvloop    bcf    STATUS
,C             ; set quotient bit to 0, shift left dividend & quotient
    rlcf    dividende32            
; low byte
    rlcf    dividende32
+1
    rlcf    dividende32
+2
    rlcf    dividende32
+3        ; msb into carry
    rlcf    diviseur32
+2        ; and then into partial remainder
    rlcf    diviseur32
+3
    bc    subdiv                
; if overflow then remainder > divisor so can subtract
    movf    diviseur32
+1,w        ; compare partial remainder and divisor
    subwf    diviseur32
+3,w
    bnz    testgt                
; if hi bytes =, check low bytes, else check for >

    movf    diviseur32,w        ; high bytes are = so compare low bytes
    subwf    diviseur32
+2,w
testgt    bnc    remrlt                
; if carry set remainder > divisor, so ok to subtract
subdiv    movf    diviseur32
,w        ; subtract divisor from partial remainder
    subwf    diviseur32
+2,f
    movf    diviseur32
+1,w
    subwfb    diviseur32
+3,f
    bsf    dividende32
,0        ; set quotient bit to 1
;            quotient replaces dividend which is lost
remrlt    decfsz    tampon
    bra    dvloop
    return
            
; ----------------------------------------------------------------------
division32    ; by F6FCO    
    
; on vérifie si c'est une division par zéro, si c'est le cas on charge le dividende dans le quotient.
    ; dividende/0=dividende, pas cohérent mathématiquement mais nécessaire dans le projet en cas de ligne
    
; horizontale (Y=0) ou verticale (X=0).
    movf    diviseur32,diviseur32
    btfss    STATUS
,Z
    bra    div32            
div_zero32    
    movf    diviseur32
+1,diviseur32+1
    btfsc    STATUS
,Z
    movf    diviseur32
+2,diviseur32+2
    btfsc    STATUS
,Z
    movf    diviseur32
+3,diviseur32+3
    btfsc    STATUS
,Z
    bra    div_quot32
            
div32        
; on initialise quotient=0
    clrf    quotient32
    clrf    quotient32
+1
    clrf    quotient32
+2
    clrf    quotient32
+3
    
; reste=dividende
    movff    dividende32
,reste32
    movff    dividende32
+1,reste32+1
    movff    dividende32
+2,reste32+2
    movff    dividende32
+3,reste32+3
            
div32_0    
; test poids3
    movf    reste32
+3,w
    subwf    diviseur32
+3,w            
    
; test si poids3 reste>diviseur ?
    btfss    STATUS,C                    
    bra    div32_3            
    
; test si poids2 reste=diviseur ? sinon on sort    
    bz    div32_1
findiv32    return
            
            
div32_1    
; test poids2
    movf    reste32
+2,w
    subwf    diviseur32
+2,w            
    
; test si poids2 reste>diviseur ?
    btfss    STATUS,C                    
    bra    div32_3            
    
; test si poids2 reste=diviseur ? sinon on sort    
    bz    div32_2
    return

div32_2    
; test poids1
    movf    reste32
+1,w
    subwf    diviseur32
+1,w            
    
; test si poids1 reste>diviseur ?
    btfss    STATUS,C                    
    bra    div32_3            
    
; test si poids1 reste=diviseur ? sinon on sort
    bz    div32_22
    return

div32_22    
; test si poids0 reste>=diviseur
    movff    reste32
,WREG
    subwf    diviseur32
,w
    btfss    STATUS
,C
    bra    div32_3
    bz    div32_3
    return
            
div32_3    
; reste=dividende-diviseur
    nop
    movff    reste32
,valeur1
    movff    reste32
+1,valeur1+1
    movff    reste32
+2,valeur1+2
    movff    reste32
+3,valeur1+3
                        
    movff    diviseur32
,valeur2
    movff    diviseur32
+1,valeur2+1
    movff    diviseur32
+2,valeur2+2
    movff    diviseur32
+3,valeur2+3
            
    call    soustraction32            
; résultat dans valeur1, +1, +2 et +3
    movff    valeur1
,reste32
    movff    valeur1
+1,reste32+1
    movff    valeur1
+2,reste32+2
    movff    valeur1
+3,reste32+3
            
    
; quotient +1
    bcf    STATUS
,C
    movlw    1
    addwf    quotient32
    
; on additionne le carry dans les poids forts
    movf    STATUS
,C
    andlw    0x1
    addwf    quotient32
+1
    movf    STATUS
,C
    andlw    0x1
    addwf    quotient32
+2
    movf    STATUS
,C
    andlw    0x1
    addwf    quotient32
+3
    bra    div32_0
            
div_quot32    
; en cas de division par zéro on charge le dividende dans le quotient
    movff    dividende32
,quotient32
    movff    dividende32
+1,quotient32+1
    movff    dividende32
+2,quotient32+2
    movff    dividende32
+3,quotient32+3
    return

;**************************************************************************
;
Div4824U
;Inputs:
;
    dividende48 - dividende48:6    (- least significant!)
;
    Divisor     - diviseur24:3    (- least significant!)
;
Temporary:
;
    ptrer     - ptr
;    Shift     - Shift:6
;Output:
;
    Quotient - dividende48:6    (- least significant!)
;
    Remainder- Rem:3    (- least significant!)
;
;
Adaptation of 24x24 division by Tony Nixon with corrections
;by Frank Finster 3/15/2005.
;Code adapted by Andy Lee
;01-Sep-2006    Original version
;**************************************************************************

div48_24
; SUBROUTINE - 48 by 24 BIT DIVISION
    movlw 48
    movwf ptr
    movff dividende48
+0, Shift+0
    movff dividende48
+1, Shift+1
    movff dividende48
+2, Shift+2
    movff dividende48
+3, Shift+3
    movff dividende48
+4, Shift+4
    movff dividende48
+5, Shift+5
    clrf dividende48
+0
    clrf dividende48
+1
    clrf dividende48
+2
    clrf dividende48
+3
    clrf dividende48
+4
    clrf dividende48
+5
    clrf Rem
+2
    clrf Rem
+1
    clrf Rem
+0
dloop
    bcf STATUS
, C
    rlcf Shift
+0
    rlcf Shift
+1
    rlcf Shift
+2
    rlcf Shift
+3
    rlcf Shift
+4
    rlcf Shift
+5
    rlcf Rem
+0
    rlcf Rem
+1
    rlcf Rem
+2
    movf diviseur24
+2, w
    subwf Rem
+2, w
    btfss STATUS
, Z
    bra nochk

    movf diviseur24
+1,w
    subwf Rem
+1,w
    btfss STATUS
, Z
    bra nochk
    movf diviseur24
+0,w
    subwf Rem
+0,w
nochk
    btfss STATUS
, C
    bra nogo
    movf diviseur24
+0,w
    subwf Rem
+0
    btfsc STATUS
, C
    bra    nodec_remainM
    decf Rem
+1, f
    movf Rem
+1, w
    xorlw 0xff
    btfsc STATUS
, Z
    decf Rem
+2, f
nodec_remainM
    movf diviseur24
+1, w
    subwf Rem
+1, f
    btfss STATUS
, C
    decf Rem
+2, f
    movf diviseur24
+2, w
    subwf Rem
+2, f
    bsf STATUS
, C
nogo
    rlcf dividende48
+0
    rlcf dividende48
+1
    rlcf dividende48
+2
    rlcf dividende48
+3
    rlcf dividende48
+4
    rlcf dividende48
+5
    decfsz ptr
, f
    goto dloop
       return


;------------------------------------------------------------------------------
;
;
        Gestion encodeur rotatif _ F6FCO
;            Octobre 2021
;
;
    pin A de l'encodeur sur PORTD,0
;    pin B de l'
encodeur sur PORTD,1
;
;
 Déclarer les variables:
;
    EncA_old    :1     ; état de la pin A de l'encodeur au tour d'avant
;    EncB_old    :1     ; état de la pin B de l'encodeur au tour d'avant
;    Sens        :1    ; sens de rotation de l'encodeur
;-------------------------------------------------------------------------------

gestion_encodeur
    movf    PORTB,w
    andlw    b'
00000001'
    subwf    EncA_old,w
    btfsc    STATUS,Z
    goto    enc1
        
enc3    movf    PORTB,w        ; est-ce que A=B_old ?
    andlw    b'
00000010'
    rrncf    WREG,w
    subwf    EncA_old,w
    btfsc    STATUS,Z
    goto    enc4
    movlw    1
    movwf    Sens        ; Sens=1  horaire
    
enc5    movf    PORTB,w
    andlw    b'
00000001'
    movwf    EncA_old
    movf    PORTB,w
    andlw    b'
00000010'
    movwf    EncB_old
    return    

enc1    movf    PORTB,W
    andlw    b'
00000010'
    subwf    EncB_old,w
    btfss    STATUS,Z
    goto    enc3
    
enc2    movlw    2
    movwf    Sens        ; sens=2  encodeur figé
    return
    
enc4    clrf    Sens        ; Sens=0 anti-horaire
    goto    enc5
    

; ------------------------------------------------------------------

modif_frq


    movlw    1
    subwf    Sens,w
    btfsc     STATUS,Z
    bra    increment
    
    clrf    WREG
    cpfseq    Sens
    return    ; si Sens=2 encodeur pas touché, on sort
    
    ; --------------------------
    ; increment 10hz  (0x0158)    
    ; incrément 50hz  (0x06B6)
    ; incrément 100Hz (0x0d6c)
    ; incrément 250Hz (0x218e)
    ; incrément 500Hz (0x431c)

decrement    ; si Sens=0
    movlw    0x6c
    movwf    valeur2+0
    movlw    0x0d
    movwf    valeur2+1
    clrf    valeur2+2
    clrf    valeur2+3
    clrf    valeur2+4
    clrf    valeur2+5

    movff    MotBinaire+4,valeur1+0
    movff    MotBinaire+3,valeur1+1
    movff    MotBinaire+2,valeur1+2
    movff    MotBinaire+1,valeur1+3
    movff    MotBinaire+0,valeur1+4
    clrf    valeur1+5
    call    soustraction32
    movff    valeur1+4,MotBinaire+0
    movff    valeur1+3,MotBinaire+1
    movff    valeur1+2,MotBinaire+2
    movff    valeur1+1,MotBinaire+3
    movff    valeur1+0,MotBinaire+4
    call    conversion_frq
    call    conversion_ascii
    call    Lcd_affichage
    return    
    
increment    ; si Sens=1
    movlw    0x6c
    movwf    valeur2+0
    movlw    0x0d
    movwf    valeur2+1
    clrf    valeur2+2
    clrf    valeur2+3
    clrf    valeur2+4
    clrf    valeur2+5

    movff    MotBinaire+4,valeur1+0
    movff    MotBinaire+3,valeur1+1
    movff    MotBinaire+2,valeur1+2
    movff    MotBinaire+1,valeur1+3
    movff    MotBinaire+0,valeur1+4
    clrf    valeur1+5
    call    addition32
    movff    valeur2+4,MotBinaire+0
    movff    valeur2+3,MotBinaire+1
    movff    valeur2+2,MotBinaire+2
    movff    valeur2+1,MotBinaire+3
    movff    valeur2+0,MotBinaire+4
    call    conversion_frq
    call    conversion_ascii
    call    Lcd_affichage
    return    
    
    
;--------------------------------------------------------------------
conversion_frq
; On commence par déconstruire le mot binaire de prog AD9850 pour le convertir en fréquence
    ; MotBinaire dans le dividende
    clrf    frq_affichage+0
    clrf    frq_affichage+1
    clrf    frq_affichage+2
    clrf    frq_affichage+3
    clrf    frq_affichage+4
    clrf    frq_affichage+5
    
    movff    MotBinaire+4,dividende32+0
    movff    MotBinaire+3,dividende32+1
    movff    MotBinaire+2,dividende32+2
    movff    MotBinaire+1,dividende32+3
        
    ; la constante d'
3436' (0x0d6c)  qui est le produit de (2^32/1250000) dans le diviseur
    movlw    0x6c
    movwf    diviseur32+0
    movlw    0x0d
    movwf    diviseur32+1
    clrf    diviseur32+2
    clrf    diviseur32+3
    nop
    call    div32_16
    nop
    nop
    
    ;########################## Test
    ;movlw    0xa2
    ;movwf    dividende32+0
    ;movlw    0x42
    ;movwf    dividende32+1
    ;movlw    0x0e
    ;movwf    dividende32+2
    ;clrf    dividende32+3
    ;nop
    ;########################### /Test
    
    movlw    0x01
    cpfslt    dividende32+2
    bra    div1
    movlw    0x86
    cpfslt    dividende32+1
    bra    div1
    movlw    0xa0
    cpfslt    dividende32+0
    bra    div1
    clrf    frq_affichage+5
    bra    suite1
    ; division par 100 000        
div1    movlw    0xa0
    movwf    diviseur32+0
    movlw    0x86
    movwf    diviseur32+1
    movlw    0x01
    movwf    diviseur32+2
    clrf    diviseur32+3
    call    division32
    movff    quotient32+0,frq_affichage+5    ; sixième chiffre placé  (0)
    movff    reste32+0,dividende32+0
    movff    reste32+1,dividende32+1
    movff    reste32+2,dividende32+2
    movff    reste32+3,dividende32+3
    nop
    
    
suite1    movlw    d'
0'
    cpfslt    dividende32+2
    bra    div2
    movlw    0x27
    cpfslt    dividende32+1
    bra    div2
    movlw    0x10
    cpfslt    dividende32+0
    bra    div2
    clrf    frq_affichage+4
    bra    suite2
    ; division par 10 000    
div2    movlw    0x10
    movwf    diviseur32+0
    movlw    0x27
    movwf    diviseur32+1
    clrf    diviseur32+2
    call    division32
    movff    quotient32+0,frq_affichage+4    ; cinquième chiffre placé  (7)
    movff    reste32+0,dividende32+0
    movff    reste32+1,dividende32+1
    movff    reste32+2,dividende32+2
    movff    reste32+3,dividende32+3
    nop
    
    
suite2    movlw    d'
0'
    cpfslt    dividende32+2
    bra    div3
    movlw    0x03
    cpfslt    dividende32+1
    bra    div3
    movlw    0x08
    cpfslt    dividende32+0
    bra    div3
    clrf    frq_affichage+3
    bra    suite3
    ; division par 1000    
div3    movlw    0xe8
    movwf    diviseur32+0
    movlw    0x03
    movwf    diviseur32+1
    call    division32
    movff    quotient32+0,frq_affichage+3    ; quatrième chiffre placé  (1)
    movff    reste32+0,dividende32+0
    movff    reste32+1,dividende32+1
    movff    reste32+2,dividende32+2
    movff    reste32+3,dividende32+3
    nop
    

suite3    movlw    d'
0'
    cpfslt    dividende32+2
    bra    div4
    cpfslt    dividende32+1
    bra    div4
    movlw    0x64
    cpfslt    dividende32+0
    bra    div4
    clrf    frq_affichage+2
    bra    suite4
    ; division par 100
div4    movlw    0x64
    movwf    diviseur32+0
    clrf    diviseur32+1
    call    division32
    movff    quotient32+0,frq_affichage+2    ; troisième chiffre placé  (1)
    movff    reste32+0,dividende32+0
    movff    reste32+1,dividende32+1
    movff    reste32+2,dividende32+2
    movff    reste32+3,dividende32+3
    nop
    
suite4    movlw    d'
0'
    cpfslt    dividende32+2
    bra    div5
    cpfslt    dividende32+1
    bra    div5
    movlw     0x0a
    cpfslt    dividende32+0
    bra    div5
    clrf    frq_affichage+1
    bra    suite5
    ; division par 10    
div5    movlw    0x0a
    movwf    diviseur32+0
    call    division32
    movff    quotient32+0,frq_affichage+1    ; deuxième chiffre placé (1)
    movff    reste32+0,dividende32+0
    movff    reste32+1,dividende32+1
    movff    reste32+2,dividende32+2
    movff    reste32+3,dividende32+3
    nop
    
    ; placement dernier chiffre
suite5    movff    reste32+0,frq_affichage+0    ; deuxième chiffre placé

    nop
    return    
; ---------------------------------------------------------------------------------
conversion_ascii
    movlw    d'
48'
    addwf    frq_affichage+0,f
    addwf    frq_affichage+1,f
    addwf    frq_affichage+2,f
    addwf    frq_affichage+3,f
    addwf    frq_affichage+4,f
    addwf    frq_affichage+5,f
    return
    
; ---------------------------------------------------------------------------------
Lcd_affichage
    LCD_LIGNE d'
1'
    LCD_COLONNE d'
3'
    movf    frq_affichage+5,w
    LCD_AFF_DATAS_W
    movf    frq_affichage+4,w
    LCD_AFF_DATAS_W
    movf    frq_affichage+3,w
    LCD_AFF_DATAS_W
    movf    frq_affichage+2,w
    LCD_AFF_DATAS_W
    movf    frq_affichage+1,w
    LCD_AFF_DATAS_W
    LCD_AFF_DATAS '
.'
    movf    frq_affichage+0,w
    LCD_AFF_DATAS_W

    LCD_AFF_DATAS '
K'
    LCD_AFF_DATAS '
h'
    LCD_AFF_DATAS '
z'


    return
    
; ----------------------------------------------------------------------
F6FCO    
    ; ------------ ligne 1, colonne 3 affichage F6FCO
    LCD_LIGNE d'
1'
    LCD_COLONNE d'
1'
    movlw    '
-'
    LCD_AFF_DATAS_W
    LCD_AFF_DATAS '
*'
    LCD_AFF_DATAS '
('
    LCD_AFF_DATAS '
 '
    movlw    'b'
    LCD_AFF_DATAS_W
    movlw    '
y'
    LCD_AFF_DATAS_W
    LCD_AFF_DATAS '
 '
    LCD_AFF_DATAS '
F'
    LCD_AFF_DATAS '
6'
    LCD_AFF_DATAS '
F'
    LCD_AFF_DATAS '
C'
    LCD_AFF_DATAS '
O'
    LCD_AFF_DATAS '
 '
    LCD_AFF_DATAS '
)'
    LCD_AFF_DATAS '
*'
    LCD_AFF_DATAS '
-'
    return

; ----------------------------------------------------------------------
fq7012    ; ----------------- 7012.0Khz  0x0e5c5c21
    movlw    0x21
    movwf    MotBinaire+4
    movlw    0x5c
    movwf    MotBinaire+3
    movlw    0x5c
    movwf    MotBinaire+2
    movlw    0x0e
    movwf    MotBinaire+1
    movlw    0x00
    movwf    MotBinaire+0
    movff    MotBinaire+0,MotBinaireOld+0
    movff    MotBinaire+1,MotBinaireOld+1
    movff    MotBinaire+2,MotBinaireOld+2
    movff    MotBinaire+3,MotBinaireOld+3
    movff    MotBinaire+4,MotBinaireOld+4
    call    conversion_frq
    call    conversion_ascii
    call    Lcd_affichage
    return
    
; ----------------------------------------------------------------------
fq3564    ; ----------------- 3564.0Khz  0x044c9d68
    movlw    0x68
    movwf    MotBinaire+4
    movlw    0x9d
    movwf    MotBinaire+3
    movlw    0x4c
    movwf    MotBinaire+2
    movlw    0x07
    movwf    MotBinaire+1
    movlw    0x00
    movwf    MotBinaire+0
    movff    MotBinaire+0,MotBinaireOld+0
    movff    MotBinaire+1,MotBinaireOld+1
    movff    MotBinaire+2,MotBinaireOld+2
    movff    MotBinaire+3,MotBinaireOld+3
    movff    MotBinaire+4,MotBinaireOld+4
    call    conversion_frq
    call    conversion_ascii
    call    Lcd_affichage
    return
    
; ----------------------------------------------------------------------
fq10112    ; ------------------ 10112.0Khz  0x14b5a716
    movlw    0x16
    movwf    MotBinaire+4
    movlw    0xa7
    movwf    MotBinaire+3
    movlw    0xb5
    movwf    MotBinaire+2
    movlw    0x14
    movwf    MotBinaire+1
    movlw    0x00
    movwf    MotBinaire+0
    movff    MotBinaire+0,MotBinaireOld+0
    movff    MotBinaire+1,MotBinaireOld+1
    movff    MotBinaire+2,MotBinaireOld+2
    movff    MotBinaire+3,MotBinaireOld+3
    movff    MotBinaire+4,MotBinaireOld+4
    call    conversion_frq
    call    conversion_ascii
    call    Lcd_affichage
    return


Code : Tout sélectionner


    
tempoBlanc
    call    tempo100ms
    return
    
tempoNote
    call    tempo150ms
    return
    
tempo1ms
; Délai 1 000 Cycles de la machine
; Durée du délai 1 millisecond
; Fréquence de l'oscillateur 4 MHZ

            movlw       .75
            movwf       Reg_1,1
            movlw       .2
            movwf       Reg_2
            decfsz      Reg_1,F,1
            bra         $-2
            decfsz      Reg_2
            bra         $-6

        return

tempo5ms
; Délai 5 000 Cycles de la machine
; Durée du délai 5 millisecond
; Fréquence de l'
oscillateur 4 MHZ

            movlw       .125
            movwf       Reg_1
,1
            movlw       .7
            movwf       Reg_2
            decfsz      Reg_1
,F,1
            bra         
$-2
            decfsz      Reg_2
            bra         
$-6
            return
            
tempo50ms
; Délai 50 000 Cycles de la machine
; Durée du délai 50 millisecond
; Fréquence de l'oscillateur 4 MHZ

            movlw       .238
            movwf       Reg_1,1
            movlw       .65
            movwf       Reg_2
            decfsz      Reg_1,F,1
            bra         $-2
            decfsz      Reg_2
            bra         $-6
            nop

    return
            
tempo100ms
; Délai 100 000 Cycles de la machine
; Durée du délai 100 millisecond
; Fréquence de l'
oscillateur 4 MHZ

            movlw       .221
            movwf       Reg_1
,1
            movlw       .130
            movwf       Reg_2
            decfsz      Reg_1
,F,1
            bra         
$-2
            decfsz      Reg_2
            bra         
$-6
            nop
            nop
        return
        
        
tempo150ms
; Délai 150 000 Cycles de la machine
; Durée du délai 150 millisecond
; Fréquence de l'oscillateur 4 MHZ

            movlw       .205
            movwf       Reg_1,1
            movlw       .195
            movwf       Reg_2
            decfsz      Reg_1,F,1
            bra         $-2
            decfsz      Reg_2
            bra         $-6
    return
        

tempo200ms
; Délai 200 000 Cycles de la machine
; Durée du délai 200 millisecond
; Fréquence de l'
oscillateur 4 MHZ

            movlw       .186
            movwf       Reg_1
,1
            movlw       .4
            movwf       Reg_2
            movlw       .2
            movwf       Reg_3
            decfsz      Reg_1
,F,1
            bra         
$-2
            decfsz      Reg_2
            bra         
$-6
            decfsz      Reg_3
            bra         
$-.10
            nop
            return
            
tempo400ms
; Délai 400 000 Cycles de la machine
; Durée du délai 400 millisecond
; Fréquence de l'oscillateur 4 MHZ

            movlw       .119
            movwf       Reg_1,1
            movlw       .8
            movwf       Reg_2
            movlw       .3
            movwf       Reg_3
            decfsz      Reg_1,F,1
            bra         $-2
            decfsz      Reg_2
            bra         $-6
            decfsz      Reg_3
            bra         $-.10

    return
        
tempo1000ms
; Délai 1 000 000 Cycles de la machine
; Durée du délai 1000 millisecond
; Fréquence de l'
oscillateur 4 MHZ

            movlw       .173
            movwf       Reg_1
,1
            movlw       .19
            movwf       Reg_2
            movlw       .6
            movwf       Reg_3
            decfsz      Reg_1
,F,1
            bra         
$-2
            decfsz      Reg_2
            bra         
$-6
            decfsz      Reg_3
            bra         
$-.10
            nop
            nop
        return


tempo1500ms
; Délai 3 000 000 Cycles de la machine
; Durée du délai 1500 millisecond
; Fréquence de l'oscillateur 8 MHZ

            movlw       .13
            movwf       Reg_1,1
            movlw       .57
            movwf       Reg_2
            movlw       .16
            movwf       Reg_3
            decfsz      Reg_1,F,1
            bra         $-2
            decfsz      Reg_2
            bra         $-6
            decfsz      Reg_3
            bra         $-.10
            nop
            nop
        return
Modifié en dernier par F6FCO le ven. 10 déc. 2021 23:37, modifié 1 fois.
Une porte nand prend 2 bits en entrée... la cochonne !!! :langue:

Programmer l'AD9850
F6FCO
Avatar de l’utilisateur
Expert
Expert
Messages : 1413
Âge : 70
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#66 Message par F6FCO » ven. 10 déc. 2021 23:36

Toujours sur la même base du VFO DDS j'ai commencé l'étude d'un affichage avec des vieux tubes Russes IV9 qui datent du temps de la guerre froide, pour le plaisir de mêler la technologie moderne avec celle du siècle dernier. Ces IV9 s'alimentent en 5vcc, pratique. J'ai un peu bataillé parce que je n'arrivais pas à les multiplexer, pas moyen d'isoler les tubes un par un. Le pbm venait du câblage des electrodes à l'intérieur des tubes qui ont toutes un point commun, quoi que je fasse il y avait toujours des retours de courant et tous les tubes s'allumaient de la même façon, même ceux qui n'étaient pas sélectionnés avec leur commun en l'air.

Le datasheet d'époque :-D

IV9_2.jpg


IV3_9.jpg


J'ai fais des essais en isolant les filaments avec des diodes, çà fonctionnait bien mais pour un affichage à 6 tubes et 9 electrodes/tubes il aurait fallu câbler 54 diodes, une vraie usine à gaz.
Finalement j'ai utilisé des registres 74LS595 pour faire fonctionner le bazar mais ce n'est pas ce que je voulais au départ, j'aurai voulu rester dans le vintage.
Bref çà marche, on n'en parle plus.
Pour les tests, par manque de place sur les breadboards je ne peux utiliser que 2 tubes, mais çà me permet quand même de mettre le programme au point.

IV9_5.JPG
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Une porte nand prend 2 bits en entrée... la cochonne !!! :langue:

Programmer l'AD9850
F6FCO
Avatar de l’utilisateur
Expert
Expert
Messages : 1413
Âge : 70
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#67 Message par F6FCO » sam. 11 déc. 2021 14:03

Hello tous,
Je viens de me rendre compte, après avoir conduit le projet à son terme avec succès sur un 18F4525 que j'utilisais un fichier 18F2525.inc, et déclaration en entête pour un 18F2525.
Trop de copier/coller et mémoire de serin, mais qui supposerait que les fichiers 18F2525.inc et 18F4525.inc sont similaires et interchangeables.
Erreur éducatrice et constructive :wink:
Une porte nand prend 2 bits en entrée... la cochonne !!! :langue:

Programmer l'AD9850
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 2589
Âge : 73
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#68 Message par paulfjujo » sam. 11 déc. 2021 17:36

bonsoir à tous,

F6FCO a écrit :Hello tous,
Je viens de me rendre compte, après avoir conduit le projet à son terme avec succès sur un 18F4525 que j'utilisais un fichier 18F2525.inc, et déclaration en entête pour un 18F2525.
Trop de copier/coller et mémoire de serin, mais qui supposerait que les fichiers 18F2525.inc et 18F4525.inc sont similaires et interchangeables.
Erreur éducatrice et constructive :wink:




:!!: tant qu'on ne declare pas d'entree/sortie sur le port D ! ...

j'avais déja constaté celà entre 18f27k42 et 47k42
:sifflotte: le compilo ne voit/ compte pas le nb de pins
Aide toi, le ciel ou FantasPic t'aidera

Programmer l'AD9850
F6FCO
Avatar de l’utilisateur
Expert
Expert
Messages : 1413
Âge : 70
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#69 Message par F6FCO » dim. 12 déc. 2021 00:02

Oui, sous réserve bien sur qu'on utilise les entrées/sorties compatibles avec les deux, ce que je faisais dans ce cas.
Une porte nand prend 2 bits en entrée... la cochonne !!! :langue:

Programmer l'AD9850
F6FCO
Avatar de l’utilisateur
Expert
Expert
Messages : 1413
Âge : 70
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#70 Message par F6FCO » dim. 12 déc. 2021 10:54

Hello tous,

J'ai travaillé pour rien, j'ai recommencé deux fois le programme à cause de mauvaises décisions.
J'ai embrayé l'affichage à tubes sur le gros 18F4525 et je me suis dit que c'était ballot d'utiliser un gros 40pins pour seulement 3 fils de commande sur l'affichage.
J'ai tout recommencé avec un PIC18F2525 à 28pins et puis au milieu du programme je me suis dit que c'était ballot de faire un circuit spécifique pour des vieux tubes Russes pas simples à dénicher et en risque de pénurie prochaine.
J'ai de nouveau tout recommencé sur le gros PIC18F4525 et cette fois le programme sera capable de gérer en même temps un afficheur LCD1602 et un affichage à 6 tubes IV9. Après chacun branche ce qu'il veut dessus.
Et je ne recommence plus :roll:

Le programme est fonctionnel avec les deux tubes montés sur la breadboard, on recopie bien l'affichage LCD. Cà devrait théoriquement être bon avec les 6 tubes, je suis en train de travailler sur le circuit imprimé.

IV9_3.JPG


J'ai par contre un petit pbm de rémanence sur les filaments, je pense savoir pourquoi mais j'attends d'avoir les 6 tubes en fonction pour voir ce que çà donne.

IV9_4.JPG
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Une porte nand prend 2 bits en entrée... la cochonne !!! :langue:


Retourner vers « Langage ASM »

Qui est en ligne

Utilisateurs parcourant ce forum : Roger et 39 invités