ATNEL tech-forum 2013-10-12T09:36:46+01:00 https://forum.atnel.pl/feed.php?f=4&t=4437&mode 2013-10-12T09:36:46+01:00 2013-10-12T09:36:46+01:00 https://forum.atnel.pl/viewtopic.php?t=4437&p=52637#p52637 <![CDATA[Re: AT45DB01 - zmieszczenie jak najwęcej]]>
Wysłane z Tapatalk2 [url='http://tapatalk.com/m?id=10']now Free[/url]

Statystyki: Napisane przez majster — 12 paź 2013, o 09:36

]]> 2013-10-12T09:35:09+01:00 2013-10-12T09:35:09+01:00 https://forum.atnel.pl/viewtopic.php?t=4437&p=52636#p52636 <![CDATA[Re: AT45DB01 - zmieszczenie jak najwęcej]]>
Wysłane z Tapatalk2 [url='http://tapatalk.com/m?id=10']now Free[/url]

Statystyki: Napisane przez majster — 12 paź 2013, o 09:35

]]> 2013-10-12T09:17:25+01:00 2013-10-12T09:17:25+01:00 https://forum.atnel.pl/viewtopic.php?t=4437&p=52633#p52633 <![CDATA[Re: AT45DB01 - zmieszczenie jak najwęcej]]> [syntax=c]#include "LCD/lcd.h"[/syntax]
Nie wiem, gdzieś widziałem jak mirek dawał coś takiego w bibliotekach
[syntax=c]#include "../LCD/lcd.h"[/syntax]
ale mi to nie działało.

Statystyki: Napisane przez Paul Dirac — 12 paź 2013, o 09:17

]]> 2013-10-12T06:08:58+01:00 2013-10-12T06:08:58+01:00 https://forum.atnel.pl/viewtopic.php?t=4437&p=52628#p52628 <![CDATA[Re: AT45DB01 - zmieszczenie jak najwęcej]]>
Code:
#include "C:/PSM/flash_tefelski/LCD/lcd.h"


troche to nie eleganckie

Statystyki: Napisane przez DominikN — 12 paź 2013, o 06:08

]]> 2013-10-11T17:55:25+01:00 2013-10-11T17:44:21+01:00 https://forum.atnel.pl/viewtopic.php?t=4437&p=52584#p52584 <![CDATA[Re: AT45DB01 - zmieszczenie jak najwęcej]]> [syntax=c]printf("%d %d", *buf_read, sizeof(buffor));[/syntax]

Jednak miałeś racje źle było w printf, brak '*'. Thx za pomoc, mam teraz wartosc binarna znaku ASCII, który jest moja liczbą z zakresu <0,255>, a przez uarta to juz działam z binarka, więc bedzie gites.

Statystyki: Napisane przez Paul Dirac — 11 paź 2013, o 17:44

]]> 2013-10-11T17:45:25+01:00 2013-10-11T17:41:43+01:00 https://forum.atnel.pl/viewtopic.php?t=4437&p=52583#p52583 <![CDATA[Re: AT45DB01]]>
Żeby zapisać liczbę 3-cyfrową w postaci tekstowej/znakowej trzeba użyć 3 bajtów. Te znaki będą zawierać kody ASCII znaków poszczególnych cyfr (mogą tam też być kody liter).

Natomiast unsigned char który mieści 8 bitów, czyli przedział <0,255> to surowa liczba. Jeżeli wyślesz liczbę unsigned char 123 na wyświetlacz czy na UART to zobaczysz znak ASCII o kodzie 123 (taki nawias: "{"). Poczytaj o tablicy ASCII.

Inaczej mówiąc - jeżeli chcesz na wyświetlaczu/terminalu wyświetlić liczbę - musisz przekonwertować ją na tekst (w C będzie to najczęściej tablica znaków o z góry określonej długości). Dlatego do wyświetlenia lub wysłania na terminal liczby 3 cyfrowej musisz użyć 3 bajtów.

Rozumiesz?

Statystyki: Napisane przez kaamil — 11 paź 2013, o 17:41

]]> 2013-10-12T09:17:57+01:00 2013-10-11T17:25:53+01:00 https://forum.atnel.pl/viewtopic.php?t=4437&p=52580#p52580 <![CDATA[AT45DB01 - zmieszczenie jak najwęcej]]>
A więc:
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include "LCD/lcd.h"
#include "spi.h"
#include "flashmem.h"



int main(void){
uint8_t buffor[2];
uint8_t buf_read[20];

DDRA=0xff; //lcd port
PORTA=0x00;
DDRB=(1<<MOSI)|(1<<SS)|(1<<SCK);

uint8_t zmienna = 12;
//sprintf(buffor,"%d",zmienna);
buffor[0] = zmienna;

stdout=&mystdout;
memset(buf_read,0,20);
_delay_ms(20);
lcd_init();
lcd_str_P(PSTR("FlashMem test."));
SPI_MasterInit();
main_memory_page_program(0,0,buffor,sizeof(buffor));
_delay_ms(100);
//FLA_buffer_write(0,buffor,sizeof(buffor));
//FLA_buffer_to_memory_with_erase(0);
FLA_direct_memory_read(0,0,buf_read, sizeof(buffor));
lcd_set_xy(1,0);
printf("%s %d", buf_read, sizeof(buffor));

while(1){
}
return 0;
}[/syntax]

flash.c:[syntax=c]#include "flashmem.h"
#include "spi.h"


/////////////////////////////////////////////////////////
/* IMPORTANT */
/* BFA - Buffer First Address - write */
/* BA - Buffer Address -read */
/////////////////////////////////////////////////////////
void FLA_if_busy_wait(void){
uint8_t status;
do{
SS_ENABLE();
SPI_MasterTransmit(STATUS_REGISTER_READ);
SPI_MasterTransmit(0); //Receive data
SS_DISABLE();
status=SPDR;
} while (!(status&(1<<FLASH_BUSY)));
}

void FLA_page_to_buffer(uint16_t page_no){
uint8_t command[4];
command[0]=MAIN_MEMORY_PAGE_TO_BUFFER_TRANSFER;
command[1]=(page_no>>7)&0x03;
command[2]=page_no<<1;
command[3]=0;
FLA_if_busy_wait();
SS_ENABLE();
for(uint8_t i=0;i<4;i++){
SPI_MasterTransmit(command[i]);
}
SS_DISABLE();
}

void FLA_buffer_to_memory_with_erase(uint16_t page_no){
uint8_t command[4];
command[0]=BUFFER_TO_MAIN_MEMORY_PAGE_PROGRAM_WITH_ERASE;
command[1]=(page_no>>7)&0x03;//three older bits
command[2]=page_no<<1;
command[3]=0xff;
FLA_if_busy_wait();
SS_ENABLE();
for(uint8_t i=0;i<4;i++){
SPI_MasterTransmit(command[i]);
}
SS_DISABLE();
}

void FLA_buffer_read(uint16_t address, uint8_t *buffer, uint16_t length){
uint8_t command[4];
command[0]=BUFFER_READ;
command[1]=0;
command[2]=(uint8_t)(address>>8);
command[3]=(uint8_t)(address);
FLA_if_busy_wait();
SS_ENABLE();
for(uint8_t i=0;i<4;i++){
SPI_MasterTransmit(command[i]);
}
for(uint16_t n=0;n<length;n++){
SPI_MasterTransmit(0);
buffer[n]=SPDR;
}
SS_DISABLE();
}

void FLA_buffer_write(uint16_t address, uint8_t *buffer, uint16_t length){
uint8_t command[4];
command[0]=BUFFER_WRITE;
command[1]=0;
command[2]=(uint8_t)(address>>8);
command[3]=(uint8_t)(address);
FLA_if_busy_wait();
SS_ENABLE();
for(uint8_t i=0;i<4;i++){
SPI_MasterTransmit(command[i]);
}
for(uint16_t n=0;n<length;n++){
SPI_MasterTransmit(buffer[n]);
}
SS_DISABLE();
}

void FLA_direct_memory_read(uint16_t page_no, uint16_t address, uint8_t *buffer, uint16_t length){
uint8_t i;
uint8_t command[4];
command[0]=CONTINOUS_ARRAY_READ;
command[1]=(uint8_t)(page_no>>7);
command[2]=((uint8_t)(page_no<<1)) | ( ((uint8_t) address>>8) & 0x01);
command[3]=(uint8_t) address;
FLA_if_busy_wait();
SS_ENABLE();
for(i=0;i<4;i++){
SPI_MasterTransmit(command[i]);
}
for(i=0;i<4;i++){
SPI_MasterTransmit(0);
}
for(uint16_t n=0;n<length;n++){
SPI_MasterTransmit(0);
buffer[n]=SPDR;
}
SS_DISABLE();
}

void FLA_auto_page_rewrite(uint16_t page_no){
uint8_t command[4];
command[0]=AUTO_PAGE_REWRITE_THROUGH_BUFFER;
command[1]=(page_no>>7)&0x03;
command[2]=page_no<<1;
command[3]=0;
FLA_if_busy_wait();
SS_ENABLE();
for(uint8_t i=0;i<4;i++){
SPI_MasterTransmit(command[i]);
}
SS_DISABLE();
}

void FLA_page_erase(uint16_t page_no){
uint8_t command[4];
command[0]=PAGE_ERASE;
command[1]=(page_no>>7)&0x03;
command[2]=page_no<<1;
command[3]=0;
FLA_if_busy_wait();
SS_ENABLE();
for(uint8_t i=0;i<4;i++){
SPI_MasterTransmit(command[i]);
}
SS_DISABLE();
}

void FLA_block_erase(uint16_t block_no){
uint8_t command[4];
command[0]=BLOCK_ERASE;
command[1]=(uint8_t) (block_no>>4)&0x03;
command[2]=(uint8_t) block_no<<4;
command[3]=0;
FLA_if_busy_wait();
SS_ENABLE();
for(uint8_t i=0;i<4;i++){
SPI_MasterTransmit(command[i]);
}
SS_DISABLE();
}
/////////////////////////////////////////////////////////////////////////////////
/* PARAMETERS */
/* uint8_t addres_page include bracket <0,511> */
/*uint8_t address_buffer_Bajt - which bajt on page wuth bracket <0,256> */
/////////////////////////////////////////////////////////////////////////////////
void main_memory_page_program(uint16_t address_page,uint16_t address_buffer_Bajt, uint8_t *buffer, uint16_t length)
{
uint8_t command[4];



command[0] = MAIN_MEMORY_PAGE_PROGRAM_THROUGH_BUFFER;//opcode 82H
command[1] = (uint8_t) (address_page>>7)&0x03;//address select the page, where data is to be written
command[2] = (uint8_t)((address_page << 1) | ((address_buffer_Bajt >> 8)&0x01));//how up
command[3] = (uint8_t)(address_buffer_Bajt);

FLA_if_busy_wait();

SS_ENABLE();

for(int i = 0 ; i < 4 ; i++)
{
SPI_MasterTransmit(command[i]);
}

for(int n = 0 ; n < length ; n++)
{
SPI_MasterTransmit(buffer[n]);
}
SS_ENABLE();

}[/syntax]

flash.h:
[syntax=c]#ifndef _FLASHMEM_H
#define _FLASHMEM_H
#include <avr/io.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <stdlib.h>

/* AT45DB011B flash memory routines */

/*FLAG BITS*/
#define FLASH_BUSY 7
#define FLASH_COMP 6

/*Read commands*/
#define STATUS_REGISTER_READ 0xd7
#define CONTINOUS_ARRAY_READ 0xe8
#define MAIN_MEMORY_PAGE_READ 0xd2
#define BUFFER_READ 0xd4

/*Program and erase commands*/
#define BUFFER_WRITE 0x84
#define BUFFER_TO_MAIN_MEMORY_PAGE_PROGRAM_WITH_ERASE 0x83
#define BUFFER_TO_MAIN_MEMORY_PAGE_PROGRAM_WITHOUT_ERASE 0x88
#define PAGE_ERASE 0x81
#define BLOCK_ERASE 0x50
#define MAIN_MEMORY_PAGE_PROGRAM_THROUGH_BUFFER 0x82

/*Additional Commands*/
#define MAIN_MEMORY_PAGE_TO_BUFFER_TRANSFER 0x53
#define MAIN_MEMORY_PAGE_TO_BUFFER_COMPARE 0x60
#define AUTO_PAGE_REWRITE_THROUGH_BUFFER 0x58

void FLA_if_busy_wait(void);
void FLA_page_to_buffer(uint16_t page_no);
void FLA_buffer_to_memory_with_erase(uint16_t page_no);
void FLA_buffer_read(uint16_t address, uint8_t *buffer, uint16_t length);
void FLA_buffer_write(uint16_t address, uint8_t *buffer, uint16_t length);
void FLA_direct_memory_read(uint16_t page_no, uint16_t address, uint8_t *buffer, uint16_t length);
void FLA_auto_page_rewrite(uint16_t page_no);
void FLA_page_erase(uint16_t page_no);
void FLA_block_erase(uint16_t block_no);
void main_memory_page_program(uint16_t address_sector,uint16_t address_page, uint8_t *buffer, uint16_t length);

#endif[/syntax]

i spi.c:
[syntax=c]#include "spi.h"


void SPI_MasterInit(void){
SPCR=(1<<SPE)|(1<<MSTR)|(1<<SPR0);
}


void SPI_MasterTransmit(uint8_t data){
SPDR = data;
while(! (SPSR & (1<<SPIF)));
}

uint8_t SPI_MasterReceive(void){
SPDR = 0;
while(! (SPSR & (1<<SPIF)));
return SPDR;
}[/syntax]

spi.h:
[syntax=c]#ifndef _SPI_H
#define _SPI_H
#include <inttypes.h>
#include <avr/io.h>
#include <util/delay.h>

#define SS PB4
#define MOSI PB5
#define MISO PB6
#define SCK PB7


#define SS_ENABLE() {PORTB&=~(1<<SS);}
#define SS_DISABLE() {PORTB|=(1<<SS);}


void SPI_MasterInit(void);
void SPI_MasterTransmit(uint8_t data);
uint8_t SPI_MasterReceive(void);
#endif[/syntax]

Kod jest działajacy więc ktoś może sobie z nim się pobwić mając tą pamięć. Ale ważne pytanie, dlaczego jak wykorzystam sprintf i sobie zapisze liczbe 123 jako 1 bajt na 1, 1 bajt na 2 i 1 bajt na 3 to działa. A jak chce sobie zmieścić w jednym bajcie liczbe 123, bo jak wiadomo mieści sie ona w unsigned char = <0,255>, to mam lipe krzak - żeby nie było bez liści. I interesuje mnie jak wykorzystując 1 bajt zapisac liczbę z przedziału <0,255>, bo po co marnowac aż 3,2 lub 1 bajt.

Statystyki: Napisane przez Paul Dirac — 11 paź 2013, o 17:25

]]>