ATNEL tech-forum

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-02T10:20:34+01:00

Podciagniecie jest przez 2x 10k, wiec wychodzi ok 5k na linii...
Bede pamietac by nie dawac nastepnego..
A co do adresacji...nei wiem czemu na tym adresie nie dzialalo..

Statystyki: Napisane przez wchpikus — 2 lip 2015, o 10:20

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-02T09:59:36+01:00

Tylko weź pod uwagę że magistrala I2C powinna mieć tylko
jedno podciągnięcie do VCC .

Jeśli masz w drugim module również PullUp to mocniej
podciągasz do VCC przez połączenie równoległe rezystorów
przyłączonych do magistrali.

Możliwe że teraz jeszcze to niczemu nie przeszkadza ale co
jeśli do tej magistrali podłączysz jeszcze jeden moduł

Statystyki: Napisane przez Zaba — 2 lip 2015, o 09:59

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-02T08:59:51+01:00

Ok,jest postęp.
Pamiec wyjeta,a nadal mam jakies odpowiedzi z ukladu.
Soft gdzies ma blad,nie powinienem dostawac nic bez kosci.
W tym samym czasie czujnik cisnienia dziala poprawnie,nie zauwazylem ze tez ma pullup.
Wiec cos nie tak z obslugs pamieci...nie wiem co.
Program w czasie odczytu eeprom nie czyta cisnienia,wiec nie wiem skad te bledne dane..
Moze czujnik odpowiada bzdurami?

Adres czujnkia cisnienia:
BMP085_ADDR (0x77<<1);

Adres pamieci:
addressw 0xA0

Zglupialem..

Edit..
Dziala!!!
Okazuje sie ze pamiec nie moze miec adresu 0xA0...
Pod adresem 0xAE dziala bez problemu...
Nie pytajcie sie mnie dlaczego tak jest...

Statystyki: Napisane przez wchpikus — 2 lip 2015, o 08:59

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-02T05:45:32+01:00

Zaba napisał(a):

A czy czasami nie masz gdzieś dodatkowych rezystorów podciągających
np. w innym module podłączonym do I2C

Nie, upewniłem się, wyciagajac moduł pamięci..padła komunikacja z czujnikiem cisnienia.

Statystyki: Napisane przez wchpikus — 2 lip 2015, o 05:45

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T23:05:18+01:00

A czy czasami nie masz gdzieś dodatkowych rezystorów podciągających
np. w innym module podłączonym do I2C

Statystyki: Napisane przez Zaba — 1 lip 2015, o 23:05

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T22:18:50+01:00

wchpikus napisał(a):

Czy ta pamiec ma faktycznie 20ua wydajnosc pradowa?

Jaką ma wydajność to nie wiem. Nie zdziwił bym się, jakby się okazało, że zamiast wystawiać stan wysoki to ustawia się w Hi-z i niech pullupy podnoszą.

Statystyki: Napisane przez jnk0le — 1 lip 2015, o 22:18

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T22:13:11+01:00

jnk0le napisał(a):

Jakie wartości mają R2 i R3 ?

103 to bedzie 1k?

jnk0le napisał(a):

Zobacz czy będzie działać pamięć po przełożeniu jej z modułu na stykówke (WP i adresy mogą 'wisieć') lub/i odłączeniu kynarowych antenek.

postaram sie zmienic cos w ukladzie, moze faktycznie cos mam zle zrobione i takie jaja sa..
Czy ta pamiec ma faktycznie 20ua wydajnosc pradowa?

Statystyki: Napisane przez wchpikus — 1 lip 2015, o 22:13

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T21:47:31+01:00

Jakie wartości mają R2 i R3 ?

Zobacz czy będzie działać pamięć po przełożeniu jej z modułu na stykówke (WP i adresy mogą 'wisieć') lub/i odłączeniu kynarowych antenek.

Statystyki: Napisane przez jnk0le — 1 lip 2015, o 21:47

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T21:33:52+01:00

[quote="jnk0le"]Przeliczyłem sobie te przekłamania i wychodzi że niektóre jedynki są odczytywane jako zera.

Możliwe, że w układzie masz zbyt wysoką pojemność lini sygnałowych do masy (mała wydajność prądowa eeproma ( uA ?) vs 20mA z atmegi robią swoje).

Poprawic polaczenia?
Dodac cos do ukladu?
moduł mam taki, wpiety na goldpiny do plytki uniwersalnej, polaczenia atmega - pamiec - bmp085 na kynarze..
http://www.gotronik.pl/modul-pamiecia-a ... -2385.html

Statystyki: Napisane przez wchpikus — 1 lip 2015, o 21:33

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T18:54:18+01:00

Przeliczyłem sobie te przekłamania i wychodzi że niektóre jedynki są odczytywane jako zera.

Możliwe, że w układzie masz zbyt wysoką pojemność lini sygnałowych do masy (mała wydajność prądowa eeproma ( uA ?) vs 20mA z atmegi robią swoje).

twi można bez problemu przetaktowywać w dół - to nie uart .

Statystyki: Napisane przez jnk0le — 1 lip 2015, o 18:54

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T18:38:27+01:00

Analizator widzi to co wypływa z uart..
Inne predkosci twi?
Czy czegos innego?
Twi chodzi na 100k lub 400k...innych nie ma chyba.

Statystyki: Napisane przez wchpikus — 1 lip 2015, o 18:38

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T12:50:49+01:00

A jak otrzymujesz inną wartość niż zapisana to co "widzi" analizator ?

Pozostaje jeszcze wypróbować inne prędkości (200, 50, 10, 5 kHz itd).

Statystyki: Napisane przez jnk0le — 1 lip 2015, o 12:50

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T12:15:48+01:00

zegar na 14745600..
Dokladnie, dosc dziwaczna...dlatego pytam:)
Nigdy nie mialem z eepromem problemów, szczególnie ze twi działa obecnie...jak widać po ramkach..

Dziwne jest tez to, ze zapis "0" do pamiecie idzie dobrze, odczyt zawsze jest 0
Z "1" jest juz gorzej, losowo 0 i 1 (oczywiscie po zapisie 0 wczesniej).

Przy zapisie 10, losowe dane od 0 do 10...
przy 100, losowe od 0 do 100...

Statystyki: Napisane przez wchpikus — 1 lip 2015, o 12:15

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T11:54:49+01:00

Dane losowe, ale powtarzają się (96, 64, 32 ...), dosyć dziwaczna sytuacja.

Jakie masz taktowanie procka ?
Z tego co wiem TWBR nie może być mniejszy niż 10, przez co 1mhz nie pozwala na ustawienie 100kHz.

Statystyki: Napisane przez jnk0le — 1 lip 2015, o 11:54

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T11:28:23+01:00

Dodalem twoja biblioteke, nadal mam to samo..
Czyli nie odczytuje danych, losowe wyniki sa.
Ramki sa ok, dane poprawne..

do "x" przypisuje 10, 1 10, 100...

moj kod:

[syntax=c]uart_puts("zapis= ");uart_puts("\r\n");
uint16_t i;
uint8_t device = 0xA0;
for (i=10; i<15;i++){
eewrite(device,i,x);
uart_puts("ADRES write= ");uart_putnr(i);uart_puts(" dana= ");uart_putnr(x);uart_puts("\r\n");
}

uart_puts("odczyt= ");uart_puts("\r\n");
uint8_t dataout;
uint8_t device = 0xA0;
uart_puts("odczyt= ");uart_puts("\r\n");
uint16_t i;

for (i=10; i<15; i++){
dataout = eeread(device,i);
uart_puts("ADRES read= ");uart_putnr(i);uart_puts(" dana= ");uart_putnr(dataout);uart_puts("\r\n");
}[/syntax]

[syntax=c]void eewrite(uint8_t device, uint16_t addr, uint8_t dat)
{
start:
twistart();
twiwrite(device);

if ( (TWSR & 0xF8) == TW_MT_SLA_NACK)
{
twistop();
goto start;
}

twiwrite(addr >> 8);
twiwrite(addr);

twiwrite(dat);
twistop();
}

uint8_t eeread(uint8_t device, uint16_t addr)
{
uint8_t dat;
start:
twistart();
twiwrite(device);

if ( (TWSR & 0xF8) == TW_MT_SLA_NACK)
{
twistop();
goto start;
}

twiwrite(addr >> 8);
twiwrite(addr);

twistart();
twiwrite(device+1);
dat = twiread(0); //0 - NOACK
twistop();

return dat;
}[/syntax]

Czyli to nie to..
odczyt wyglada tak:

ADRES write= 10 dana= 100
ADRES write= 11 dana= 100
ADRES write= 12 dana= 100
ADRES write= 13 dana= 100
ADRES write= 14 dana= 100

ADRES read= 10 dana= 96
ADRES read= 11 dana= 100
ADRES read= 12 dana= 100
ADRES read= 13 dana= 100
ADRES read= 14 dana= 96

Kazdy nastepny odczyt:

ADRES read= 10 dana= 96
ADRES read= 11 dana= 96
ADRES read= 12 dana= 100
ADRES read= 13 dana= 100
ADRES read= 14 dana= 100

odczyt=
ADRES read= 10 dana= 68
ADRES read= 11 dana= 68
ADRES read= 12 dana= 64
ADRES read= 13 dana= 64
ADRES read= 14 dana= 64

odczyt=
ADRES read= 10 dana= 0
ADRES read= 11 dana= 0
ADRES read= 12 dana= 32
ADRES read= 13 dana= 32
ADRES read= 14 dana= 32

odczyt=
ADRES read= 10 dana= 100
ADRES read= 11 dana= 96
ADRES read= 12 dana= 0
ADRES read= 13 dana= 0
ADRES read= 14 dana= 0

losowe dane...
Jak pisalem wyzej, obsluga BMP085 dziala poprawnie na bibliotece TWI...

[syntax=c]#include
#include
#include
#include "i2cmaster.h"

/* I2C clock in Hz */
#define SCL_CLOCK 400000L

/*************************************************************************
Initialization of the I2C bus interface. Need to be called only once
*************************************************************************/
void i2c_init(void)
{
/* initialize TWI clock: 100 kHz clock, TWPS = 0 => prescaler = 1 */

TWSR = 0; /* no prescaler */
TWBR = (uint8_t)(((F_CPU/SCL_CLOCK)-16)/2); /* must be > 10 for stable operation */

}/* i2c_init */

uint8_t i2c_sync(void){
uint16_t timeout = 100;
while(!(TWCR & (1<_delay_us(1);
timeout--;
}
return timeout != 0;
}

uint8_t i2c_waitStop(void){
uint16_t timeout = 100;
while((TWCR & (1<_delay_us(1);
timeout--;
}
return timeout != 0;
}
/*************************************************************************
Issues a start condition and sends address and transfer direction.
return 0 = device accessible, 1= failed to access device
*************************************************************************/
unsigned char i2c_start(unsigned char address)
{
uint8_t twst;

// send START condition
TWCR = (1<
// wait until transmission completed (this is stupid!!)
if(!i2c_sync()) return 0;

// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
if ( (twst != TW_START) && (twst != TW_REP_START)) return 1;

// send device address
TWDR = address;
TWCR = (1<
// wail until transmission completed and ACK/NACK has been received
if(!i2c_sync()) return 0;

// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return 1;

return 0;

}/* i2c_start */

/*************************************************************************
Issues a start condition and sends address and transfer direction.
If device is busy, use ack polling to wait until device is ready

Input: address and transfer direction of I2C device
*************************************************************************/
uint8_t i2c_start_wait(unsigned char address)
{
uint8_t twst;

int retry = 2000;
while ( 1 )
{
// send START condition
TWCR = (1<
// wait until transmission completed
if(!i2c_sync()) break;

// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
if ( (twst != TW_START) && (twst != TW_REP_START)) continue;

// send device address
TWDR = address;
TWCR = (1<
// wail until transmission completed
if(!i2c_sync()) break;

// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
if ( (twst == TW_MT_SLA_NACK )||(twst ==TW_MR_DATA_NACK) )
{
/* device busy, send stop condition to terminate write operation */
TWCR = (1<
// wait until stop condition is executed and bus released
if(!i2c_waitStop()) continue;

if(!(retry --)) break;
continue;
}
return 1;
//if( twst != TW_MT_SLA_ACK) return 1;
break;
}
return 0;
}/* i2c_start_wait */

/*************************************************************************
Issues a repeated start condition and sends address and transfer direction
Input: address and transfer direction of I2C device

Return: 0 device accessible
1 failed to access device
*************************************************************************/
unsigned char i2c_rep_start(unsigned char address)
{
return i2c_start( address );

}/* i2c_rep_start */

/*************************************************************************
Terminates the data transfer and releases the I2C bus
*************************************************************************/
void i2c_stop(void)
{
/* send stop condition */
TWCR = (1<
// wait until stop condition is executed and bus released
i2c_waitStop();

}/* i2c_stop */

/*************************************************************************
Send one byte to I2C device

Input: byte to be transfered
Return: 0 write successful
1 write failed
*************************************************************************/
unsigned char i2c_write( unsigned char data )
{
uint8_t twst;

// send data to the previously addressed device
TWDR = data;
TWCR = (1<
// wait until transmission completed
i2c_sync();

// check value of TWI Status Register. Mask prescaler bits
twst = TW_STATUS & 0xF8;
if( twst != TW_MT_DATA_ACK) return 1;
return 0;

}/* i2c_write */

/*************************************************************************
Read one byte from the I2C device, request more data from device

Return: byte read from I2C device
*************************************************************************/
unsigned char i2c_readAck(void)
{
TWCR = (1<i2c_sync();
return TWDR;
}/* i2c_readAck */

/*************************************************************************
Read one byte from the I2C device, read is followed by a stop condition

Return: byte read from I2C device
*************************************************************************/
unsigned char i2c_readNak(void)
{
TWCR = (1<i2c_sync();
//uart_puts("Adana odczytana z pamieci= ");uart_putnrhex(TWDR);uart_puts("\r\n");
return TWDR;
}/* i2c_readNak */

void twi_init(uint8_t twbr_value)
{
//TWSR = 0x00;
TWBR = twbr_value;
}

void twistart(void)
{
TWCR = (1<while (!(TWCR & (1<}

void twistop(void)
{
TWCR = (1<while ((TWCR & (1<}

void twiwrite(uint8_t data)
{
TWDR = data;
TWCR = (1<while (!(TWCR & (1<}

uint8_t twiread(uint16_t ack) // nack 0
{
TWCR = ack ?
((1 << TWINT) | (1 << TWEN) | (1 << TWEA))
: ((1 << TWINT) | (1 << TWEN)) ;

while (!(TWCR & (1<return TWDR;
}

/*
void scan(void)
{
uart_puts_P("Scanning for devices on i2c bus ...\r\n\n");

for(uint8_t s = 0; s <= 0x7F; s++)
{
twistart();
twiwrite(SLA_W(s));

if(TW_STATUS == TW_MT_SLA_ACK )
{
uart_puts_P("Found device at address - 0x");
uart_put_hex(s);
uart_puts_P(" (<< 1 for SLA_W) \t 0b");
uart_putintr(s, 2);
uart_puts_P(" 0\r\n");

}
twistop();
}
}*/[/syntax]

Statystyki: Napisane przez wchpikus — 1 lip 2015, o 11:28

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T09:32:43+01:00

https://github.com/jnk0le/AVR-I2C-libs

Podawałem to już parę postów wyżej.

Kod sklejony na szybko z gotowców i nieco poprawiony, niedługo pojawi się coś lepszego.
W TWI_routines są podstawowe operacje na i2c, a 24C32 eepromy 4-64 kbx8.

I jakby co to
[syntax=c]main(){
...
twi_init(TWBR_CALC(100000));

for(uint16_t i=0; i < 4096; i++)
eewrite(SLA_24C_W, i, 0x00);

uart_puts_P("random read :\r\n");

for(uint16_t i = 0, j=1; i < 1024; i++, j++)
{
tmp = eeread(SLA_24C_W, i);
uart_put_hex(tmp);
uart_putc(' ');

if(j == 8)
{
uart_puts("\r\n");
j = 0;
}
}

uint8_t buf[8]={0x2,0x4,0x8,0x16,0x32,0x62,0x11,0x33};

ee_write_page(SLA_24C_W, 128, 8, buf); // 32 byte aligment - read datasheet

uart_puts_P("page read :\r\n");
ee_read_page(SLA_24C_W, 0, 1024, readbuffer);

for(uint16_t i = 0, j=1; i < 1024; i++, j++)
{
uart_put_hex(readbuffer[i]);
uart_putc(' ');

if(j == 8)
{
uart_puts("\r\n");
j = 0;
}
}

}[/syntax]

EDIT:
[syntax=c]unsigned char i2c_readNak(void)
{
TWCR = (1< i2c_sync();
//uart_puts("Adana odczytana z pamieci= ");uart_putnrhex(TWDR);uart_puts("\r\n");
return TWDR;
}[/syntax]

Spróbuj odczytać TWDR przed sync'em.

Statystyki: Napisane przez jnk0le — 1 lip 2015, o 09:32

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-07-01T08:30:25+01:00

to nadal nie to..moge proscic o jakis przykladowy kod zapisu i oczytu?
Moje biblioteki sa takie:

[syntax=c]unsigned char i2c_start(unsigned char address)
{
uint8_t twst;

// send START condition
TWCR = (1<
// wait until transmission completed (this is stupid!!)
if(!i2c_sync()) return 0;

// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
if ( (twst != TW_START) && (twst != TW_REP_START)) return 1;

// send device address
TWDR = address;
TWCR = (1<
// wail until transmission completed and ACK/NACK has been received
if(!i2c_sync()) return 0;

// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return 1;

return 0;

}/* i2c_start */

/*************************************************************************
Issues a start condition and sends address and transfer direction.
If device is busy, use ack polling to wait until device is ready

Input: address and transfer direction of I2C device
*************************************************************************/
uint8_t i2c_start_wait(unsigned char address)
{
uint8_t twst;

int retry = 2000;
while ( 1 )
{
// send START condition
TWCR = (1<
// wait until transmission completed
if(!i2c_sync()) break;

// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
if ( (twst != TW_START) && (twst != TW_REP_START)) continue;

// send device address
TWDR = address;
TWCR = (1<
// wail until transmission completed
if(!i2c_sync()) break;

// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
if ( (twst == TW_MT_SLA_NACK )||(twst ==TW_MR_DATA_NACK) )
{
/* device busy, send stop condition to terminate write operation */
TWCR = (1<
// wait until stop condition is executed and bus released
if(!i2c_waitStop()) continue;

if(!(retry --)) break;
continue;
}
return 1;
//if( twst != TW_MT_SLA_ACK) return 1;
break;
}
return 0;
}/* i2c_start_wait */

/*************************************************************************
Issues a repeated start condition and sends address and transfer direction
Input: address and transfer direction of I2C device

Return: 0 device accessible
1 failed to access device
*************************************************************************/
unsigned char i2c_rep_start(unsigned char address)
{
return i2c_start( address );

}/* i2c_rep_start */

/*************************************************************************
Terminates the data transfer and releases the I2C bus
*************************************************************************/
void i2c_stop(void)
{
/* send stop condition */
TWCR = (1<
// wait until stop condition is executed and bus released
i2c_waitStop();

}/* i2c_stop */

/*************************************************************************
Send one byte to I2C device

Input: byte to be transfered
Return: 0 write successful
1 write failed
*************************************************************************/
unsigned char i2c_write( unsigned char data )
{
uint8_t twst;

// send data to the previously addressed device
TWDR = data;
TWCR = (1<
// wait until transmission completed
i2c_sync();

// check value of TWI Status Register. Mask prescaler bits
twst = TW_STATUS & 0xF8;
if( twst != TW_MT_DATA_ACK) return 1;
return 0;

}/* i2c_write */

/*************************************************************************
Read one byte from the I2C device, request more data from device

Return: byte read from I2C device
*************************************************************************/
unsigned char i2c_readAck(void)
{
TWCR = (1<i2c_sync();
return TWDR;
}/* i2c_readAck */

/*************************************************************************
Read one byte from the I2C device, read is followed by a stop condition

Return: byte read from I2C device
*************************************************************************/
unsigned char i2c_readNak(void)
{
TWCR = (1<i2c_sync();
//uart_puts("Adana odczytana z pamieci= ");uart_putnrhex(TWDR);uart_puts("\r\n");
return TWDR;
}/* i2c_readNak */[/syntax]

Statystyki: Napisane przez wchpikus — 1 lip 2015, o 08:30

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-06-30T20:23:40+01:00

Ok sprawdze jutro...moze faktycznie rejestr sie czysci..twdr..nie zauwazylem ze faktycznie delay jest przed odczytem.

Mozesz podeslas swoja funkcje send i read?
Widze ze robisz to bezposrednio na twi hardware.

Statystyki: Napisane przez wchpikus — 30 cze 2015, o 20:23

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-06-30T16:54:51+01:00

Odczytujesz TWDR 25ms po zakończeniu transmisji, możliwe że po wysłaniu 'stopa' wartość rejestru TWDR może być niezdefiniowana.

U mnie odczyt zrobiony jest tak
[syntax=c]uint8_t twiread(uint16_t ack) // bardzo prawdopodobne rozdzielenie na read ack i read nak.
{
TWCR = ack ?
((1 << TWINT) | (1 << TWEN) | (1<: ((1 << TWINT) | (1 << TWEN) | (1<
while (!(TWCR & (1<return TWDR;
}

uint8_t eeread(uint8_t device, uint16_t addr)
{
uint8_t dat;
start:
twistart();
twiwrite(device);

if ( (TWSR & 0xF8) == TW_MT_SLA_NACK)
{
twistop();
goto start;
}

twiwrite(addr >> 8);
twiwrite(addr);

twistart();
twiwrite(device+1);
dat = twiread(0); //O - NOACK
twistop();

return dat;
}[/syntax]

Masz te funkcje z jakiegoś tutoriala czy sam sobie skleiłeś ?

A i jeszcze brakuje i2c_stop() po readNAK

Statystyki: Napisane przez jnk0le — 30 cze 2015, o 16:54

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-06-30T14:09:53+01:00

sie za wczesnie...cos znow nie dziala:(

[syntax=c]void writeData(unsigned char addr, unsigned char datain)
{

i2c_start(addressw);
i2c_write(addr>> 8);
i2c_write(addr);
i2c_write(datain);
i2c_stop();
_delay_ms(25);

}

int readData(unsigned char addr){
uint8_t dataout;
i2c_start(addressw);
i2c_write (addr >> 8);
i2c_write (addr);
i2c_rep_start(addressr);
i2c_readNak();
_delay_ms(25);
dataout = TWDR;
return dataout;
}[/syntax]

Troche zmienilem ta funkcje, by nie miala argumentu dataout.

Statystyki: Napisane przez wchpikus — 30 cze 2015, o 14:09

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-06-30T14:02:55+01:00

Wrzuć cały kod od writeData i readData.

[syntax=c]i = readData(1,&dataout);
uart_puts("PWM_Value_night read from eeprom = ");uart_putnr(i);
//a dataout ?[/syntax]
tu może być problem.

Statystyki: Napisane przez jnk0le — 30 cze 2015, o 14:02

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-06-30T13:17:48+01:00

Mam jeszcze jeden problem...moze przy okazji:

Nie dziala mi przekazywanie parametrow PWM_Value_day i PWM_Value_night do funkcji
void zapis_do_pamieci(unsigned char PWM_Value_day,unsigned char PWM_Value_night)..

mam takie wyniki:
PWM_Value_day przed zapisem = 135
PWM_Value_night przed zapisem = 85
PWM_Value_day write zapis= 135
PWM_Value_night write zapis= 85
PWM_Value_day read from eeprom = 0
PWM_Value_night read from eeprom = 69

Jak widac dane wchodza popranie, ale uz sie nie zapisuja popranie w pamieci..

Ustawianie dziala, mam zwracane poprane wartosci, ale jak juz wchodzi do zapisu to jest blad...

Gdzie robie blad?

[syntax=c]void zapis_do_pamieci(unsigned char PWM_Value_day,unsigned char PWM_Value_night);
int exit_podswietlenie_bit;
int ustaw_jasnosc(unsigned char *PWM_Value_day,unsigned char *PWM_Value_night, int *menu_brightness_bit,int *menu_brightnessday_bit,int *menu_brightnessnight_bit);//ustawienie dla dnia
//void eeprom_write(unsigned int EEPAddress, unsigned char EEPData);

uint8_t commandnew;
unsigned char bar=5;
uint8_t x_kro;
uint8_t x_poz;
int pozycja;
int pozycjanr;

uint16_t adc_result;

int podswietlenie(unsigned char PWM_Value_day,unsigned char PWM_Value_night, int *menu_brightness_bit,int *menu_brightnessday_bit,int *menu_brightnessnight_bit){ //ustawienie dla nocy
LED1_off;
//uart_puts("exit_podswietlenie_bit exit podswietlenie wejscie= ");uart_putnr(exit_podswietlenie_bit);uart_puts("\r\n");

while(*menu_brightness_bit == 1 && *menu_brightnessday_bit == 1 && *menu_brightnessnight_bit == 0 && exit_podswietlenie_bit == 0){
ir_recive(&commandnew);
ustaw_jasnosc( &PWM_Value_day, &PWM_Value_night, menu_brightness_bit, menu_brightnessday_bit, menu_brightnessnight_bit);
OCR2 = bar;
uart_puts("podswietlenir ustaw jasnosc dzien= ");uart_putnr(PWM_Value_day);uart_puts("\r\n");

if (commandnew == exit && *menu_brightnessday_bit == 1 && *menu_brightnessnight_bit == 0 ){ //wyjscie z ustawienia podswietlenia dzien

//uart_puts("wciskam exit= ");uart_putnr(commandnew);uart_puts("\r\n");
*menu_brightnessday_bit = 0;
*menu_brightnessnight_bit = 1;
commandnew=255;
}
}

while(*menu_brightness_bit == 1 && *menu_brightnessday_bit == 0 &&*menu_brightnessnight_bit == 1 && exit_podswietlenie_bit == 0){ ////wyjscie z ustawienia podswietlenia noc
//int i;
ir_recive(&commandnew);
ustaw_jasnosc(&PWM_Value_day, &PWM_Value_night, menu_brightness_bit, menu_brightnessday_bit, menu_brightnessnight_bit);
OCR2 = bar;
uart_puts("podswietlenir ustaw jasnosc noc= ");uart_putnr(PWM_Value_night);uart_puts("\r\n");

if (commandnew == exit && *menu_brightness_bit == 1 && *menu_brightnessday_bit == 0 && *menu_brightnessnight_bit == 1 && exit_podswietlenie_bit == 0){ //funkcja wyjscia i zapisu
//unsigned int i;
*menu_brightness_bit = 1;
*menu_brightnessday_bit = 0;
*menu_brightnessnight_bit = 0;
exit_podswietlenie_bit = 1;

while(*menu_brightness_bit == 1 && *menu_brightnessday_bit == 0 &&*menu_brightnessnight_bit == 0 && exit_podswietlenie_bit == 1){

ustawienie_pozycji(&pozycja,&pozycjanr);
if (pozycjanr > 1){
pozycjanr = 0;
}

uart_puts("bar= ");uart_putnr(bar);uart_puts("\r\n");
uart_puts("PWM_Value_day przed zapisem = ");uart_putnr(PWM_Value_day);uart_puts("\r\n");
uart_puts("PWM_Value_night przed zapisem = ");uart_putnr(PWM_Value_night);uart_puts("\r\n");

if (pozycjanr == 0 && exit_podswietlenie_bit == 1){ //wyjscie i zapis do pamieci

if (commandnew == button_ok){
zapis_do_pamieci(PWM_Value_day,PWM_Value_night); //zapis do pamieci
*menu_brightness_bit = 0;
*menu_brightnessday_bit = 0;
*menu_brightnessnight_bit = 0;
exit_podswietlenie_bit = 0;
GLCD_ClearGraphic();
commandnew=255;
}
}
if (pozycjanr == 1 && exit_podswietlenie_bit == 1){//wyjscie bez zapisu

if (commandnew == button_ok){
*menu_brightness_bit = 0;
*menu_brightnessday_bit = 0;
*menu_brightnessnight_bit = 0;
exit_podswietlenie_bit = 0;
GLCD_ClearGraphic();
commandnew=255;
}
}

GLCD_Graph_flash_ins(save,32,35); //wyswietl grafike
GLCD_Graph_flash_ins(discard,121,35);
GLCD_Graph_flash_ins(minus,pozycja,50);
commandnew=255;
}
GLCD_ClearGraphic();
}
}

return *menu_brightness_bit;
}

int ustaw_jasnosc(unsigned char *PWM_Value_day,unsigned char *PWM_Value_night, int *menu_brightness_bit,int *menu_brightnessday_bit,int *menu_brightnessnight_bit){
if (commandnew == cursor_right){
bar = bar +10;
commandnew=255;
}

if (commandnew == cursor_left){
bar = bar-10;
commandnew=255;
}

for (x_kro=0; x_krox_poz =x_kro;
GLCD_Graph_flash_ins(kropka,x_poz,30);
}

GLCD_Graph_flash_cdn(setupbrightness,0,40); //wyswietlenie day
if (*menu_brightnessday_bit == 1){
GLCD_Graph_flash_ins(day,152,40);
}
if (*menu_brightnessnight_bit == 1){
GLCD_Graph_flash_ins(night,152,40); //wyswietlenie noc
}
GLCD_Graph_flash_ins(min,0,0);
GLCD_Graph_flash_ins(max,214,0);

if (*menu_brightnessday_bit == 1){ //przypisanie pwm do zmiennych dla dnia
*PWM_Value_day = bar;
}
if (*menu_brightnessnight_bit == 1){//przypisanie pwm do zmiennych dla nocy
*PWM_Value_night = bar;
}
return *menu_brightness_bit;

return *PWM_Value_day;
return *PWM_Value_night;
}

void jasnosc (unsigned char PWM_Value_day,unsigned char PWM_Value_night){
if (adc_result>10){
OCR2 = PWM_Value_day;
}

if (adc_result == 0){
OCR2 = PWM_Value_night;
}

}

void zapis_do_pamieci(unsigned char PWM_Value_day,unsigned char PWM_Value_night){
unsigned char i;
unsigned char dataout;

writeData(0,PWM_Value_day);
writeData(1,PWM_Value_night);
uart_puts("PWM_Value_day write zapis= ");uart_putnr(PWM_Value_day);uart_puts("\r\n");
uart_puts("PWM_Value_night write zapis= ");uart_putnr(PWM_Value_night);uart_puts("\r\n");
i = readData(0,&dataout);
uart_puts("PWM_Value_day read from eeprom = ");uart_putnr(i);uart_puts("\r\n");
i = readData(1,&dataout);
uart_puts("PWM_Value_night read from eeprom = ");uart_putnr(i);uart_puts("\r\n");

}[/syntax]

Statystyki: Napisane przez wchpikus — 30 cze 2015, o 13:17

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-06-30T12:36:34+01:00

wchpikus napisał(a):

Juz wiem:)
Jeju, ale zrobiłem bube...

I jak zwykle najwięcej problemów sprawia coś nieistotnego

[syntax=c]void writeData(unsigned char addr, unsigned char *datain){...}

//gdzieś w mainie
writeData(addr, &data);[/syntax]
Powinno działać.

Teraz możesz się pozbyć tego delaya stosując coś takiego

[syntax=c]void eewrite(uint8_t device, uint16_t addr, uint8_t dat)
{
start:
twistart();
twiwrite(device);

if ( (TWSR & 0xF8) == TW_MT_SLA_NACK)
{
twistop();
goto start;
}

twiwrite(addr >> 8);
twiwrite(addr);

twiwrite(dat);
twistop();

}[/syntax]

Statystyki: Napisane przez jnk0le — 30 cze 2015, o 12:36

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-06-30T10:41:39+01:00

Juz wiem:)
Jeju, ale zrobiłem bube...

[syntax=c]void writeData(unsigned char addr, unsigned char *datain)
{

i2c_start(addressw);
i2c_write(addr>> 8);
i2c_write(addr);
i2c_write(*datain);
i2c_stop();
_delay_ms(25);[/syntax]

Miałem rzutowanie....stad nie działało...ale kicha:)

[syntax=c]void writeData(unsigned char addr, unsigned char datain)
{

i2c_start(addressw);
i2c_write(addr>> 8);
i2c_write(addr);
i2c_write(datain);
i2c_stop();
_delay_ms(25);[/syntax]

Bez rzutowania działa...

Statystyki: Napisane przez wchpikus — 30 cze 2015, o 10:41

Re: 24c256 ic2 atmega128..nie dziala, nie wiadomo czemu..

2015-06-26T13:29:21+01:00

Zapisalem 20k adresow, odczyt inny niz zapisane dane..
Stronami zapisuje sie flash, nie eeprom..

Wymieniłem pamięć na inna, to samo...

Znalazlem dziwny kod, nei za bardzo rozumiem dlaczego tak to jest robione, juz w kilku przykladach jest tak dziwnie...

[syntax=c]// set the 24C256 eeprom address to 0
Wire.beginTransmission(80);
Wire.send(0); // address low byte
Wire.send(0); // address high byte
Wire.endTransmission();[/syntax]

Ustawienie adresu??

[syntax=c]// read 1 byte, from address 0
Wire.requestFrom(80, 1);
while(Wire.available()) {
num = Wire.receive();
}
Serial.print("num = ");
Serial.println(num, DEC);

// increment num
num = num + 1;

// write "num" to 24C256 eeprom at address zero
Wire.beginTransmission(80);
Wire.send(0); // address low byte
Wire.send(0); // address high byte
Wire.send(num); // any more send starts writing
Wire.endTransmission();[/syntax]

Czytanie i zapis jasny jest dla mnie..
Ale o co to ustawienie adresu??

Statystyki: Napisane przez wchpikus — 26 cze 2015, o 13:29