ATNEL tech-forum

Re: TWI MR-ST problem z odczytem bufora danych

2018-05-22T17:59:55+01:00

igsor96 napisał(a):

Po dodaniu delaya do funkcji write_slave problem zniknął

Powiem tak - jeśli dodałeś tego delaya i problem zniknął to masz coś nie tak (przypuszczam że z warunkiem w while).
Sekcję
[syntax=c]_delay_ms(100);
uart_putint(TW_STATUS,16);[/syntax]
dodałem tylko po to by podejrzeć jakie wartości status code zwraca TWI SLAVE-a, delay był tu konieczny i oszacowany na "bezpieczne oko" tak by operacja wysyłki tego kodu po UART była już na pewno po operacji wysłania bajtu po TWI.
W czasie normalnej pracy modułu TWI właściwy czas oczekiwania załatwia właśnie pętla while która zatrzymuje działanie programu do czasu pojawienia się właściwego status code co jest równoznaczne z zakończeniem operacji wysyłania bajtu przez moduł TWI.
U mnie program działa również po usunięciu delaya i funkcji uart_putint.

A tak wogule to nie wiem czy twoje podejście do TWI SLAVE jest właściwe. Widzisz moduł SLAVE powinien wykonywać polecenia MASTER-a. Więc budowanie funkcji która wysyła zdefiniowaną ilość bajtów nie do końca jest trafione.
Funkcja powinna cały czas wysyłać kolejne dane jeśli MASTER po odbiorze bajtu wystawia ACK, informując SLAVE że chce odczytywać kolejne bajty; a przerwać funkcję w momencie wysłania przez MASTER NACK. Przynajmniej tak to robią wszelakie moduły pracujące na magistrali TWI w roli SLAVE-a. Takie jest moje zdanie - choć niekoniecznie musi być słuszne

Statystyki: Napisane przez xentis — 22 maja 2018, o 17:59

Re: TWI MR-ST problem z odczytem bufora danych

2018-05-21T18:39:50+01:00

Po dodaniu delaya do funkcji write_slave problem zniknął Bardzo dziękuje za pomoc!

Statystyki: Napisane przez igsor96 — 21 maja 2018, o 18:39

Re: TWI MR-ST problem z odczytem bufora danych

2018-05-21T17:39:11+01:00

Hym... na to pytanie to chyba będzie mi ciężko odpowiedzieć bo u mnie po modyfikacji funkcji TWI_write_slave(uint8_t data) do postaci:
[syntax=c]void TWI_write_slave(uint8_t data) // Function to write data
{
TWDR= data; // Fill TWDR register whith the data to be sent
TWCR= (1<_delay_ms(100);
uart_putint(TW_STATUS,16);
while((TW_STATUS != TW_ST_DATA_ACK)&&(TW_STATUS != TW_ST_DATA_NACK)); // Wait for the acknowledgement
LED_TOG;
}[/syntax]
cały bufor leci do mastera we właściwej formie czyli w terminalu master cyklicznie wypluwa ciąg 12345678.
Nie wiem, może masz coś nie tak w samej bibliotece UART-a, bo tej nie wrzuciłeś więc nie jestem w stanie powiedzieć dla czego u mnie to działa a u Ciebie nie. Ja podłączyłem bibliotekę do UARTA mirkową z BB. Wprowadziłem kilka koniecznych zmian tak by owa biblioteka działała poprawnie, reszta kodu jest żywcem przerzucona ze źródeł które wrzuciłeś, z modyfikacją jedynie funkcji TWI_write_slave.

Statystyki: Napisane przez xentis — 21 maja 2018, o 17:39

Re: TWI MR-ST problem z odczytem bufora danych

2018-05-20T22:19:23+01:00

Tak, to było to! Ogromnie dziękuję za pomoc! Jeszcze dopytam przy okazji. Slave się 'odblokował' i wysyła bufor tylko, że z niewiadomych przyczyn ciągle jego pierwszy indeks. Zamieniłem funkcję TWI_write_slave_buf na tą analogiczną do poradnika p.Mirka ale dalej to samo. Co może być tego przyczyną?
[syntax=c]void TWI_write_slave_buf(uint8_t *buf, uint8_t len)
{
for(int i=0;i {

uint8_t b=*buf++;
TWI_write_slave(b);

}
}[/syntax]

Statystyki: Napisane przez igsor96 — 20 maja 2018, o 22:19

Re: TWI MR-ST problem z odczytem bufora danych

2018-05-20T21:26:20+01:00

Problem masz w tej funkcji:
[syntax=c]void TWI_write_slave(uint8_t data) // Function to write data
{
TWDR= data; // Fill TWDR register whith the data to be sent
TWCR= (1<while((TW_STATUS) != TW_ST_DATA_ACK); // Wait for the acknowledgement
}[/syntax]
Ponieważ w rejestrze TWCR nie ustawiasz bitu TWEA, slave zwraca status code=0xC8, a twoja pętla while czeka cały czas na kod 0xB8 (ukryty pod makrem TW_ST_DATA_ACK), tak więc jak zmodyfikujesz funkcję do takiej postaci:
[syntax=c]void TWI_write_slave(uint8_t data) // Function to write data
{
TWDR= data; // Fill TWDR register whith the data to be sent
TWCR= (1<while((TW_STATUS) != TW_ST_DATA_ACK); // Wait for the acknowledgement
}[/syntax]
Slave wyśle wszystkie 8 bajtów z bufora. Niestety na tym zakończy i już więcej nic nie wyśle bo znów ugrzęźnie w tej samej pętli while która nadal czeka na status code=0xB8, a przecież gdy master odbierze ósmy bajt wysyła NACK czyli moduł TWI slave zwróci status code=0xC0.
Musiałbyś do warunku pętli while dodać drugi jako sumę logiczną z drugim status codem, lub też wogule zrezygnować ze sprawdzania tych kodów, a jako koniec operacji wysyłania sprawdzać czy bit TWINT został ustawiony na 1.

Statystyki: Napisane przez xentis — 20 maja 2018, o 21:26

Re: TWI MR-ST problem z odczytem bufora danych

2018-05-20T17:03:19+01:00

Faktycznie, zapomniałem ją tam wrzucić. Problem jednak dalej aktualny.

Statystyki: Napisane przez igsor96 — 20 maja 2018, o 17:03

Re: TWI MR-ST problem z odczytem bufora danych

2018-05-20T16:58:29+01:00

W kodzie dla slave-a jest funkcja której wogule nie ma w plikach:
[syntax=c]TWI_write_slave_buf(buf,8);[/syntax]

------------------------ [ Dodano po: 1 minucie ]

a ok zapomniałeś ją wrzucić do pliku h biblioteki.

Statystyki: Napisane przez xentis — 20 maja 2018, o 16:58

TWI MR-ST problem z odczytem bufora danych

2018-05-20T13:18:09+01:00

Dzień dobry,
Od dłuższego czasu walczę z magistralą TWI na Atmedze8. Odbieranie/wysyłanie bajtu między dwoma uC działa poprawnie, jednak problemy zaczynają się kiedy próbuję odebrać bufor ze slave'a. Cały program zawiesza się w momencie kiedy master oczekuje odebrania danych ze slave'a w funkcji TWI_read_buf. Dokładnie w tej linijce:
[syntax=c]while (len--) *buf++ = TWI_read( len ? ACK : NACK );[/syntax]

Próbowałem temat ugryźć na wiele sposobów ale bez rezultatu. Nie mam już pomysłu gdzie robię błąd, dlatego proszę Was o pomoc w rozwiązaniu problemu.

Biblioteka.h:
[syntax=c]/*
* i2c_twi.h
*
* Created on: 2010-09-07
* Autor:
*/

#ifndef I2C_TWI_H_
#define I2C_TWI_H_

#define ACK 1
#define NACK 0

#define TWI_SLAError 6
#define TWI_WriteError 5
#define TWI_STARTError 1
#define TWI_NoNACK 3
#define TWI_NoACK 4
extern uint8_t TWI_Error;
// funkcje
inline void TWI_SetError(uint8_t err)
{
TWI_Error=err;
}

void TWISetBitrate(void);
void TWI_start(void);
void TWI_stop(void);
void TWI_write(uint8_t bajt);
uint8_t TWI_read(uint8_t ack);
void TWI_slave_init(uint8_t SLA);
void TWI_write_buf( uint8_t SLA,uint8_t len, uint8_t *buf );
void TWI_read_buf(uint8_t SLA, uint8_t len, uint8_t *buf);
uint8_t TWI_read_slave(void);
void TWI_match_read_slave(void);
void TWI_match_write_slave(void);
void TWI_write_slave(uint8_t data);
#endif /* I2C_TWI_H_ */[/syntax]

Biblioteka.c:
[syntax=c]/*
* i2c_twi.c
*
* Created on: 2010-09-07
* Autor:
*/
#include
#include
#include "i2c_twi.h"

void TWISetBitrate(void) {
TWBR=0x01; // Bit rate
TWSR=(0< // SCL freq= F_CPU/(16+2(TWBR).4^TWPS)
}

void TWI_start(void) {
TWCR = (1< while (!(TWCR&(1< if(TW_STATUS!=TW_MT_DATA_ACK) TWI_SetError(TWI_STARTError);
}

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

void TWI_write(uint8_t bajt) {
TWDR = bajt;
TWCR = (1< while ( !(TWCR&(1< if(TW_STATUS!=TW_MT_DATA_ACK) TWI_SetError(TWI_WriteError);
}

uint8_t TWI_read(uint8_t ack) {
TWCR = (1< while ( !(TWCR & (1< if(TW_STATUS!=TW_MR_DATA_ACK) TWI_SetError(TWI_NoACK);
return TWDR;
}

void TWI_write_buf( uint8_t SLA, uint8_t len, uint8_t *buf )
{

TWI_start();
TWI_write(SLA);
while (len--) TWI_write(*buf++);
TWI_stop();
}

void TWI_read_buf(uint8_t SLA, uint8_t len, uint8_t *buf) {

TWI_start();
TWI_write(SLA + 1);
if((TW_STATUS)!=0x40) TWI_SetError(8);
while (len--) *buf++ = TWI_read( len ? ACK : NACK );
TWI_stop();
}

void TWI_slave_init(uint8_t SLA)
{
TWAR=SLA; // adres slave (unikac zapisu do LSB<-TWGCE )
TWCR=(1<}

uint8_t TWI_read_slave(void)
{
// Clear TWI interrupt flag,Get acknowlegement, Enable TWI
TWCR= (1<while (!(TWCR & (1<while((TW_STATUS)!=TW_SR_DATA_ACK); // Wait for acknowledgement
return TWDR; // Get value from TWDR
}

void TWI_match_read_slave(void) //Function to match the slave address and slave dirction bit(read)
{
while((TW_STATUS)!= TW_SR_SLA_ACK) // Loop till correct acknoledgement have been received
{
// Get acknowlegement, Enable TWI, Clear TWI interrupt flag
TWCR=(1<while (!(TWCR & (1<}
}

void TWI_match_write_slave(void) //Function to match the slave address and slave dirction bit(write)
{
while((TW_STATUS)!= TW_ST_SLA_ACK) // Loop till correct acknoledgement have been received
{
// Get acknowlegement, Enable TWI, Clear TWI interrupt flag
TWCR=(1<while (!(TWCR & (1<}
}

void TWI_write_slave(uint8_t data) // Function to write data
{
TWDR= data; // Fill TWDR register whith the data to be sent
TWCR= (1<while((TW_STATUS) != TW_ST_DATA_ACK); // Wait for the acknowledgement
}

void TWI_write_slave_buf(uint8_t *buf, uint8_t len)
{

while (len--) TWI_write_slave(*buf++);

}[/syntax]

Dla mastera:
[syntax=c]/*
* main.c
*
* Created on: 5 maj 2018
* Author:
*/

// Program for Master Mode

#include
#include "MYUART/myuart.h"
#include "TWI/i2c_twi.h"
#include

uint8_t TWI_Error;

#define LED 1<#define LED_ON PORTB|=LED
#define LED_OFF PORTB&=~LED
#define LED_TOG PORTB^=LED;

int main(void)
{
DDRB=LED;
TWISetBitrate();
uart_init(__UBRR); //inicjalizacja UART

uint8_t buf[8];

inline void TWI_SetError(uint8_t err)
{
TWI_Error=err;
}

unsigned char write=0;
uint8_t len =8;
uint8_t data=1;
uint8_t SLA=0x20;

while(1)
{
_delay_ms(500);
TWI_start();
TWI_write(SLA+write);
TWI_write(data);
TWI_stop();

_delay_ms(500);
TWI_read_buf(SLA,len,buf); // Odczyt bufora ze slave
LED_TOG; //zmien stan diody na przeciwny

//wyswietlanie tablicy
for(int i=0;i<8;i++)
{
uart_putlong(buf[i],10);
uart_puts(" ");
}

}

}

}[/syntax]

Dla slave'a:
[syntax=c]/*
* main.c
*
* Created on: 5 maj 2018
* Author:
*/

// Program for Slave mode
#include
#include
#include "TWI/i2c_twi.h"

uint8_t TWI_Error;

#define LED 1<#define LED_ON PORTD|=LED
#define LED_OFF PORTD&=~LED
#define LED_TOG PORTD^=LED;

int main(void)
{

inline void TWI_SetError(uint8_t err)
{
TWI_Error=err;
}

//LED
DDRD|=LED;

//Zmienne
uint8_t addr=0x20;
uint8_t stan=0;
uint8_t buf[8]={1,2,3,4,5,6,7,8};

//inicjalizacje
TWI_slave_init(addr);

while(1)
{

TWI_match_read_slave();
stan = TWI_read_slave();
if(stan==1) LED_TOG;
_delay_ms(50);

TWI_match_write_slave();
TWI_write_slave_buf(buf,8);

}[/syntax]

Statystyki: Napisane przez igsor96 — 20 maja 2018, o 13:18