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

Algorithme de Bresenham
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 2595
Enregistré en : juillet 2016
Localisation : Terre

#1 Message par Temps-x » sam. 28 mars 2020 17:46

Bonjour tout le forum,

Suite au programme écrit en RapidQ ICI sur l'algorithme de Bresenham, j'ai décidé de le réécrire pour microcontrôleur Pic

Je vous joins également un document expliquant son fonctionnement que vous pouvez télécharger ICI

J'ai traité actuellement 2 sujets, la lignes d'un point à un autre, et le cercle

J'ai utilisé un écran Oled 128x64 en mode de communication SPI pour vous montrer le résultat obtenu, voici son datasheet

Le microcontrôleur utilisé est un Pic18F26K22, voici son datasheet

Pour le rendre compatible pour les Pic16Fxxxx et Pic18Fxxxx je n'ai pas utilisé les instructions des microcontrôleurs Pic18Fxxxx

j'ai opté pour le mode SPI bit bang, ce qui permets de choisir les pattes quand veut sur le microcontrôleur, de plus ça le rends compatible
pour les microcontrôleurs ne possèdent pas du SPI

Voici mon branchement pour mode SPI

Code : Tout sélectionner

#DEFINE dc      LATA,2                 ; RA2 ==> sélection du mode : commande = 0 , donnée = 1
#DEFINE cs      LATA,1                 ; RA1 ==> activer ou désactiver la transmission
#DEFINE rst     LATA,0                 ; RA0 ==> reset de l'écran

#DEFINE sck     LATC,3                 ; RC3 ==> horloge de synchronisation 
#DEFINE mosi    LATC,5                 ; RC5 ==> envoyer les données sur écran oled 128x64
 


Le code ASM a été écrit avec jens file Editor 3.95

Fichier code + fichier à mettre dans le Pic : Line.zip

Une petite vidéo
https://youtu.be/JvbgqLQi7EU


Suite à une demande, je me suis aussi intéressé à l'algorithme de Bresenham sur le cercle

Le code ASM a été écrit avec jens file Editor 3.95

Fichier code + fichier à mettre dans le Pic : Circle-3.zip

Voici ce que ça donne

https://www.youtube.com/watch?v=V9DdnYO1-YM

Je tiens à signaler que ce cercle n'est pas encore parfais, mais il se rapproche vraiment de la réalité, de plus actuellement c'est une version 8 bits,
ce qui limite la taille à un rayon de 85 pixels (suffisant pour un écran OLED 128x64)


Chose qui m'a était demandé c'est d'expliqué les différentes fonction des sous programmes

Je ne parlerais pas de l'initiation de l'écran, voir à ce sujet ce post #1 qui est suffisamment documenté.

La fonction ligne sert à tracer un trait d'une position à une autre
La fonction circle sert à créer un rond avec un rayon mini de 1 pixel à 85 pixel
La fonction cls sert à effacer l'écran et la mémoire sdram ou son stocké le dessin de l'écran
La fonction print sert à écrire un texte à l'écran
La fonction locate sert à positionner le texte sur la longueur et hauteur
la fonction delay_s sert à créer une pause d'un temps de 10 ms minimum à 2550 ms maximum
la fonction delay_ms sert à créer une pause d'un temps de 1 ms minimum à 255 ms maximum
la fonction delay_µs sert à créer une pause d'un temps de 1 µs minimum à 255 µs maximum
La fonction pset sert à afficher un pixel à un endroit que vous avez précisé, et de mémorisé le pixel en sdram
La fonction ecriture_eeprom pour écrit dans l'eeprom du Pic
La fonction lecture_eeprom pour lire dans l'eeprom du Pic


Voilà c'est tout, on verra par la suite pour en rajouter, suite au demande.

Certain mon demandé à quoi ça pouvait servir d'écrire un pixel en mémoire sdram, et ben tout simplement à ne pas effacer les autres pixels qui son à l'écran.

Quand vous écrivez un pixel avec cette écran, c'est huit pixel d'un coup que vous allez écrire, ce qui fait que vous risquez d'effacer les autres pixels de l'écran.

C'est pour cela quand stock les pixels en sdram avant d'écrire le prochain pixel, une fois mémorisé en mémoire sdram en regarde quelle son les pixels qui son allumé ou éteint, puis on affiche 8 pixels d'un coup sans effacer les autres pixels de l'écran.

Attention car il faut 1024 octets de mémoire sdram pour stocker tout l'écran, les bank3, bank4, bank5, bank6, bank7 serve à cela dans les codes écrit ci-dessus, ce qui nous fait 5 bank et comme une bank fait 255 octets ça nous fait 255 x 5 = 1275 octets.

La bank 0 sert au variable, avec ce pic on est tranquille avec c'est 3896 octets de sdram :-)


==> A+
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Modifié en dernier par Temps-x le ven. 16 déc. 2022 13:46, modifié 70 fois.
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

Algorithme de Bresenham
venom
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 953
Âge : 38
Enregistré en : avril 2016
Localisation : Klyntar
Contact :

#2 Message par venom » sam. 28 mars 2020 18:20

:eek: Oh.... Beau rendu. #Temps-XMaSaperMaSoiree. :cry:

Bravo (même si je n'en attendais pas moins ;de ta part) :langue:







@++
Mon site web
Mon discord : venom#4888

Algorithme de Bresenham
JJE
Passioné
Passioné
Messages : 399
Âge : 83
Enregistré en : novembre 2017
Localisation : Picardie

#3 Message par JJE » mar. 31 mars 2020 18:41

merci Temps-x, belle réalisation.
Je m'en servirai dans mon papier en cours d'écriture sur la programmation modulaire en MPASM, ce qui fera une réponse plus complète
Cordialement

JJE

C'est pas parcequ'on n'a rien à dire qu'il faut fermer sa G....e

Algorithme de Bresenham
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 2595
Enregistré en : juillet 2016
Localisation : Terre

#4 Message par Temps-x » mer. 1 avr. 2020 04:44

Bonsoir JJE, et tout le forum,

Je te mets le code de l'algorithme de Bresenham, avec ses variables et sa macro, il y a rien d'autre

Code : Tout sélectionner

;***********************************************************************************************
;**********************************
 "déclaration des macros" **********************************
;***********************************************************************************************
line MACRO valeur1,valeur2,valeur3,valeur4,valeur5,valeur6

      local nombre7
,good_bye7
                                
      movlw valeur6
  
      btfss WREG
,0                        ; valeur6 = 0 que pour les nombres 
      goto nombre7                        
; valeur6 = 1 que pour les variables

      movf valeur1
,W                      ; 
      movwf x1                            
; 

      movf valeur2
,W                      ; 
      movwf y1                            
; 
                          
      movf valeur3
,W                      ; 
      movwf x2                            
; 

      movf valeur4
,W                      ; 
      movwf y2                            
; 

      movf valeur5
,W                      ; 
      movwf couleur                       
; 

      goto good_bye7

nombre7
      movlw valeur1                       
; 
      movwf x1                            
; 

      movlw valeur2                       
; 
      movwf y1                            
; 
                          
      movlw valeur3                       
; 
      movwf x2                            
; 

      movlw valeur4                       
; 
      movwf y2                            
; 

      movlw valeur5                       
; 
      movwf couleur                       
; 
                                  
good_bye7

      call ligne

    ENDM
;***********************************************************************************************
;*********************************
 "déclaration des variables" *********************************
;***********************************************************************************************

 CBLOCK H'20'                          
      tmps                
:4
 
      x1                  
:1
      x2                  
:1
      y1                  
:1
      y2                  
:1

      x                   
:1
      y                   
:1
  
      xdist               
:1
      ydist               
:1
 
      couleur             
:1

      pas                 
:1

      erreur              
:1

    ENDC

;***********************************************************************************************
;****************************
 tracé de ligne d'un point à un autre *****************************
;***********************************************************************************************
ligne
      clrf erreur

      clrf tmps+0
      clrf tmps+1

      clrf ydist
      clrf xdist   

      clrf pas

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

      movf x1,W                           ; x_dist = abs(x2-x1)
      subwf x2,W 
      movwf xdist

      btfsc STATUS,C
      goto st1

      movf xdist,W
      sublw D'
0'
      
      movwf xdist
      
;-----------------------------------------------------------------------------------------------
st1
      movf y1,W                           ; y_dist = abs(y2-y1)
      subwf y2,W 
      movwf ydist                                     

      btfsc STATUS,C
      goto st2

      movf ydist,W
      sublw D'
0'
      
      movwf ydist     

;-----------------------------------------------------------------------------------------------
st2

      movf y1,W                           ; if y2-y1 < -xdist then
      subwf y2,W                                                 
      movwf tmps+0  

      btfsc STATUS,C                      ; est ce que (y2-y1) est négatif
      goto st3                     

      movf tmps+0,W
      sublw D'
0'
      movwf tmps+0
                                  
      movf tmps+0,W                       ;
      subwf xdist,W                       ;
                         
      btfss STATUS,C
      goto permute  

;-----------------------------------------------------------------------------------------------
st3
      movf x1,W                           ; if x2-x1 <= -ydist then
      subwf x2,W                                                 
      movwf tmps+0

      btfsc STATUS,C                      ; est ce que (x2-x1) est négatif
      goto coin                     
                                  
      movf tmps+0,W
      sublw D'
0'
      movwf tmps+0

      movf tmps+0,W
      subwf ydist,W 
                         
      btfsc STATUS,C
      goto coin

;-----------------------------------------------------------------------------------------------
permute                
      movf x1,W                           ; swap x1,x2
      movwf tmps+0

      movf x2,W
      movwf tmps+1

      movf tmps+1,W
      movwf x1

      movf tmps+0,W
      movwf x2
    
      movf y1,W                           ; swap y1,y2
      movwf tmps+0                            
                               
      movf y2,W
      movwf tmps+1
                               
      movf tmps+1,W
      movwf y1

      movf tmps+0,W
      movwf y2

;-----------------------------------------------------------------------------------------------
coin
      movf x1,W                           ; if x1 < x2 then xpas = 1 else xpas = -1
      subwf x2,W
   
      btfsc STATUS,C   
      bsf pas,0                          ; x1 < x2
      btfss STATUS,C
      bcf pas,0                          ; x1 > x2 
 
      movf y1,W                          ; if y1 < y2 then ypas = 1 else ypas = -1 
      subwf y2,W
  
      btfsc STATUS,C
      bsf pas,1                          ; y1 < y2
      btfss STATUS,C
      bcf pas,1                          ; y1 > y2 
  
;-----------------------------------------------------------------------------------------------

      movf ydist,W                       ; if ydist > xdist then
      subwf xdist,W

      btfsc STATUS,C
      goto remb3      

      bcf STATUS,C
      rrcf ydist,W
      
      movwf erreur                        ; erreur = ydist/2

      movf x1,W                           ; x = x1
      movwf x                          

;-----------------------------------------------------------------------------------------------
      movf y1,W                           ; for y = y1 TO y2     
      movwf y

      decf y,F
remb1                                          
      incf y,F

     ; pset x,y,0,1                       ; pset x,y,couleur,1

      movf xdist,W
      subwf erreur,F                      ; erreur = erreur - xdist    

                                          ; if erreur < 0 THEN
      btfsc STATUS,C   
      goto remb2
                                  
      btfsc pas,0   
      incf  x,F                           ; x = x + 1
      btfss pas,0
      decf  x,F                           ; x = x - 1   
                                            
      movf ydist,W
      addwf erreur,F                      ; erreur = erreur + ydist                                   
                                          
remb2
      movf y2,W
      xorwf y,W
      btfss STATUS,Z 
      goto remb1                           ; next y

      return

;-----------------------------------------------------------------------------------------------
remb3                                     ; else  

      bcf STATUS,C
      rrcf xdist,W                        ; erreur = xdist/2  

      movwf erreur                        ;

      movf y1,W                           ; y = Y1
      movwf y      

      movf x1,W 
      movwf x

      decf x,F
remb4                                     ; for x = x1 TO x2     
      incf x,F

    ;  pset x,y,0,1                        ; pset x,y,couleur,1

      movf ydist,W
      subwf erreur,F                      ; erreur = erreur - ydist    


      btfsc STATUS,C                      ; if erreur < 0 then
      goto remb5
  
      btfsc pas,1   
      incf y,F                            ; y = y + 1
      btfss pas,1
      decf y,F                            ; y = y - 1   

      movf xdist,W
      addwf erreur,F                      ; erreur = erreur + xdist
                                          
remb5                                     ; end if 
      movf x2,W
      xorwf x,W
      btfss STATUS,Z 
      goto remb4                           ; next x

      return


la macro pset ne sera pas pris en compte, car ici il y a pas d'écran, aumusse toi bien il ya beaucoup de nombre négatif :-D

Si savait fait cette fonction pour seulement les Pic18Fxxxx j'aurais gagné du temps, car les Pic18Fxxxx possède un bit d'indication d'un résultat négatif. (voir registre STATUS)

==> A+
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

Algorithme de Bresenham
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 2595
Enregistré en : juillet 2016
Localisation : Terre

#5 Message par Temps-x » mar. 25 oct. 2022 02:53

Bonsoir tout le forum,

Voici une version en ASM de l'algorithme de Bresenham sur le cercle, voir post #1 en bas de page.

Il y a encore pas mal de problème à régler sur le cercle en version ASM, car des pixels apparait là ou il ne faut pas.

Dans un programme écrit sur ordinateur ça fonctionne parfaitement, pour preuve... voici en image le résultat ci-dessous (ce programme sera disponible bientôt)

Algorithme de Bresenham sur le cercle.jpg


:roll: Si quelqu'un veut m'aider à améliorer cette version je suis preneur, car je patauge :-D

A+
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

Algorithme de Bresenham
francois77
Passioné
Passioné
Messages : 307
Enregistré en : avril 2022

#6 Message par francois77 » mar. 25 oct. 2022 06:31

Bonjour Temps-x

Avec le programme il faudrait fournir un prescription pour de l'aspirine :sifflotte:

La simple lecture de l'explication de l'algorithme de Bresenham n'est pas simple a digérer au lever matinal

j'ai récupérer un platine picdem+ , je vais essayer de trouver le temps de la câbler avec un Pic18F26K22 la semaine prochaine.

Mon cerveau étant câblé en 286 , il va falloir me donner du temps pour ingurgiter ton travail

Mais bravo :bravo: :bravo:

A+

Francois

Algorithme de Bresenham
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 2595
Enregistré en : juillet 2016
Localisation : Terre

#7 Message par Temps-x » mer. 26 oct. 2022 02:40

Bonsoir francois77, et tout le forum,

:roll: j'ai trouvé des erreurs dans le code... la cause... :mad: les nombres négatif, une vraie poisse ces négations, je suis entrain de les corriger.

:sifflotte: Mais ce n'est pas tout !! car je pense qu'il y a des erreurs dans l'affichage des pixels, c'est un peu compliqué a évoquer, donc je m'attarderais pas à expliquer ce détail.

Avec la macro il sera facile de faire un cercle plein, ou à moitié rempli.

francois77 a écrit :Source du message j'ai récupérer un platine picdem+ , je vais essayer de trouver le temps de la câbler avec un Pic18F26K22 la semaine prochaine.


:-D Avec l'hiver qui arrive, tu auras de quoi t'amuser, de plus tu ne seras plus limité par la taille.

==> A+
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

Algorithme de Bresenham
satinas
Expert
Expert
Messages : 1225
Enregistré en : novembre 2015

#8 Message par satinas » jeu. 27 oct. 2022 11:51

Bonjour à tous

Temps-x, j'ai regardé ton code concernant l'écriture d'une ligne, en version PC et en version asm.
Dans la version asm lorsque tu testes si la variable erreur est négative, tu le fais en regardant la carry juste après la soustraction erreur-xdist. Cette carry indique la retenue éventuelle après soustraction. Pour avoir le signe de erreur, il faut tester son bit 7, il est à 1 si la variable est négative.

Pour l'algo sur le cercle, peux-tu mettre un extrait de ton code sur PC, merci. C'est plus facile de regarder ton code asm en ayant une version qui marche comme référence.

Algorithme de Bresenham
francois77
Passioné
Passioné
Messages : 307
Enregistré en : avril 2022

#9 Message par francois77 » jeu. 27 oct. 2022 12:41

Bonjour,

Equation logique et résolution de problème

Temps-x + Satinas = Code Fonctionnel

A+

Francois

Algorithme de Bresenham
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 2595
Enregistré en : juillet 2016
Localisation : Terre

#10 Message par Temps-x » ven. 28 oct. 2022 03:20

Bonsoir satinas, francois77, et tout le forum,

francois77 a écrit :Source du message Temps-x + Satinas = Code Fonctionnel

:lol:

satinas a écrit :Source du message Temps-x, j'ai regardé ton code concernant l'écriture d'une ligne, en version PC et en version asm.

Sur la fonction ligne je n'ai pas de problème, elle fonctionne correctement, mais je vais regarder ce que tu ma dit, normalement je l'ai testé avec Mplab 8.92 ou je n'ai pas trouvé d'erreur.... mais bon... ça à pu m'échapper donc je vais contrôler

Concernant le cercle, ben, :sifflotte: j'ai pas mal d'erreur que je vais devoir corriger, le problème c'est la variable "diametre"
il faut quelle soit parfois (négatif 16 bits minimum) et parfois (positif 16 bits minimum)

je te mets la source du programme avec le fichier code + compilé en QuickBasic( :sifflotte: sous dos), sinon j'ai fait une version en Qrapid, mais elle par sur une autre façon de faire, toujours avec l'algorithme de Bresenham sur le cercle

Version QuickBasic : BreCicle.zip

==> A+
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:


Retourner vers « Langage ASM »

Qui est en ligne

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