Pic16f877A : Incompatibilité I2C / Timer / Ecran

Pic16f877A : Incompatibilité I2C / Timer / Ecran - ASM - Programmation

Marsh Posté le 07-10-2009 à 17:50:53    

Bonjour,
 
J'ai essayé d'être le plus clair possible, je suis désolé si je m'exprime mal.
 
Je travaille actuellement sur un projet : à l'aide d'un capteur (Dallas 1621) je dois récuperer une température et l'afficher sur un écran 128*64 à raison d'une capture / 30 secondes.
 
La communication entre le pic et le capteur se fait par de l'I2C en passant par le PORT C (RC3 et 4 pour SCL et SDL).
La communication entre l'écran et le pic se fait sur les PORT B et D (Le port B contrôlant tout ce qui est "commande" et le port D les données).
 
J'arrive à effectuer ses deux actions séparement, malheureusement lorsque je combine l'ensemble soit :  
-la communication I2C marche mais l'écran n'affiche rien
-l'écran me colle une valeur fixe ne correspondant pas à la température et il n'y à aucune communication en I2C.
 
 
Mon code sur l'I2C (les fonctions proviennent du cours de Bigonoff)
 

Code :
  1. org 0x00
  2. goto debut
  5. org 0x04
  6. debut
  7. bsf STATUS,RP0    ; passer en banque 1
  8. bsf TRISC,3    ; SCL en entrée (mis par défaut sur un reset)
  9. bsf TRISC,4    ; SDA en entrée (idem)
  10. movlw 0x80     ; slew rate control en service, mode I²C  ======================100kHZ SLEW RATE CONTROL à 1=======================
  11. movwf SSPSTAT    ; dans SSPSTAT
  12. movlw 0x09     ; valeur de recharge du BRG =====================================4MHz / (100KHz * 4) - 1=============================
  13. movwf SSPADD    ; dans registre de recharge
  14. bcf STATUS,RP0    ; repasser banque 0
  15. movlw 0x38     ; module MSSP en service en mode I²C master
  16. movwf SSPCON    ; dans registre de contrôle
  18. call I2C_start1   ; Start
  19. call I2C_start1   ; Start
  20. call I2C_adress
  21. call I2C_check
  22. call I2C_send_config ; Début de config
  23. call I2C_check   ; Réponse
  24. call I2C_send_conf  ; Suite config
  25. call I2C_check   ; Réponse
  26. call I2C_stop2
  27. call I2C_start1   ; Start
  28. call I2C_start1   ; Start
  29. call I2C_adress   ; Appel
  30. call I2C_check   ; Réponse
  31. call I2C_send_start  ; Début de conversion de la température EE
  32. call I2C_check   ; Réponse
  33. call I2C_stop2   ; Fin
  34. ici
  35. call I2C_start1   ; Start
  36. call I2C_start1   ; Start
  37. call I2C_adress   ; Appel du capteur
  38. call I2C_check   ; Réponse du capteur
  39. call I2C_send_read  ; Lecture de la température
  40. call I2C_check   ; Réponse du capteur
  41. call I2C_repeatstart  ; ReStart
  42. call I2C_adress2  ; Appel
  43. call I2C_check   ; Réponse
  44. call I2C_reade   ; Réception des données du capteur
  45. movf SSPBUF, w   ; Stockage des degres
  46. movlw buffer1
  47. call I2C_ACK_MASTER               ; Autorise l'esclave à poursuivre
  48. call I2C_reade
  49. movf SSPBUF, w                             ;Stockage des demidegres
  50. movlw buffer2
  51. call I2C_NOACK   ; Fin de réception
  52. call I2C_stop2   ; Stop
  53. goto ici
  56. I2C_idle      ; Sous routine contrôlant la présence d'une action en cours
  57. BANKSEL SSPSTAT   ; passer en banque 1
  58. I2C_idle2
  59. btfsc SSPSTAT,R_W   ; tester si émission en cours
  60. goto I2C_idle2    ; oui, attendre
  61. I2C_idle3
  62. movf SSPCON2,w    ; charger registre SSPCON2
  63. andlw 0x1F     ; conserver ACKEN,RCEN,PEN,RSEN,et SEN
  64. btfss STATUS,Z    ; tester si tous à 0 (aucune opération en cours)
  65. goto I2C_idle3    ; non, attendre
  66. bcf STATUS,RP0    ; repasser en banque 0
  67. return      ; rien en cours, on peut sortir
  71. I2C_start1     ; Sous routine lançant le bit Start
  72. ;call I2C_idle    ; attendre fin de l’opération précédente(voir plus haut)
  73. bsf STATUS,RP0    ; passer en banque 1
  74. bsf SSPCON2,SEN   ; lancer start-condition
  75. bcf STATUS,RP0    ; repasser en banque 0
  76. return      ; retour
  79. I2C_adress     ; Mode écriture
  80. call I2C_idle    ; attendre fin de l’opération précédente
  81. movlw 0x90     ; charger adresse esclave (b7 à b1) avec b0 = 0
  82. movwf SSPBUF    ; lancer l’émission de l’adresse en mode écriture
  83. return      ; et retour
  85. I2C_stop2     ; Stop
  86. bsf STATUS,RP0    ; passer en banque 1
  87. bsf SSPCON2,PEN   ; lancer le stop-condition
  88. I2C_start2
  89. ;clrwdt      ; effacer watchdog
  90. btfsc SSPCON2,PEN   ; stop-condition terminé ?
  91. goto I2C_start2   ; non, attendre
  92. bcf STATUS,RP0    ; oui, repasser en banque 0
  93. return
  95. I2C_send_start     ; Autoriser la conversion de température
  96. call I2C_idle    ; attendre fin de l’opération précédente
  97. movlw 0xEE     ; charger octet à envoyer
  98. movwf SSPBUF    ; lancer l’écriture de l’octet
  99. return      ; et retour
  101. I2C_check     ; Surveillance du ACK provenant de l'esclave
  102. call I2C_idle    ; attendre fin de l’opération précédente
  103. bsf STATUS,RP0    ; passer en banque 1
  104. btfsc SSPCON2,ACKSTAT  ; tester ACK reçu
  105. goto errore    ; pas reçu, traiter erreur
  106. bcf STATUS,RP0
  107. return
  108. errore
  109. bcf STATUS,RP0
  110. call I2C_stop2
  111. return
  114. I2C_send_01     ; Autoriser la conversion de température
  115. call I2C_idle    ; attendre fin de l’opération précédente
  116. movlw 0x01    ; charger octet à envoyer
  117. movwf SSPBUF    ; lancer l’écriture de l’octet
  118. return      ; et retour
  121. I2C_send_config    ; Lecture de la conversion
  122. call I2C_idle    ; attendre fin de l’opération précédente
  123. movlw 0xAC     ; charger octet à envoyer
  124. movwf SSPBUF    ; lancer l’écriture de l’octet
  125. return      ; et retour
  127. I2C_send_conf    ; Lecture de la conversion
  128. call I2C_idle    ; attendre fin de l’opération précédente
  129. movlw 0x00    ; charger octet à envoyer
  130. movwf SSPBUF    ; lancer l’écriture de l’octet
  131. return      ; et retour
  133. I2C_repeatstart    ; Repeated Start
  134. call I2C_idle    ; attendre fin de l’opération précédente
  135. bsf STATUS,RP0    ; passer en banque 1
  136. bsf SSPCON2,RSEN   ; lancer le repeated start-condition
  137. bcf STATUS,RP0    ; repasser en banque 0
  138. return      ; retour
  144. I2C_reade     ; Reception des données par le maître
  145. call I2C_idle    ; attendre fin de l’opération précédente
  146. bsf STATUS,RP0    ; passer banque 1
  147. bsf SSPCON2,RCEN  ; lancer la réception
  148. bcf STATUS,RP0    ; repasser banque 0
  149. return      ; et retour
  153. I2C_NOACK      ; Lancer l'ack provenant du maitre cloturant une reception
  154. call I2C_idle    ; attendre fin de l’opération précédente
  155. bsf STATUS,RP0    ; passer banque 1
  156. bsf SSPCON2,ACKDT   ; le bit qui sera envoyé vaudra « 1 »
  157. bsf SSPCON2,ACKEN   ; lancer l’acknowledge (= ACKDT = 1 = N0ACK)
  158. bcf STATUS,RP0    ; repasser banque 0
  159. return      ; et retour
  163. I2C_ACK_MASTER    ; Lancer l'ack provenant du maitre
  164. call I2C_idle    ; attendre fin de l’opération précédente
  165. bsf STATUS,RP0    ; passer banque 1
  166. bcf SSPCON2,ACKDT   ; le bit qui sera envoyé vaudra « 1 »
  167. bsf SSPCON2,ACKEN   ; lancer l’acknowledge
  168. bcf STATUS,RP0    ; repasser banque 0
  169. return      ; et retour
  171. I2C_send_read    ; Lecture de la conversion
  172. call I2C_idle    ; attendre fin de l’opération précédente
  173. movlw 0xAA     ; charger octet à envoyer
  174. movwf SSPBUF    ; lancer l’écriture de l’octet
  175. return      ; et retour
  177. I2C_adress2     ; Mode lecture
  178. call I2C_idle    ; attendre fin de l’opération précédente
  179. movlw 0x91     ; charger adresse esclave (b7 à b1) avec b0 = 1
  180. movwf SSPBUF    ; lancer l’émission de l’adresse en mode lecture
  181. return      ; et retour
  182.          
  183.             end


 
Bizarrement pour qu'il y ait communication avec le capteur, je dois lancer deux fois le bit de start.
 
Et celui pour l'écran
 

Code :
  1. #include <p16f877A.inc>
  3. compteur  EQU 0x20  ; Variable parametrant le nombre de répétition du TIMER1 pour arriver à 30 sec
  4. dizaine  EQU 0x21  ; Variable récuperant la valeur de la roue des dizaines
  5. unite   EQU 0x22  ; celle de la roue des unités
  6. cpt   EQU 0x23  ; Second compteur représentant la durée entre chaque capture
  7. save   EQU 0x24  ; Sauvegarde la valeur du compteur
  8. degres   EQU 0x25  ; Récupère la valeur en degrés venant du capteur
  9. demidegres  EQU 0x26  ; Récupère la présence ou non d'un demi-degrés
  10. echec   EQU 0x27  ; Identifie l'opération où le ACK n'a pas été reçu
  11. repere   EQU 0x28  ; Repère se situant en haut de l'écran
  12. X    EQU 0x29  ; plage d'adresse en hauteur (0 à 7)
  13. Y    EQU 0x2A  ; plage d'adresse en longueur (0 à 63)
  14. pixel   EQU 0x2B  ; permet l'inscription d'un pixel sur l'ecran
  15. CS1   EQU 0x2C  ; 1 = CS1 / 0 = CS2
  16. efface  EQU 0x2D
  19.              org 0x00
  20. goto debut
  23. org 0x04
  24. bcf PIR1, TMR1IF   ; Remet le flag d'overflow à 0
  25. decfsz compteur, f   ; Décrémente le compteur
  26. retfie     ; Retour d'interruption
  27. movlw 0x39    ; Nombre de passage à effectuer pour être le plus...
  28. movwf compteur    ; ...proche de 30 secondes / On relance le timer sur 30 secondes...
  29.              movlw 0x10
  30.              movwf degres
  31.              movlw 0x00
  32.              movwf demidegres
  33.              call ecran
  34. retfie
  36. debut
  38. init_lcd
  39. bsf STATUS, RP0   ; passer en banque 1
  40. clrf TRISD    ; PORTD en sortie
  41. clrf TRISB    ; PORTB en sortie
  42. bcf STATUS, RP0   ; passer en banque 0
  43. movlw 0x3F
  44. movwf PORTD    ; ON
  45. movlw 0x32    ; CS2  1ère partie de l'écran
  46. movwf PORTB
  47. bcf PORTB, 4                                  ; Chute de l'enable, envoie des données
  48. call start_line_CS2                           ; Position de la ligne de départ
  49. call blanc                                       ;Nettoyage de l'écran
  50. movlw 0x3F
  51. movwf PORTD    ; ON
  52. movlw 0x31    ; CS1 2nde partie de l'écran
  53. movwf PORTB
  54. bcf PORTB, 4
  55. movlw 0x01
  56. movwf CS1
  57. call start_line_CS1
  58. call blanc
  59. movlw 0x00
  60. movwf CS1
  61. movlw 0x0A
  62. movwf degres
  63. movlw 0x00
  64. movwf Y
  65. call setadress   ; On selectionne l'adresse
  67. debut2
  68. bsf T1CON, T1CKPS1  ; Prédiviseur...
  69. bsf T1CON, T1CKPS0  ; ...à 8
  70. bcf T1CON, TMR1CS  ; Position sur le timer 1
  71. bsf STATUS,RP0    ; passer en banque 1
  72. bsf PIE1,TMR1IE   ; autoriser interruptions timer 1
  73. bcf STATUS,RP0    ; repasser banque 0
  74. bsf INTCON,PEIE   ; interruptions périphériques en service
  75. bsf INTCON,GIE    ; interruptions en service
  76. clrf TMR1L     ; effacer timer 1, 8 lsb
  77. clrf TMR1H     ; effacer timer 1, 8 msb
  78. movlw 0x39    ; Nombre de passage à effectuer pour être le plus
  79. movwf compteur    ; proche de 30 secondes
  80. timer
  81. bsf T1CON,TMR1ON   ; mettre timer 1 en service
  83. ici goto ici
  88. start_line_CS1
  89. movlw 0xC2    ; Line 0
  90. movwf PORTD
  91. movlw 0x31    ; CS1 / Write
  92. movwf PORTB
  93. bcf PORTB, 4
  94. return
  96. start_line_CS2
  97. movlw 0xC2    ; Line 0
  98. movwf PORTD
  99. movlw 0x32    ; CS2 / Write
  100. movwf PORTB
  101. bcf PORTB, 4
  102. return
  105. ecran
  106. movlw 0x3F    ; On place le repère tout en haut de l'ecran (63)
  107. movwf repere
  108. movlw 0xFE   ; On part du premier pixel
  109. movwf pixel
  110. movlw 0x00    ; Partie haute
  111. movwf X
  112. btfsc degres, 7   ; Est-ce que la température est négative?
  113. goto negatif
  114. movlw 0x01
  115. btfsc demidegres, 7  ; Est-ce qu'on à X,5°C?
  116. addwf degres, f   ; On arrondit au degrés supérieur
  117. positif
  118. movlw 0x0A    ; On décale la valeur de 10°C pour passer d'une échelle -10/50
  119. addwf degres, f   ; à 0/60
  120. comparaison
  121. movf repere, w
  122. xorwf degres, w   ; Si la position du repère ne correspond pas à la valeur de la case
  123. btfss STATUS, 2
  124. goto movepixel   ; Alors on passe au pixel suivant
  125. call setpage   ; On selectionne la page
  126. call writepixel   ; Et on inscrit la température
  127. movlw 0x3F
  128. andwf Y, w
  129. btfsc STATUS, 2                             ;Fin d'écran ? Passage sur l'autre écran
  130. call change
  131. return
  133. change
  134. call reglage_CS1
  135. return
  146. negatif
  147. comf degres, f
  148. movlw 0x01
  149. addwf degres, f   ; Complément à deux
  150. btfsc demidegres, 7
  151. addwf degres, f   ; Arrondi
  152. goto positif
  155. movepixel
  156. bsf STATUS, 0   ; Pas de retenue
  157. rlf pixel, f   ; Décalage du pixel
  158. movlw 0xFF
  159. bcf STATUS, 0
  160. xorwf pixel, w   ; Dernière case de la plage X?
  161. btfsc STATUS, 2   ; On vérifie si l'opération a rendu 0
  162. goto addX
  164. moins
  165. decf repere, f    ; On descend d'une case
  166. goto comparaison  ; et on recommence
  168. addX
  169. incf X, f    ; passage à la plage suivante
  170. movlw 0xFE
  171. movwf pixel    ; plaçage en haut de la plage
  172. goto moins
  177. setpage
  178. movlw 0xB8
  179. movwf PORTD
  180. movf X, w
  181. addwf PORTD, f
  182. btfsc CS1, 0
  183. movlw 0x31
  184. btfss CS1, 0
  185. movlw 0x32
  186. movwf PORTB
  187. bcf PORTB, 4
  188. return
  190. setadress
  191. movlw 0x40
  192. movwf PORTD    ;0
  193. movf Y, w
  194. addwf PORTD, f
  195. btfsc CS1, 0
  196. movlw 0x31
  197. btfss CS1, 0
  198. movlw 0x32
  199. movwf PORTB
  200. bcf PORTB, 4
  201. return
  203. writepixel
  204. movf pixel, w
  205. movwf PORTD
  206. btfsc CS1, 0
  207. movlw 0x35
  208. btfss CS1, 0
  209. movlw 0x36
  210. movwf PORTB
  211. bcf PORTB, 4
  212. incf Y, f
  213. call setadress
  214. movlw 0x0A
  215. subwf degres, f
  216. return
  218. reglage_CS1
  219. btfsc CS1, 0
  220. bcf CS1, 0
  221. btfss CS1, 0
  222. bsf CS1, 0
  223. movlw 0x00
  224. movwf Y
  225. call setadress   ; On selectionne l'adresse
  226. return
  228. blanc
  229. movlw 0x09
  230. movwf X
  231. boucle
  232. movlw 0x41
  233. movwf efface
  234. decfsz X, f
  235. goto suite
  236. return
  239. suite
  240. call setpage
  241. call setadress
  242. suite2
  243. decfsz efface, f
  244. goto write
  245. goto boucle
  246. write
  247. movlw 0xFF
  248. movwf pixel
  249. call writepixel
  250. goto suite2
  252. end


 
Je ne sais pas comment combiner les deux codes pour qu'ils fonctionnent.
 
J'ai essayé de placer la séquence de lecture I2C juste après le lancement du timer (en la conservant dans une boucle afin que la capture se fasse constamment). Dès que l'interruption se déclenche normalement mes valeurs de buffer 1 et 2 sont copiés dans degrés et demidegrés et envoyés sur l'écran mais rien n'apparait.
 
Dans un deuxième essai, j'ai placé la séquence de lecture I2C dans le coin des interruptions juste avant l'appel de la fonction ecran. Mais là je n'ai plus de communication avec le capteur et une valeur est inscrite sur l'écran (c'est toujours la même et elle n'est pas cohérente avec la température actuelle).
 
Pour moi, le timer et l'I2C ont l'air de créer un conflit mais je ne sais pas comment contourner le problème.
 
Si vous avez des idées, je suis preneur.
 
Merci de m'avoir lu  :jap:


Message édité par Pingumaru le 07-10-2009 à 17:52:50
Reply

Marsh Posté le 07-10-2009 à 17:50:53   

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed