ATNEL tech-forum 2014-01-29T22:13:06+01:00 https://forum.atnel.pl/feed.php?f=8&t=5736&mode 2014-01-29T22:13:06+01:00 2014-01-29T22:13:06+01:00 https://forum.atnel.pl/viewtopic.php?t=5736&p=67336#p67336 <![CDATA[AVR jako urządzenie SLAVE dla TWI - obsługa]]>
Krótki wstęp dlaczego wykonałem komunikację między uC wykorzystując magistralę TWI.

Na potrzeby swojej pracy dyplomowej potrzebowałem wykonać komunikację między mikrokontrolerami AVR po TWI (UART już miałem zajęty do komunikacji z komputerem). Jeden uC odpowiedzialny był za obsługę RFM12B oraz komunikację z komputerem. Natomiast drugi stanowił interfejs użytkownika z klawiaturą oraz wyświetlaczem LED.
Dlaczego użyłem pojęć "JEDEN" oraz "DRUGI" zamiast MASTER i SLAVE - ponieważ podczas pracy programu zmieniałem konfigurację danego uC w zależności od potrzeby.
Pracę dyplomową obroniłem już jakiś czas temu, ale dopiero teraz udało mi się znaleźć trochę czasu, żeby poprawić biblioteki. Udostępniam je z tego względu, gdyż w sieci nie znalazłem w naszym języku prostych bibliotek - na czas kiedy pisałem pracę dyplomową, w chwili obecnej mogło się to zmienić.

Pisząc biblioteki wzorowałem się w pewnym stopniu na bibliotekach zawartych na stronie http://www.ermicro.com/blog/?p=1239, oraz książkach Mirka (za które bardzo dziękuję).

Na początku umieszczę pliki biblioteki, a następnie krótko opiszę najważniejsze fragmenty kodu. Całość jest do pobrania w załączniku wraz z przykładowym programem do testowania.

ds_twi.c

[syntax=csharp]/*
* ds_twi.c
*
* Created on: 04-01-2014
* Edited on: 29-01-2014
* Author: Daniel (danielo$)
*
*
*Na podstawie (Based on):
*http://www.ermicro.com
*http://www.ermicro.com/blog/?p=1239
*
*http://www.atnel.pl
*książka:
*Mikrokontrolery AVR Język C - podstawy programowania
*Mirosław Kardaś
*
*Język C. Pasja programowania mikrokontrolerów 8-bitowych )
*Mirosław Kardaś
*
*All rights reserved.
*/

#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <util/twi.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>

#include "ds_twi.h"
//#include "../LCD/HD44780.h"
//#include "../DS_uart/uart.h"

//definicje zmiennych

char TWI_TX_BUF[TWI_TX_SIZE];//bufor w którym znajdują się dane do wysyłki
volatile char TWI_RX_BUF[TWI_RX_SIZE];//bufor odbioru danych
volatile uint8_t i_send;//zmienna, która przechowuje numer wysyłanego bajtu
volatile uint8_t Twi_Rx_head=0;//głowa bufora
uint8_t Twi_Rx_t=0;//zmienna pomocnicza - przepisywanie do bufora odbioru
volatile TTWI_STATUS twi_status_slave;//własnna zmienna - status TWI

//-----definicje funkcji

//!!--!!WSPOLNE dla Master i Slave

void twi_init(uint8_t adr){
/*
* Tylko adres 7bit. najmłodszy określa czy odbiór (0) czy wysyłania (1)
* Gdy adr ma wartość 0, to urządzenie pracuje jako Master. W przeciwnym wypadku jako Slave
*/

if(!adr){
//Master

/*
* TWSR = 0x00;preskaler
* TWBR = 12;wartość bit rate
*
*/

#if F_CPU<=2000000
TWSR = 0x00;
TWBR = 2;
/*
* dla 1MHz:SCL_freq = 1000000 / (16 + 2 * 2 * 1) = 50kHz
* dla 2MHz:SCL_freq = 2000000 / (16 + 2 * 2 * 1) = 100kHz
*/
#elif F_CPU==4000000
TWSR = 0x00;
TWBR = 12;//100kHz
#elif F_CPU==6000000
TWSR = 0x00;
TWBR = 22;//100kHz
#elif F_CPU==8000000
TWSR = 0x00;
TWBR = 32;//100kHz
#elif F_CPU==10000000
TWSR = 0x00;
TWBR = 42;//100kHz
#elif F_CPU<=12000000
TWSR = 0x00;
TWBR = 52;//100kHz
#elif F_CPU==14000000
TWSR = 0x00;
TWBR = 62;//100kHz
#elif F_CPU<=16000000
TWSR = 0x00;
TWBR = 72;//100kHz
#elif F_CPU==18000000
TWSR = 0x00;
TWBR = 82;//100kHz
#endif

}else{
//Slave
TWAR = adr & 0xFE;//wpisanie adresu
TWDR = 0x00;//rejestr danych wypełniamy 0

TWCR |= (1<<TWINT) | (1<<TWEA) | (1<<TWEN) | (1<<TWIE);// Włączenie przerwania od TWI (TWINT, TWIE), włączenie potwierdzenia (TWEA), włączeni TWI (TWEN)


#if TWI_GCALL
//gdy ma reagować na adres 0x00
TWAR |= (1<<TWGCE);
#endif

}

}

//!!--!!dla MASTER

void twi_start(void){//sprzętowa sekwencja start

TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);

while(!(TWCR & (1<<TWINT)));

}

void twi_stop(void){//sprzętowa sekwencja stop

TWCR = (1<<TWINT) | (1<<TWSTO) | (1<<TWEN);

while(!(TWCR & (1<<TWSTO)));

}

void twi_send(uint8_t data){
//wysłanie pojedyńczego bajtu

TWDR = data;
TWCR = (1<<TWINT) | (1<<TWEN);

while(!(TWCR & (1<<TWINT)));

}

uint8_t twi_read(uint8_t ack){
//odebranie pojedyńczego bajtu

TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);
while(!(TWCR & (1<<TWINT)));

return TWDR;
}

uint8_t twi_send_to_device(uint8_t address, uint8_t registry, char *send_data){
//pod wskazany adres urządzenia wysyłany jest ciąg znaków do podanego rejestru

uint8_t twi_stat = 0;//zmienna w której przechowywany jest aktualny status TWI

// sekwencja start
twi_start();
twi_stat = TW_STATUS;//zapisanie statusu TWI do zmiennej twi_start

if( (twi_stat != TW_START) && (twi_stat != TW_REP_START) )
return twi_stat | 0x04;

//wywołanie urządzenia z ustawionym zapisem (najmłodszy bit adresu ustawiony na 0)
twi_send(address & 0xFE);
twi_stat = TW_STATUS;

if( (twi_stat == TW_MT_SLA_NACK) || (twi_stat == TW_MT_ARB_LOST) || (twi_stat != TW_MT_SLA_ACK) )//0x20, 0x38, 0x18
return twi_stat | 0x04;

//wysłanie do urządzenia bitu kontrolnego bądź rejestr - informacje potrzebne do odbioru danych

twi_send(registry);
twi_stat = TW_STATUS;

if( (twi_stat == TW_MT_ARB_LOST) || (twi_stat != TW_MT_DATA_ACK)) // 0x38, 0x28
return twi_stat | 0x04;

else if (twi_stat == TW_MT_DATA_NACK){//0x30

twi_stop();
twi_stat = TW_STATUS;
return twi_stat | TW_MT_DATA_NACK | 0x04;
}


//wysyłanie danych

while(*send_data){
twi_send(*send_data++);
twi_stat = TW_STATUS;

if( (twi_stat == TW_MT_DATA_NACK) || (twi_stat == TW_MT_ARB_LOST) || (twi_stat != TW_MT_DATA_ACK)) //0x30, 0x38, 0x28
return twi_stat | 0x04;

else if (twi_stat == TW_MT_DATA_NACK){//0x30

twi_stop();
twi_stat = TW_STATUS;
return twi_stat | TW_MT_DATA_NACK | 0x04;
}

}

twi_stop();

return 0;
}

uint8_t twi_read_from_device(uint8_t address, uint8_t registry, uint8_t nr_data, char *read_data){
/* z wskazanego adresu urządzenia oraz rejestru odczytywany jest okreslony ciąg znaków
* address - adres urządzeniaXXXX XXX0
* registry - rejestr, ramka kontrolna
* nr_data - ilosc odczytywanych danych// 0 - jesli ilosc danych przesyłana jest jako tekst w 2 pierwszych bajtach
* read_data - odczytane dane
*/

char len_data[] = {"00"};//dlugosc odbieranej ramki
uint8_t twi_stat=0;//status magistrali twi

twi_start();
twi_stat = TW_STATUS;

if( (twi_stat != TW_START) && (twi_stat != TW_REP_START) )
return twi_stat | 0x04;

//wywołanie urządzenia z ustawionym zapisem (najmłodszy ustawiony na 0)
twi_send(address & 0xFE);
twi_stat = TW_STATUS;

if( (twi_stat == TW_MT_DATA_NACK) || (twi_stat == TW_MT_ARB_LOST) || (twi_stat != TW_MT_SLA_ACK) )//0x20, 0x38, 0x18
return twi_stat | 0x04;

//wysłanie do urządzenia bitu kontrolnego bądź rejestr - informacje potrzebne do odbioru danych
twi_send(registry);
twi_stat = TW_STATUS;

if( (twi_stat == TW_MT_DATA_NACK) || (twi_stat == TW_MT_ARB_LOST) || (twi_stat != TW_MT_DATA_ACK) )//0x30, 0x38, 0x28
return twi_stat | 0x04;

//stop

twi_stop();
twi_stat = TW_STATUS;

#if TWI_DELAY_REP_START//jeżeli wartość została wpisana
//opóźnienie wywołania startu
_delay_ms(TWI_DELAY_REP_START);

#endif


//powtórzenie startu
twi_start();
twi_stat = TW_STATUS;

if( (twi_stat != TW_START) && (twi_stat != TW_REP_START) )
return twi_stat | 0x04;

//powtórne wywołanie urzadzenia, lecz z zamiarem odczytu danych

twi_send( (address & 0xFE) | 0x01 );
twi_stat = TW_STATUS;

if( (twi_stat == TW_MR_SLA_NACK) || (twi_stat == TW_MR_ARB_LOST) || (twi_stat != TW_MR_SLA_ACK) ) //0x48, 0x38, 0x40
return twi_stat | 0x04;

//ilość odbieranych danych

if(nr_data){
//stała zdefiniowana wartość
while(--nr_data){
*read_data++ = twi_read(ACK);
twi_stat = TW_STATUS;
if( (twi_stat == TW_MR_ARB_LOST) || (twi_stat != TW_MR_DATA_ACK) )//0x38, 0x50
return twi_stat | 0x04;
}

*read_data++ = twi_read(NACK);
twi_stat = TW_STATUS;
if( twi_stat != TW_MR_DATA_NACK)
return twi_stat | 0x04;

}else{
//pierwsze dwa bajty danych zawierają ilość odbieranych danych
uint8_t i=0;
for( i=0 ; i < 2 ; i++){
len_data[i] = twi_read(ACK);
twi_stat = TW_STATUS;
if( (twi_stat == TW_MR_ARB_LOST) || (twi_stat != TW_MR_DATA_ACK) )//0x38, 0x50
return twi_stat | 0x04;
}

//konwersja z ANSI na typ uint8_t
nr_data = atoi(len_data);

//odbieranie określonej ilości danych
while(--nr_data){
//odbiór z potwierdzeniem
*read_data++ = twi_read(ACK);
twi_stat = TW_STATUS;
if( (twi_stat == TW_MR_ARB_LOST) || (twi_stat != TW_MR_DATA_ACK) )//0x38, 0x50
return twi_stat | 0x04;
}

//odbiór bez potwierdzenia
*read_data++ = twi_read(NACK);
twi_stat = TW_STATUS;
if( twi_stat != TW_MR_DATA_NACK)
return twi_stat | 0x04;
}

//stop
twi_stop();

return 0;
}


//!!--!!dla SLAVE

//przerwanie od TWI

ISR(TWI_vect){

switch(TW_STATUS){

//wysyłanie danych
case TW_ST_SLA_ACK://0xA8Own SLA+R has been received, ACK has been returned
case TW_ST_ARB_LOST_SLA_ACK://0xB0Arbitration lost in SLA+R/W, own SLA+R has been received, ACK has been returned
case TW_ST_DATA_ACK://0xB8Data byte in TWDR has been transmitted, ACK has been received

//wpisanie do rejestru danych z bufora wysyłania
TWDR = TWI_TX_BUF[i_send++];
TWCR |= (1<<TWINT);
if(i_send == TWI_TX_SIZE) i_send=0;//jeżeli skończyły się dane w buforze, a master dalej odbiera, slave wysyła dane od początku
break;

case TW_ST_DATA_NACK://0xC0Data byte in TWDR has been transmitted, NOT ACK has been received

//odebrano NACK - koniec odbierania danych
i_send = 0;
twi_status_slave.twi_ss_end_send=1;//zakończono wysyłanie danych
TWCR |= (1<<TWINT);

break;

//odbiór danych
//własny adres
case TW_SR_SLA_ACK://0x60SLA+W received, ACK has been returned
case TW_SR_ARB_LOST_SLA_ACK://0x68Arbitration lost in SLA+R/W

//odebrano własny adres
twi_status_slave.twi_sr_own_adr=1;
TWCR |= (1<<TWINT);
break;

//general call-adres 0x00
#if TWI_GCALL
case TW_SR_GCALL_ACK://0x70general call address has been received , ACK has been returned
twi_status_slave.twi_sr_gen_call=1;//odebrano GC
TWCR |= (1<<TWINT)
break;
#endif
case TW_SR_DATA_ACK://0x80address witn own SLA+w, data has been received, ACK has been returned
case TW_SR_GCALL_DATA_ACK://0x90address - general call, data has been returned, ack has been returned
if(!twi_status_slave.twi_sr_rec_data)//jeżeli nie jest jeszcze ustawiona zmienna
twi_status_slave.twi_sr_rec_data=1;//odbiór danych

TWI_RX_BUF[Twi_Rx_head++] = TWDR;//zapis odebranych danych do bufora

if(Twi_Rx_head == TWI_RX_SIZE-1) {//sprawdzenie czy odebrane dane będą nadpisywane w buforze. o 1 mniejszy bo jeszcze znak końca linii (13)
twi_status_slave.twi_sr_overwrite=1;//nadpisywanie danych
Twi_Rx_head = 0;//ustawienie początku bufora
}

TWCR |= (1<<TWINT);
break;

case TW_SR_STOP://0xA0STOP or repeated start has been received

twi_status_slave.twi_sr_end_received=1;//zakończono odbiór

TWCR |= (1<<TWINT);

TWI_RX_BUF[Twi_Rx_head++] = 13;//koniec linii
Twi_Rx_head = 0;//ustawienie początku bufora
break;

default:
TWCR |= (1<<TWINT);//clear twint flag

}

}

uint16_t twi_status_sl(void){
//funkcja zwracająca status obsługi TWI dla slave
return twi_status_slave.bool;
}

uint8_t twi_status(void){
//funkcja zwracająca status TWI - sprzętowe procedury. Rejestr TWSR
return TW_STATUS;
}

inline int get_char(void){//pobieranie bajtu z bufora cyklicznego
return TWI_RX_BUF[Twi_Rx_t++];//zwrócenie danych znajdujących się w komórce
}

char *twi_get_data(char *s){//pobieranie ramki danych z bufora cyklicznego
char c;
char *wsk = s;//kopia zapasowa wskaźnika przekazanych danych (początku bufora)

while((c=get_char())){//pobranie pojedyńczego znaku, wpisanie do c i sprawdzenie czy jest różna od 0
if(c == 13 || c < 0)break;//jeżeli jest znak CR lub -1 (brak danych w buforze) koniec pętli
*s++ = c;//wpisanie do bufora pod adres wskaźnika danych 'c' i inkrementacja wskaźnika - następny adrs
}//while

*s = 0;//zakończenie odczytanej linijki poprzez znak 0 - NULL- bo to C-string

Twi_Rx_t=0;

return wsk;//odczytane dane są w s i zwracane poprzez wsk
}

void insert_data(char *s){//wpisanie danych do bufora nadawczego z twi. Dane wysyłające muszą posiadać na końcu wartosc 0x00

#if TWI_SLAVE_SEND_LENGTH//w zależności czy w pierwszych dwóch bajtach danych wysyłanych ma znajdować się ilość wysyłanych danych
uint16_t i_insert=2;
#else//czy nie
uint16_t i_insert=0;
#endif
char c= *s;

//przepisywanie danych do bufora wysyłania
while(c){
if( c==13 || c < 0 ) break;
TWI_TX_BUF[i_insert++] = c;
c = *++s;
if(i_insert == TWI_TX_SIZE-1) break;
}

TWI_TX_BUF[i_insert] = 13;//koniec danych w buforze oznaczony jako znak CR

#if TWI_SLAVE_SEND_LENGTH//wpisanie do dwóch pierwszych bajtów bufora ilości wysyłanych danych
i_insert=-2;
TWI_TX_BUF[0] = i_insert/10 + 0x30;
TWI_TX_BUF[1] = i_insert%10 + 0x30;
#endif
}

//Zdarzenia dotyczace obsługi TWI

//wskaźnik do funkcji zwrotnej dla odbioru danych w TWI_event
static void (*twi_event_received_callback)(char *received_bufor);

//rejestracja funkcji zwrotnej dla odbioru danych
void register_twi_event_received(void (*callback)(char *received_bufor)){
twi_event_received_callback = callback;
}

//zdarzenie obsługi TWI
void TWI_EVENT(char *twi_event_bufor){

//odbiór
if(twi_status_slave.twi_sr_end_received){//jeżeli skończono odbiór
if(twi_event_received_callback){//jeżeli funkcja została zarejestrowana
twi_get_data(twi_event_bufor);//pobranie danych z bufora i wpisanie do twi_even_bufor
(*twi_event_received_callback)(twi_event_bufor);//wywołanie funkcji obsługi zdarzenia
twi_status_slave.bool &= 0xFF00;//wyzerowanie statusów informujących o odbiorze danych
}//received callback
//end received

}else if(twi_status_slave.twi_ss_end_send){//zakończono wysyłanie danych
twi_status_slave.bool &= 0x00FF;//wyzerowanie statusów informujących o wysyłaniu danych
//funkcja która reaguje na zakończenie wysyłania danych<- można ją tutaj dodać
}


}

void twi_send_data(char *twi_send_data){//zewnętrzna funkcja do wpisywania danych które mają zostać odesłane do MASTER
insert_data(twi_send_data);
}


//ostrzeżenie w przypadku gdy ustawiona ilość danych rejestru jest większa od bufora odbioru
#if TWI_REC_REG_DATA >= TWI_RX_SIZE

#error "Za mała wielkość bufora odbioru TWI. Zwiększ wartość TWI_RX_SIZE"

#endif[/syntax]


ds_twi.h

[syntax=csharp]/*
* ds_twi.h
*
* Created on: 04-01-2014
* Edited on: 29-01-2014
* Author: Daniel (danielo$)
*
*
*Na podstawie (Based on):
*http://www.ermicro.com
*http://www.ermicro.com/blog/?p=1239
*http://www.atnel.pl
*książka:
*Mikrokontrolery AVR Język C - podstawy programowania
*Mirosław Kardaś
*
*Język C. Pasja programowania mikrokontrolerów 8-bitowych
*Mirosław Kardaś
*
*All rights reserved.
*/

#ifndef DS_TWI_H_
#define DS_TWI_H_

#define TWI_SLAVE_ADDRESS0x42//litera B

//#define TWI_TIMEOUT1//do wykorzystania w przyszłości
#define TWI_DELAY_REP_START 10//czas w ms, po którym następuje powtórzenie startu dla odbierania danych. UWAGA!! opóźnienie realizowane przy pomocy funkcji _delay_ms

#define TWI_GCALL0//Czy mikrokontroler ma reagować na General Call - adres 0x00. TYLKO dla pracy jako Slave

#define TWI_TX_SIZE32//rozmiar tablicy wysyłanych danych
#define TWI_RX_SIZE16//rozmiar bufora odbioru-najlepiej wielokrotnosci dwojki

#define TWI_SLAVE_SEND_LENGTH 1//układ slave wysyła w pierwszych dwóch bajtach długość danych do odebrania przez MASTER

#define TWI_REC_REG_DATA 1//ilość danych w buforze to adres rejestru

//-----!!Nie zmieniać

#define ACK 1
#define NACK 0
//#define MAX_TRY 50//do wykorzystania w przyszłości

#define TWI_WRITE1
#define TWI_READ0

#define MASTER 1
#define SLAVE 0

//definicja własnej zmiennej
typedef union{
uint16_t bool;
struct{
//--odbiór
uint16_t twi_sr_own_adr:1;//1 - odebrano własny adres
uint16_t twi_sr_gen_call:1;//2- odebrano general call -0x00
uint16_t twi_sr_rec_data:1;//3- odbiór danych
uint16_t twi_sr_end_received:1;//4- zakończono odbiór
uint16_t twi_sr_overwrite:1;//5- występuje nadpisywanie danych
uint16_t twi_sr_rec_error:1;//6- błędny odbiór
//7
//8

//--wysyłanie
uint16_t twi_ss_end_send:1;//9- wysłano dane
//10
//11
//12
//13
//14
//15
//16
};
}TTWI_STATUS;

//-----deklaracje zmiennych
extern volatile TTWI_STATUS twi_status_slave;//status twi
extern volatile char TWI_RX_BUF[TWI_RX_SIZE];//bufor odbioru

//-----deklaracje funkcji
void twi_init(uint8_t adr);//Tylko 7bit. Gdy adr jest 0, to urządzenie pracuje jako Master. W przeciwnym wypadku jako Slave
void twi_start(void);//sekwencja start
void twi_stop(void);//sekwencja stop
void twi_send(uint8_t data);//wysłanie pojedyńczego bajtu
uint8_t twi_read(uint8_t ack);//odebranie pojedyńczego bajtu
uint8_t twi_send_to_device(uint8_t address, uint8_t registry, char *send_data);//pod wskazany adres urządzenia wysyłany jest ciąg znaków do podanego rejestru
uint8_t twi_read_from_device(uint8_t address, uint8_t registry, uint8_t nr_data, char *read_data);//z wskazanego adresu urządzenia oraz rejestru odczytywany jest ciąg znaków

uint16_t twi_status_sl(void);//funkcja zwracająca status obsługi TWI dla slave
uint8_t twi_status(void);//funkcja zwracająca status TWI - sprzętowe procedury. Rejestr TWSR

char *twi_get_data(char *s);//pobieranie ramki danych z bufora cyklicznego

//Zdarzenia dotyczące obsługi TWI

void TWI_EVENT(char *twi_event_bufor);//zdarzenie TWI
void register_twi_event_received(void (*callback)(char *received_bufor));//rejestracja funkcji obsługi zdarzenia TWI

void twi_send_data(char *twi_send_data);//wpisanie danych które mają zostać wysłane przez TWI do bufora TWI_TX_BUF

#endif /* DS_TWI_H_ */[/syntax]

Bibliotekę starałem wykonać się tak, aby była ona uniwersalna. Dlatego też, ramkę danych wykonałem na podstawie not katalogowych urządzeń komunikujących się za pomocą I2C.

Ramka danych ma następujący format:
- dla zapisu w urządzeniu Slave

Obrazek

- dla odczytu z urządzenia Slave

Obrazek

Podczas odczytu danych z urządzenia SLAVE, nie jest konieczne wysyłanie do SLAVE rejestru. Można od razu rozpocząć odbiór danych.
W przypadku wysłania rejestru, należy ustawić czas opóźnienia T wysłania ponownego startu. Czas T powinien być na tyle długi, aby program zdążył przygotować dane.



Konfiguracja.

Konfiguracji dokonujemy w pliku ds_twi.h do komentarza "nie zmieniać".

Adres jaki nasze urządzenie SLAVE będzie posiadało. Ja wykorzystywałem litery jako adres z tą uwagą, aby najmłodszy bit miał wartość 0. Na najmłodszym bicie przesyłana jest informacja czy następuje odczyt czy zapis do SLAVE.
[syntax=csharp]#define TWI_SLAVE_ADDRESS0x42//litera B[/syntax]

Podczas odczytu z urządzenia SLAVE może występować opóźnienie w celu przygotowania danych do odesłania (np. w celu wykonania pomiarów, bądź odczytu danych z innych urządzeń) - czas podawany jest w ms.
[syntax=csharp]#define TWI_DELAY_REP_START 10//czas w ms, po którym następuje powtórzenie startu dla odbierania danych. UWAGA!! opóźnienie realizowane przy pomocy funkcji _delay_ms[/syntax]

Układ może również reagować na ogólne wywołanie za pomocą adresu 0x00 (General Call)
[syntax=csharp]#define TWI_GCALL0//Czy mikrokontroler ma reagować na General Call - adres 0x00. TYLKO dla pracy jako Slave[/syntax]

Rozmiary bufora obioru, oraz wysyłania.
[syntax=csharp]#define TWI_TX_SIZE32//rozmiar tablicy wysyłanych danych
#define TWI_RX_SIZE16//rozmiar bufora odbioru-najlepiej wielokrotnosci dwojki[/syntax]

Dane odbierane przez układ Master mogą mieć różną długość - w takim przypadku w pierwszych 2 bajtach przesyłana jest liczba w kodzie ASCII informująca o ilości danych. Gdy ilość danych jest stała, TWI_SLAVE_SEND_LENGTH należy ustawić na 0, w przeciwnym razie 1.
[syntax=csharp]#define TWI_SLAVE_SEND_LENGTH 1//układ slave wysyła w pierwszych dwóch bajtach długość danych do odebrania przez MASTER[/syntax]

Funkcje, dla użytkownika:

Inicjalizacja TWI. Gdy układ ma pracować jako MASTER, argument przesyłany do funkcji powinien mieć wartość 0. Natomiast gdy urządzenie ma pracować jako SLAVE, argumentem jest adres tego urządzenia.
[syntax=csharp]void twi_init(uint8_t adr);//Tylko 7bit. Gdy adr jest 0, to urządzenie pracuje jako Master. W przeciwnym wypadku jako Slave[/syntax]

Funkcje do wykorzystania w przypadku, gdy ramka danych zdefiniowana w następnych funkcjach nie pokrywa się z ramką danych obsługiwanego urządzenia.
[syntax=csharp]void twi_start(void);//sekwencja start
void twi_stop(void);//sekwencja stop
void twi_send(uint8_t data);//wysłanie pojedyńczego bajtu
uint8_t twi_read(uint8_t ack);//odebranie pojedyńczego bajtu[/syntax]

Wysyłanie danych z MASTER do SLAVE. Pod wskazany adres (address) urządzenia wysyłany jest ciąg znaków (send_data) do podanego rejestru (registry).
[syntax=csharp]uint8_t twi_send_to_device(uint8_t address, uint8_t registry, char *send_data);//pod wskazany adres urządzenia wysyłany jest ciąg znaków do podanego rejestru[/syntax]

Odczyt danych z SLAVE przez MASTER. Z podanego adresu urządzenia (address), oraz rejestru (registry) odczytywana jest odpowiednia ilość danych (nr_data) i zapisywana do bufora read_data. W przypadku gdy ilość odczytywanych danych jest zmienna argument nr_data musi mieć wartość 0.
[syntax=csharp]uint8_t twi_read_from_device(uint8_t address, uint8_t registry, uint8_t nr_data, char *read_data);//z wskazanego adresu urządzenia oraz rejestru odczytywany jest ciąg znaków[/syntax]

Funkcje umożliwiające odczytanie statusu magistrali TWI oraz obsługi TWI dla SLAVE
[syntax=csharp]uint16_t twi_status_sl(void);//funkcja zwracająca status obsługi TWI dla slave
uint8_t twi_status(void);//funkcja zwracająca status TWI - sprzętowe procedury. Rejestr TWSR[/syntax]

Obsługa zdarzeń TWI, oraz rejestracja odpowiednich funkcji do obsługi tego zdarzenia.
[syntax=csharp]void TWI_EVENT(char *twi_event_bufor);//zdarzenie TWI
void register_twi_event_received(void (*callback)(char *received_bufor));//rejestracja funkcji obsługi zdarzenia TWI[/syntax]

Dane które mają zostać przygotowane do wysyłania są przesyłane jako argument funkcji:
[syntax=csharp]void twi_send_data(char *twi_send_data);//wpisanie danych które mają zostać wysłane przez TWI do bufora TWI_TX_BUF[/syntax]

Odebrany rejestr przechowywany jest w pierwszych komórkach bufora odbioru. Przygotowanie danych do wysłania można wykonać po odebraniu rejestru w zdarzeniu do obsługi TWI, bądź gdziekolwiek w programie gdy jest taka potrzeba.

Przykładowe zastosowanie zdarzenia TWI dla układu SLAVE:

[syntax=csharp]#include "DS_TWI/ds_twi.h"
void reakcja_odbior(char *buffor);

int main(void)
{
LCD_init();
twi_init(TWI_SLAVE_ADDRESS);
register_twi_event_received(reakcja_odbior);

sei();//globalne odblokowanie przerwań
while (1)
{
TWI_EVENT(bufor);
}
}

// ----- definicje funkcji
void reakcja_odbior(char *buffor){
switch (buffor[0])
{
case 'o'://odbiór
LCD_local(0,0);
LCD_text(buffor);
break;

case 'w'://wysyłanie
twi_send_data("wyslano przez TWI");
break;

default:
break;
}
}[/syntax]

Poszczególne fragmenty kodu opatrzone są komentarzami.
W przypadku jakichkolwiek pytań, należy pytać!

Jeżeli w jakimś miejscu pojawiły się jakieś błędy - też pisać. Każdy może się pomylić.

W przyszłości mam zamiar wykonać timeout w celu zabezpieczenia programu tam gdzie zostały zastosowane pętle while(), oraz wykonać szerszą obsługę magistrali TWI w układzie SLAVE (np. w przypadku nie odebrania danych, bądź powtórne wysłania danych).

Proszę o wyrozumiałość;)

P.S.

Przykład zastosowania obejmuje dwa mikrokontrolera pierwszy MASTER - ATmega 8 połączona z komputerem przez uart. Wysyłając wartość "1" przez terminal (19200 bps) wysyłane jest polecenie odbioru danych. Natomiast wpisanie dowolnego krótkiego tekstu (około 8 znaków) do terminala i wciśnięcie enter zapisuje dane w SLAVE. Układ taktowany wewnętrznym kwarcem 4MHz.
Układ Slave to Atmega32 taktowana zewnętrznym kwarcem 4MHz. Podłączony jest do niej wyświetlacz lcd 2 wierszowy. Odebrane dane z Master są wyświetlane na LCD.

Rezystory podciągające magistralę o wartości 4,7k znajdują się przy Master.

Jeżeli ktoś mógłby przetestować działanie tych bibliotek na innych AVR byłbym wdzięczny.

P.S. 2

Jeżeli znajdę trochę więcej czasu to postaram się dokładniej opisać sposób komunikacji oraz działania tych bibliotek i umieścić w jakimś pdf - w bliżej nieokreślonym czasie.

Pozdrawiam

Statystyki: Napisane przez danielos — 29 sty 2014, o 22:13

]]>