C USARTD0 als SPI?

[Mikro23]

Da es zeilenweise nicht untereinander bleibt, schreibe ich es mal in zwei Spalten
Alles Hexadezimal, XX = Dummy bei in, ignore bei out
in - out
5A - XX
00 - XX
00 - XX
00 - XX
XX - XX
XX - 53
XX - 46
XX - 44
XX - 50

 

[LotadaC]

Da es zeilenweise nicht untereinander bleibt, schreibe ich es mal in zwei Spalten
Alles Hexadezimal, XX = Dummy bei in, ignore bei out

0x5A - 0x00 - 0x00 - 0x00 - 0xXX - 0xXX - 0xXX - 0xXX - 0xXX
0xXX - 0xXX - 0xXX - 0xXX - 0xXX - 0x53 - 0x46 - 0x44 - 0x50

??

Edit @Dirk : sowas wie diese Bit/Byte-Pegel-Verlaufs-Diagramm-Dinger (hoffe, Du verstehst was ich meine) kann man nicht irgendwie in den Foreneditor "reinwurschteln", oder?
Andererseits hat Jan den entsprechenden Screenshoot selbst ein paar Beiträge vorher eingebunden...

 

[Mikro23]

??

Irgendwo hatte ich das mit Code auch schon mal gesehen, blos wo?

Hier geht doch nur ASM, BAS, C...

 

[Dirk]

Irgendwo hatte ich das mit Code auch schon mal gesehen, blos wo?

Klick mal auf das Plus und dann wähle </>Code. Das ist vom System.
Die anderen <> ASM BAS C PAS sind von uns eingefügt.

 

[Mikro23]

Klick mal auf das Plus

Ah, da ist es, danke.
Wenn man etwas nicht öfter braucht...

 

[Janiiix3]

Wo finde ich jetzt im Datenblatt die Speicheradressen? Ich würde gerne mal eine "TestPage" schreiben wollen..


CodeBox C

void df_page_programm(df_t *DataFlash, spi_usart_t *FlashSPI, [I]uint32_t[/I] addr){

Spi_USARTD0_Slave_Select_Low(FlashSPI);
Spi_USARTD0_Rx_Tx(0x02);
Spi_USARTD0_Rx_Tx((addr&0x00FF0000)>>16 );
Spi_USARTD0_Rx_Tx((addr&0x0000FF00)>>8 );
Spi_USARTD0_Rx_Tx((addr&0x000000FF) );

[I]uint8_t[/I] byte=0;
while (DataFlash->TxBuffer[byte]!='\0')
{
Spi_USARTD0_Rx_Tx(((DataFlash->TxBuffer[byte++])));
}

Spi_USARTD0_Slave_Select_High(FlashSPI);
df_wait_is_busy(DataFlash,FlashSPI); 

}

 

[Mikro23]

Bei 2 MByte gesamt- und 256 Bytes page-Größe hat der Flash 8192 pages.
Für 256 Bytes werden 8 Adressbits gebraucht.
Daher setzt sich die Adresse aus

(pagenummer << 8) | bytenummer

zusammen.
Da Du nur ganze pages schreiben und löschen kannst, setzt Du die Bytenummer = 0.
Jetzt mußt Du nur noch eine der 8192 pages auswählen und kannst die Adresse berechnen.

 

[Janiiix3]

Wenn mich nicht alles täuscht müssten das 4MByte sein. Es ist ein 16MBit Speicher.

Das mit der Adresse berechnen habe ich noch nicht ganz so verstanden..

Habe gelesen, dass der Speicherbereich bei 0x00000000 los geht... Möchte ich jetzt eine Page schreiben, heißt das ich bin nach der Page bei welcher Adresse? 255?

 

[Mikro23]

16 durch 8 (bit) sind bei mir immer noch 2

Die erste Seite (page 0) beginnt bei 0x000000
Das letzte Byte der ersten Seite liegt bei 0x0000FF
Die zweite Seite (page 1) beginnt bei 0x000100

 

[Janiiix3]

Das heißt ich kann bei 0x00.. 255 Bytes schreiben. Dann bin ich bei 0x0..1 habe ich das richtig verstanden?

Habe schon versucht an Adresse 0 zu schreiben.. Konnte leider kein Ergebnis erzielen.

 

[LotadaC]

4MByte sein. Es ist ein 16MBit Speicher.

???
4MByte (Du meinst sicher 4Mebibyte) sind 4*1024*1024*8 Bit

 

[Janiiix3]

Hiermit versuche ich Bytes zu schreiben..


CodeBox C

void df_write_page(df_t *DataFlash, spi_usart_t *FlashSPI, uint32_t addr, uint8_t leng){
  
   df_wait_is_busy(DataFlash,FlashSPI);      
  
   Spi_USARTD0_Slave_Select_Low(FlashSPI);
  
   Spi_USARTD0_Rx_Tx(0x02);
   Spi_USARTD0_Rx_Tx((addr&0x00FF0000)>>16);
   Spi_USARTD0_Rx_Tx((addr&0x0000FF00)>>8 );
   Spi_USARTD0_Rx_Tx((addr&0x000000FF)    );
  
  
   uint8_t byte=0;
   while (byte++<leng && (DataFlash->TxBuffer[byte] != '\0'))
   {
       df_wait_is_busy(DataFlash,FlashSPI);
       Spi_USARTD0_Rx_Tx(((DataFlash->TxBuffer[byte])));          
   }
          
   Spi_USARTD0_Slave_Select_High(FlashSPI);
}

CodeBox C

int main(void)
{
   PORTR.DIR       =   1<<0; // state led
   PORTR.OUTSET   =   1<<0;

   Spi_Master_USARTD0_Init(FlashSPI,65535,0,0);
   
   uint8_t x=0;
   while(x++<sizeof(DataFlash->TxBuffer))
   {
       DataFlash->TxBuffer[x]=5;
   }

   df_write_start(DataFlash,FlashSPI);
   df_write_page(DataFlash,FlashSPI,0x00000000,sizeof(DataFlash->TxBuffer));
   df_write_stop(DataFlash,FlashSPI);
   
    while (1)
    {
       df_read(DataFlash,FlashSPI,0x00000000,sizeof(DataFlash->RxBuffer));
       if (DataFlash->RxBuffer[9]==5)
       {
           PORTR.OUTCLR=1<<0;
       }else{
           PORTR.OUTSET=1<<0;
       }
    }
}

 

[Mikro23]

Das heißt ich kann bei 0x00.. 255 Bytes schreiben.

Eine Seite hat 256 Bytes.
Wenn Du bei 0 anfängst und 256 Bytes schreibst (mehr geht nicht auf einmal), dann bist Du bei 0x000100.
Interessiert aber nicht, weil wenn Du die nächste Seite schreiben willst, mußt Du vorab erneut die Adresse schicken, an der Du schreiben willst, wie auch bei der ersten Seite schon....

 

[Mikro23]

Setzt Du das WREN bit bevor Du write_page aufrufst?
Wenn nicht, wäre es empfehlenswert, das Datenblatt noch mal etwas genauer zu studieren.


CodeBox C

while (byte++<leng && (DataFlash->TxBuffer[byte] != '\0'))   { // *1
  df_wait_is_busy(DataFlash,FlashSPI);                         // *2
  Spi_USARTD0_Rx_Tx(((DataFlash->TxBuffer[byte])));
} 

*1: Willst Du nur ASCII (nullterminiert) in den Flash schreiben? Bei allen anderen Daten, die Null als Wert enthalten können geht das in die Hose.
*2: Um den pagebuffer (256 Bytes) zu füllen, braucht Du kein busy abzufragen. Das brauchst Du erst, um festzustellen, ob der Schreibvorgang beendet ist (nach initiieren des Schreibvorgangs durch setzten der CS-Leitung auf eins).

 

[Janiiix3]

Okay.

Hiermit versuche ich eine Page zu lesen..


CodeBox C

void df_read(df_t *DataFlash, spi_usart_t *FlashSPI, uint32_t addr, uint8_t leng){
  
   df_wait_is_busy(DataFlash,FlashSPI);
          
   Spi_USARTD0_Slave_Select_Low(FlashSPI);
  
   Spi_USARTD0_Rx_Tx(0x03);
   Spi_USARTD0_Rx_Tx((addr&0x00FF0000)>>16);
   Spi_USARTD0_Rx_Tx((addr&0x0000FF00)>>8 );
   Spi_USARTD0_Rx_Tx((addr&0x000000FF)    );

   Spi_USARTD0_Rx_Tx(((DataFlash->RxBuffer[0])));

   Spi_USARTD0_Slave_Select_High(FlashSPI);
}

Egal was ich versuche, es wird nichts gespeichert oder geschrieben..

 

[Mikro23]

Ja das Bit setze ich.

Liest Du anschließend den Status um zu überprüfen, ob das Bit gesetzt ist?
Und wiederholst Du das so lange, bis es gesetzt ist?

 

[Janiiix3]

Liest Du anschließend den Status um zu überprüfen, ob das Bit gesetzt ist?
Und wiederholst Du das so lange, bis es gesetzt ist?

Nein das mache ich nicht. Meinst du das könnte ein Problem sein?

 

[Mikro23]

Meinst du das könnte ein Problem sein?

Vor jedem Schreib- und Löschvorgang frage ich das WEL Bit ab, weil wenn es nicht gesetzt ist, kann weder geschrieben, noch gelöscht werden. (Grade noch mal nachgesehen: WREN heißt der Befehl um das Bit zu setzen)

 

[Janiiix3]

Und meine Routine für das lesen und schreiben (bis auf die while()) sieht soweit okay aus?

 

[Mikro23]

Und meine Routine für das lesen und schreiben (bis auf die while()) sieht soweit okay aus?

Wenn die aufgerufenen Funktionen das tun was ich annehme ja.
Es sieht so aus, als hättest Du da einiges übernommen, was ja nichts verwerfliches ist, wenn man weiß, was man tut... (Du kennst die Definition von df_t und spi_usart_t auswendig? )
Auch wenn's länger gedauert hat und vielleicht nicht ganz so elegant aussieht, habe ich mir die Funktionen (die ich brauchte) alle von grund auf selbst geschrieben.