comment remplir une memoire flash spi en25qh16 avec un fichier venant du pc ?

[buldo]

Bonjour, j'ai bien une petite idée : en utilisant la liaison série. Mais le problème c'est comment recevoir octet par octet ce fichier ?
du coté picaxe 28x2, un programme de ce style pour une mémoire flash en25qh16 (http://www.alldatasheet.com/datasheet-pdf/pdf/458188/EON/EN25QH16.html), le fichier est envoyé avec hyperterminal.
Bien sûre rien ne se passe... Connaissez-vous un petit soft coté pc qui enverrait octet par octet le fichier ?? Je pense que mon problème vient de là ! ou un bug dans mon code du 28x2 ?
Merci d'avance pour votre aide.

; cablage
; 1 = CS     = PICAXE B.7
; 2 = SO     = PICAXE C.4
; 3 = WP     = +3.3V
; 4 = Vss    = 0V
; 5 = SI    = PICAXE C.5
; 6 = SCK    = PICAXE C.3
; 7 = HOLD     = +3.3V
; 8 = Vdd      = +3.3V
; 

symbol cs = b.7    ' chip select  PICAXE b.7

; Commands
symbol WRSR = 1        ; write status register
symbol PP   = 2        ; page programming
symbol RD   = 3        ; read
symbol WRDI = 4        ; write disable
symbol RDSR = 5        ; read status register
symbol WREN = 6        ; write enable
symbol RSTEN = $66    ; reset enable
symbol RST = $99        ; reset
symbol CE = $c7        ; chip erase
; Variables
symbol add_0     = b0    
symbol add_1    = b1    ; 
symbol add_2    = b2
symbol test_data1 = b3    ;  test data 1
Symbol lec_data1 = b7    ; lecture data 1
symbol SR_Value1  = b11    ; lecture état du registre 1
symbol SR_Value2  = b12    ; lecture état du registre 2


init:
    high cs
    pause 50
    add_0 = 0 ; adresse de début
    add_1 = 0
    add_2 = 0

    ;**********   setup spi mode - mode 0,0 **********
    hspisetup spimode00,spislow
    pause 50    
    
    ;*************  reset memoire *****************
    low cs
    hspiout (RSTEN)
    high cs
    pause 50    ;tCHSH
    
    low cs
    hspiout (RST)
    high cs
    pause 50
 ;   *******************************************
        ; ********* permettre l'écriture en désactivant la protection
; write enable
    low cs
    hspiout (WREN)
    high cs
    
    ; write status register à 0 pour enlever block protect
    low cs
    hspiout (WRSR,0)
    high cs
    pause 5    ; wait write time
    ;**********************************************
   
    
;    gosub efface ; efface complètement la mémoire

    
main:
    
    serin [1000], c.7 ,N4800,(test_data1) ; <===================== récupère un caractère du port série
    
    ; write enable
    low cs
    hspiout (WREN)
    high cs

    ;write
    low cs
    hspiout (PP,add_2,add_1,add_0,test_data1) <= programme à l'adresse $add_2add_1add_0 l'octet test_data1
    high cs
    pause 5     ; le temps d'écrire
    

    
    ;read
    low cs
    hspiout (RD,add_2,add_1,add_0)
    hspiin (lec_data1)
    high cs
    pause 5 ; le temps de lire
    
    

    ; affich lecture données
    debug
 ;   serout c.6,N4800,(lec_data1," ") ; <============== renvoie le caractère programmé sur le port série
;    pause 1000
            
    ; **********************   increment pointeur d'adresse jusqu'à $1fffff *****************************
    if add_0 = $ff then bcl
    add_0 = add_0 + 1
    
    goto finbcl
bcl: 
    add_0 = 0
    if add_1 = $ff then bcl2
    inc add_1
    
    goto finbcl
bcl2:
    add_1 = 0
    if add_2 = $1f then bcl3
    inc add_2
    
 *******************************************************************   
        
finbcl:    
    goto main

bcl3:
    high b.4  ; allume la del si fin du travaille
    pause 10000
    
    end
    
    
;    **************** efface mémire *********************
efface:    
    low cs
    hspiout (WREN)
    high cs
    
    low cs
    hspiout (CE)
    high cs
    
st2:    
    ;lecture  si wip (bit0) = 0 fin de l'effacement
    low cs
    hspiout (RDSR)
    hspiin (SR_Value2)
    high cs
    SR_Value2 = %00000001 and SR_Value2
    if SR_Value2 = 0 then st1
    goto st2
st1:
    high b.4
    pause 1000
    low b.4
    return
;*********************************************************

 

[BESQUEUT]

Bien sûr rien ne se passe...

A mon humble avis, il faut déjà résoudre ce problème avant de songer à changer d'outil...
Vu votre programme, au bout d'une seconde, il se passe quelque chose, que vous ayez reçu un caractère ou pas.
Vu tout ce qui se passe et notamment le "debug", le programme a largement le temps de rater des tas de caractères avant de retourner au label "main".
Voilà ce que je suggère :
- utiliser le paramètre optionnel "address" pour faire quelque chose de différent en cas de time-out, par exemple un flash sur une led, ce qui est beaucoup moins prenant qu'un "debug" pour le Picaxe,
- envoyer un a un des caractères avec Hyperterminal (tapez lentement (1 par seconde) a b c d e f ...)
- même si le Picaxe en rate, au moins certains caractères doivent être pris en compte,
- si ça ne marche toujours pas, vérifiez votre connectique et publiez votre schéma, voire une photo du montage,
- si ça marche : vous pouvez commencer à réfléchir...
1) le hardware fonctionne,
2) mais le Picaxe étant totalement incapable de faire deux choses à la fois, il faut établir un protocole rigoureux de façon à n'envoyer un caractère que quand le Picaxe est à l'écoute.
Une solution simple est de supprimer le timeout : dans ce cas, le Picaxe va rester bloqué en attente d'un caractère.
Si vous supprimer le debug, il mettra quelques fractions de secondes pour le traiter et revenir au label "main".
Si vous envoyez les caractères au goutte à goutte, ça devrait marcher.
Si vous devez envoyer un fichier, un petit programme VB fera l'affaire, mais le débit sera faible.
Pour faire un peu mieux, il faut établir un protocole genre XON/XOFF
Hyperterminal sait en principe gérer ce protocole, mais là encore un programme VB offre bien plus de facilités de débogage.

PS) Je vois arriver la solution "Background receive" qui est en théorie la solution miraculeuse pour recevoir des caractères à la volée pendant que le Picaxe fait autre chose. En pratique, il y a tellement de limitations que ça ne peut servir à rien d'autre qu'à une (mauvaise) démo. Je n'ai trouvé aucun programme qui fasse autre chose qu'une boucle sur une pause, ce qui il faut le reconnaître n'est pas hyper utile. Mais restons positif : il reste possible que le hspiout soit compatible avec le backgroud receive et dans ce cas, vous devriez envisager cette solution.

 

[buldo]

Merci pour les éclaircissements.
Si j'enlève le timeout rien ne s'affiche sur le terminal, le temps de connexion se bloque quelques secondes et repart .
si je remplace :

serin [1000], c.7 ,N4800,(test_data1) par test_data1 = $55 le U s'affiche correctement sur le terminal ce qui prouve que l'écriture en mémoire se passe correctement et que la communication picaxe > PC est correcte.
pour la la solution "Background receive" je vais chercher à quoi cela correspond ...

 

[BESQUEUT]

Vous pouvez laisser les deux (dans cet ordre) :
test_data1 = "U"
serin [1000], c.7 ,N4800,(test_data1)

En toute logique, si rien n'est reçu au bout d'une seconde un "U" doit s'afficher.
Evidemment, pour les essais, tapez une autre lettre...
Vérifier quand même le câblage dans le sens PC=> Picaxe, mais effectivement, si ça marche dans un sens, c'est plutôt bon signe.
Vous pouvez aussi faire un loopback coté Picaxe.

Le serout est en commentaire dans votre programme et il est précédé par un debug.
Quelle est votre connectique ?
Si vous utilisez le cordon de programmation uniquement, il faut utiliser les commandes sertxd et serrxd.

Pour le Background receive, c'est prématuré ; ça ne peut servir qu'à améliorer les performances, qui sont nulles actuellement. Trois fois rien, ça reste pas grand chose.

 

[buldo]

serin [1000], c.7 ,N4800,(test_data1) ; <===================== récupère un caractère du port série

à remplacer par
serin [1000], c.7 ,N4800,test_data1 ; <=====

il me reste plus qu'a trouver le logiciel qui va bien pour envoyer octet par octet coté pc

retour dans une semaine ...