Więc możemy powoli zakończyć ....
Jak poprzednio wspomniałem jedna z zalet magistrali CAN (lub bardziej precyzyjnie to określimy -> kontrolera CAN) jest
fakt umożliwiający filtrowanie wiadomości. Nasz kontroler posiada 2 filtry dla bufora 0 i jeszcze 4 na buforze 1. Dzięki
temu wiadomości które nie są przeznaczone dla naszego urządzenia , mogą być "odfiltrowane" bez użycia Mikrokontrolera.
Częściowo przedstawię zależności filtrów w tabelce :
Jak widzicie poszczególne bity ID Wiadomości są używane do filtrowania tylko wtedy gdy jest ustawiony odpowiedni Bit w MASCE.
Jeśli więc chcecie po testować otrzymywanie wszystkich komunikatów, wystarczy w masce ustawić wszystkie bity na dominujące,
czyli 0. Kontroler będzie wtedy wiedział że wszystkie wiadomości niezależnie od ID zostaną przekazane do bufora.
Popatrzcie tak wygląda kompletny kod inicjalizacji dla naszego MSP2515:
[syntax=c]void mcp2515_init(void)
{
// Inicjalizacja SPI
spi_init();
// Wprowadzenie MCP w tryb konfiguracji
PORT_CS &= ~(1<<P_CS);
spi_putc( SPI_RESET );
_delay_ms(1);
PORT_CS |= (1<<P_CS);
// Trzeba dać chwilkę czasu by MCP mogło się ustawić
_delay_ms(10);
/*
* Dostosowanie Bit Timings
*
* Fosc = 16MHz
* BRP = 7
* TQ = 2 * (BRP + 1) / Fosc (=> 1 uS)
*
* Sync Seg = 1TQ
* Prop Seg = (PRSEG + 1) * TQ = 1 TQ
* Phase Seg1 = (PHSEG1 + 1) * TQ = 3 TQ
* Phase Seg2 = (PHSEG2 + 1) * TQ = 3 TQ
*
* Bus speed = 1 / (Total # of TQ) * TQ
* = 1 / 8 * TQ = 125 kHz
*/
// BRP = 7
mcp2515_write_register( CNF1, (1<<BRP0)|(1<<BRP1)|(1<<BRP2) );
// regulacja fazy dla SEG1
mcp2515_write_register( CNF2, (1<<BTLMODE)|(1<<PHSEG11) );
// Wake-up wyłączony , dopasowanie fazy SEG2
mcp2515_write_register( CNF3, (1<<PHSEG21) );
// Właczenie przerwania Rx Bufor
mcp2515_write_register( CANINTE, (1<<RX1IE)|(1<<RX0IE) );
// Bufor 0 : Odbieranie wszystkich wiadomości
mcp2515_write_register( RXB0CTRL, (1<<RXM1)|(1<<RXM0) );
// Bufor 1 : Odbieranie wszystkich wiadomości
mcp2515_write_register( RXB1CTRL, (1<<RXM1)|(1<<RXM0) );
// Wszystkie bity MASKI ustawiamy na 0
mcp2515_write_register( RXM0SIDH, 0 );
mcp2515_write_register( RXM0SIDL, 0 );
mcp2515_write_register( RXM0EID8, 0 );
mcp2515_write_register( RXM0EID0, 0 );
mcp2515_write_register( RXM1SIDH, 0 );
mcp2515_write_register( RXM1SIDL, 0 );
mcp2515_write_register( RXM1EID8, 0 );
mcp2515_write_register( RXM1EID0, 0 );
// Ustawienia funkcji PINÓW IO
// wyłaczenie Pinów RXnBF --> ustawienie na HIS (High Impedance State)
mcp2515_write_register( BFPCTRL, 0 );
// TXnRTS ustawiamy jako wejścia
mcp2515_write_register( TXRTSCTRL, 0 );
// Przełączenie MCP w tryb offsetowy (normalny tryb pracy)
mcp2515_bit_modify( CANCTRL, 0xE0, 0);
}[/syntax]
Oczywiście można to zrobić bardziej elegancko i wysłać cały zestaw danych prosto do rejestrów, ale
byłoby to mało czytelne. Jak więc widzicie doszliśmy do takiego momentu naszego wywodu , w którym
już niewiele nam brakuje by wysłać pierwszą wiadomość przez CAN. Żeby nie utrudniać zajmiemy się
wysłaniem wiadomości z ID 11bit. Oczywiście jak będziecie chcieli bez problemu przerobicie sobie
do ID rozszerzonych czyli 29 bitów. W tym miejscu wypadało by jednak bym tradycyjnie coś namieszał
Co zresztą uczynię z premedytacją i pełną świadomością faktu że jest to moja złośliwość
Więc bez dalszego owijania w bawełnę czy coś innego powiem wam w tajemnicy, że nasz malutki kontroler
jakim jest dzielny MCP2515 ma aż 3 bufory nadawania i do tego z niezależnymi ustawieniami priorytetu.
Dzięki czemu nasze zadanie czyli wysłanie wiadomości jest banalnie proste i sprowadza się tylko
do rejestracji odpowiedniego ID, wypełnienia pola danych i już ... można wysłać wiadomość
Oczywiście jest jednak jedno małe ale .....
mianowicie są trzy różne sposoby by wysłać wiadomość
-- przez ustawienie odpowiednich bitów w rejestrze TXBnCTRL
-- przez wysłanie poleceń RTS po SPI
-- ustawienie stanu niskiego dla odpowiednich bitów TXnRTS buforów
Przykład wysłania wiadomości może być następujący:
[syntax=c]// Wysyłamy wiadomość z bufora0
// 2 bajty danych (0x04, 0xf3)
// ID: 0x0123
uint16_t id = 0x0123;
// ustawiamy Bufor na najwyższy priorytet
mcp2515_bit_modify( TXB0CTRL, (1<<TXP1)|(1<<TXP0), (1<<TXP1)|(1<<TXP0) );
// ID
mcp2515_write_register(TXB0SIDH, (uint8_t) (id>>3));
mcp2515_write_register(TXB0SIDL, (uint8_t) (id<<5));
// Długość wiadomości + zestaw bitów RTR
mcp2515_write_register(TXB0DLC, 2);
// Dane
mcp2515_write_register(TXB0D0, 0x04);
mcp2515_write_register(TXB0D1, 0xf3);
//Można wysyłać ....
PORT_CS &= ~(1<<P_CS);
spi_putc(SPI_RTS | 0x01);
PORT_CS |= (1<<P_CS);[/syntax]
Jakoś poszło no nie
ale to mało elegancki sposób takie pakowanie bezpośrednie bardziej optymalne jest wysyłanie do bufora określonych danych co też umożliwi nam wymianę danych między funkcjami i dlatego w tym celu lepiej pakować dane
w struktury
np. tak:[syntax=c]typedef struct
{
uint16_t id;
uint8_t rtr;
uint8_t length;
uint8_t data[8];
} CANMessage;
// Utwórz nową wiadomość
CANMessage message;
// Dane
message.id = 0x0123;
message.rtr = 0;
message.length = 2;
message.data[0] = 0x04;
message.data[1] = 0xf3;
// Wyślij wiadomość
can_send_message(&message);[/syntax]
Prawda że lepiej to wygląda ?? teraz wystarczy strukturę przekazać do Funkcji wysyłającej :
[syntax=c]void can_send_message(CANMessage *p_message)
{
uint8_t length = p_message->length;
// ID Wiadomości
mcp2515_write_register(TXB0SIDH, (uint8_t) (p_message->id>>3));
mcp2515_write_register(TXB0SIDL, (uint8_t) (p_message->id<<5));
// RTR "Remote Transmit Request"
if (p_message->rtr)
{
// wiadomość RTR ma długość , ale nie zawiera danych
// Ustawienie długości + RTR
mcp2515_write_register(TXB0DLC, (1<<RTR) | length);
}
else
{
// Ustawienie długości komunikatu
mcp2515_write_register(TXB0DLC, length);
// Czas na DANE
for (uint8_t i=0;i<length;i++) {
mcp2515_write_register(TXB0D0 + i, p_message->data[i]);
}
}
// Wszystko pasuje można wysyłać wiadomość
PORT_CS &= ~(1<<P_CS);
spi_putc(SPI_RTS | 0x01);
PORT_CS |= (1<<P_CS);
}[/syntax]
Oczywiście można funkcje bardziej rozbudować , i używać dzięki temu do wysyłania pierwszego wolnego buforu
w którym bit TXREQ w rejestrze TXBnCTRL gdzie n to numer bufora. Jest tęż to łatwiejsze dzięki dodatkowym poleceniom
SPI
jaką jest np. komenda RSI (Read Status Instruction).W przeciwieństwie jednak do powyższych przykładów teraz nie będziemy korzystać z "prefabrykowanych" funkcji rejestrów,
dodatkowo przyspieszymy transmisję wysyłając dane bezpośrednio na SPI, które następnie będą przechowywane
w odpowiednich rejestrach MCP2515.
[syntax=c]uint8_t can_send_message(CANMessage *p_message)
{
uint8_t status, address;
// Odczyt statusu MCP2515
PORT_CS &= ~(1<<P_CS);
spi_putc(SPI_READ_STATUS);
status = spi_putc(0xff);
spi_putc(0xff);
PORT_CS |= (1<<P_CS);
/* Znaczenie bitów statusu:
*
* Bit Funkcja
* 2 TXB0CNTRL.TXREQ
* 4 TXB1CNTRL.TXREQ
* 6 TXB2CNTRL.TXREQ
*/
if (bit_is_clear(status, 2)) {
address = 0x00;
}
else if (bit_is_clear(status, 4)) {
address = 0x02;
}
else if (bit_is_clear(status, 6)) {
address = 0x04;
}
else {
// Wszystkie bufory są w użyciu --- nie można wysłać wiadomości
return 0;
}
PORT_CS &= ~(1<<P_CS); // CS = Low
spi_putc(SPI_WRITE_TX | address);
//11bitowego ID
spi_putc((uint8_t) (p_message->id>>3));
spi_putc((uint8_t) (p_message->id<<5));
//29bitowe ID
spi_putc(0x00);
spi_putc(0x00);
uint8_t length = p_message->length;
if (length > 8) {
length = 8;
}
// czy pojawił się RTR -- "Remote Transmit Request" ?
if (p_message->rtr)
{
// Ustawienie długości + RTR
spi_putc((1<<RTR) | length);
}
else
{
//ustawienie długości komunikatu
spi_putc(length);
// Dane
for (uint8_t i=0;i<length;i++) {
spi_putc(p_message->data[i]);
}
}
PORT_CS |= (1<<P_CS); // CS = High
asm volatile ("nop");
// Wysyłamy komunikaty do ...
// 3 ostatnie bity w poleceniu RTS określają który bufor ma być wysłany
PORT_CS &= ~(1<<P_CS); // CS = Low
if (address == 0x00) {
spi_putc(SPI_RTS | 0x01);
} else {
spi_putc(SPI_RTS | address);
}
PORT_CS |= (1<<P_CS); // CS = High
return 1;
}[/syntax]
Teoretycznie może się też zdarzyć tak, że będziecie wysyłać wiele wiadomości jedna po drugiej. Pamiętajcie, że jako pierwszy
zostanie wysłany ten bufor , który ma najwyższy priorytet. Aby temu zapobiec , powinniście się starać o to by zawsze mieć
bufor z którego chcecie wysyłać wiadomości bieżące ustawiony na najniższy priorytet i zwiększać priorytet pozostałych
o 1. Wtedy macie pewność że wiadomości będą wysłane w takiej kolejności w jakiej były wpisane do buforów.
I pozostało nam już w zasadzie tylko odbieranie wiadomości.
No tu troszkę schodów nas czeka bo musimy określić czy wiadomość jest nowa , a to zależy od konfiguracji MCP2515
i można oczywiście to tez zrealizować na kilka sposobów.
--- stanem piny RXnBF
--- LInią IRQ
--- Poleceniami SPI
Oczywiście, żeby było trudniej można te sposoby łączyć ze sobą . Bardzo przydatne jest w jednym z przypadków uruchomienie
IRQ i sprawdzenie stanu na Mikrokontrolerze, wtedy widać czy są nowe wiadomości czy nie, a następnie pobrać przez
polecenia SPI bufora, w którym jest wiadomość. I w sumie tym przypadkiem zajmiemy się teraz.
W celu wykorzystania IRQPin i sprawdzeniu czy jest nowa wiadomość jak sie zapewne domyślacie musimy go najpierw ustawić
Wykonujemy to podczas Inicjalizacji i potem możemy sobie cierpliwie czekać aż na IRQPin pojawi się stan NISKI, co informuje
nas o tym że możemy odczytać nową wiadomość. Ale musimy też ustalić teraz gdzie jest ta nowa wiadomość (w którym buforze)
, a może jest to coś innego ?? np (STD ID, EXT ID, RTR itp
) Jest to proste bo MCP2515 ma taką extra komendę SPI pozwalającą na alternatywną ocenę rejestru CANINTF [syntax=c]uint8_t mcp2515_read_rx_status(void)
{
uint8_t data;
// /CS = LOW
PORT_CS &= ~(1<<P_CS);
spi_putc(SPI_RX_STATUS);
data = spi_putc(0xff);
// Ponowne wysłanie danych
// Musimy ocenić więc 1 z 2ch bajtów
spi_putc(0xff);
// /CS uwolniony :)
PORT_CS |= (1<<P_CS);
return data;
}[/syntax]
Dlatego łatwiej i lepiej jest najpierw sprawdzić czy IRQPin jest w stanie Niskim czy nie i jeśli jest to odbieramy
mową wiadomość:
[syntax=c]uint8_t can_get_message(CANMessage *p_message)
{
// Odczyt stanu
uint8_t status = mcp2515_read_rx_status();
if (bit_is_set(status,6))
{
// Wiadomość w buforze 0
PORT_CS &= ~(1<<P_CS); // CS = Low
spi_putc(SPI_READ_RX);
}
else if (bit_is_set(status,7))
{
// Wisdomość w buforze 1
PORT_CS &= ~(1<<P_CS); // CS = Low
spi_putc(SPI_READ_RX | 0x04);
}
else {
/* BŁĄD: Brak nowych wiadomości !*/
return 0xff;
}
// dla Standardowego ID
p_message->id = (uint16_t) spi_putc(0xff) << 3;
p_message->id |= (uint16_t) spi_putc(0xff) >> 5;
spi_putc(0xff);
spi_putc(0xff);
// długość odczytu
uint8_t length = spi_putc(0xff) & 0x0f;
p_message->length = length;
// Odczyt danych
for (uint8_t i=0;i<length;i++) {
p_message->data[i] = spi_putc(0xff);
}
PORT_CS |= (1<<P_CS);
if (bit_is_set(status,3)) {
p_message->rtr = 1;
} else {
p_message->rtr = 0;
}
// Flaga przerwania skasowana
if (bit_is_set(status,6)) {
mcp2515_bit_modify(CANINTF, (1<<RX0IF), 0);
} else {
mcp2515_bit_modify(CANINTF, (1<<RX1IF), 0);
}
return (status & 0x07);
}[/syntax]
Jak widać praktycznie rutynowa obsługa SPI
, pobieramy informacje o typie wiadomości, i buforze z wiadomością . Następnieodczytujemy dane z właściwych rejestrów. Dla komunikatów z EXT ID (29bit) jest obsługa w pierwszej kolejności. Funkcja
Filtrująca zwraca numer , przez który wiadomość zostanie wysłana z powrotem, a jeśli niema żadnych nowych wiadomości
do odczytania zwraca komunikat o błędzie - wartość 0xff. I to by było na tyle jęsli chodzi o implementacje CANA dla
mikrokontrolerów AVR jak nasza ATMega8 użyta do testu. Teraz powinniście już umieć wysłać i odebrać wiadomość
przez magistrale CAN. Oczywiście nasz tort jeszcze nie ma wiśienki
bo pewnie się już połapaliście że używam jakiejś magicznej biblioteki i plików dodatkowych. TAk to prawda dlatego też przygotuje tą wisienkę wraz z małym programikiem
który wysyła i odbiera bzdury z CANA
, a właściwie to wykonuje tylko inicjalizacje MSP2515, przełącza w tryb pętli zwrotnej co powoduje że wiadomość jest wysłana tylko wewnętrznie, odbiera ją i przechodzi do normalnego trybu, w którym ponawia
wysłanie wiadomości na magistrale CAN i oczekuje przychodzących.
Mam nadzieję że was nie zanudziłem na śmierć , i że zrozumieliście że CAN jest ciekawą alternatywą dla USARTA i pożądaną,
a jednocześnie nie jest ani skomplikowany , ani kosztowny w implementacji. Oczywiście polecam korzystać ze sprzętowego
SPI. Czytać notę, i odpowiednie rozdziały traktujące o SPI w książce Mirka.
TO JUŻ WSZYSTKO PANOWIE ....
PLIKI UMIESZCZĘ TUTAJ JAK BĘDĄ GOTOWE DO PUBLIKACJI , ORAZ ODPOWIEDNI ZESTAW INO dla ARDUINOWCÓW.
-- 1 lip 2012, o 14:38 --
Obiecałem, że będzie też CAN dla Arduinowców ... tu sprawa jest prosta i wręcz nie wymagająca żadnego opisu, jak to w Arduino.
Całość sprowadza się do zakupienia lub zrobienia sobie CAN-Shielda. Wszystko co potrzeba jest dostępne na stronie
sparkfuna : http://www.sparkfun.com/products/10039
a biblioteka dla Arduino jest do pobrania pod tym adresem:
http://code.google.com/p/sparkfun-ardui ... p&can=2&q=
Użycie jak to w Arduino jest proste i bez problemowe więc nie będę się rozwodził nad tym.
Życzę miłej zabawy .. z magistralą CAN oraz zapraszam do dyskusji w nowym temacie.
-- 1 lip 2012, o 22:27 --
Jak obiecałem , oto przykładowy programik demonstrujący działanie kontrolera CAN,
Na tej podstawie możecie już napisać co wam się podoba panowie
I przesyłać co chcecie przez magistralę CAN.
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <stdio.h>
#include <inttypes.h>
#include "uart.h"
#include "mcp2515.h"
#include "global.h"
#include "defaults.h"
// ----------------------------------------------------------------------------
#definePRINT(string, ...)printf_P(PSTR(string), ##__VA_ARGS__)
static int putchar__(char c, FILE *stream) {
uart_putc(c);
return 0;
}
static FILE mystdout = FDEV_SETUP_STREAM(putchar__, 0, _FDEV_SETUP_WRITE);
// -------------------------------------------------------------------------------------------------------------------
void print_can_message(tCAN *message)
{
uint8_t length = message->header.length;
PRINT("id: 0x%3x\n", message->id);
PRINT("len: %d\n", length);
PRINT("rtr: %d\n", message->header.rtr);
if (!message->header.rtr) {
PRINT("dane: ");
for (uint8_t i = 0; i < length; i++) {
PRINT("0x%02x ", message->data[i]);
}
PRINT("\n");
}
}
// ------------------------------------------------------------------------------------------------------------------
// Program Główny
int main(void)
{
// UART
uart_init(UART_BAUD_SELECT(9600UL, F_CPU));
// Włączenie Przerwań
sei();
// Przekierowanie standardowego wyjścia => Od teraz możemy użyć printf ()
stdout = &mystdout;
// MCP2515
if (!mcp2515_init()) {
PRINT("Błąd: MCP2515 nie gotowy\n");
for (;;);
}
else {
PRINT("MCP2515 aktywny\n\n");
}
PRINT("Tworzenie wiadomości\n");
tCAN message;
// Niektóre wartości
message.id = 0x123;
message.header.rtr = 0;
message.header.length = 2;
message.data[0] = 0xab;
message.data[1] = 0xcd;
print_can_message(&message);
PRINT("\Tryb Loopback\n\n");
mcp2515_bit_modify(CANCTRL, (1<<REQOP2)|(1<<REQOP1)|(1<<REQOP0), (1<<REQOP1));
// Wyślij wiadomość
if (mcp2515_send_message(&message)) {
PRINT("Wisdomość zapisana w buforze\n");
}
else {
PRINT("Błąd: Nie można wysłać wiadomości\n");
}
// No to chwilkę poczekamy
_delay_ms(10);
if (mcp2515_check_message()) {
PRINT("Odebrano wiadomość!\n");
// odczyt wiadomości z buforów
if (mcp2515_get_message(&message)) {
print_can_message(&message);
PRINT("\n");
}
else {
PRINT("Błąd: Nie można odczytać wiadomości\n\n");
}
}
else {
PRINT("Błąd: Nie odebrano wiadomości\n\n");
}
PRINT("Powrót do normalnego trybu\n\n");
mcp2515_bit_modify(CANCTRL, (1<<REQOP2)|(1<<REQOP1)|(1<<REQOP0), 0);
// Ponowne podłączenie do magistrali CAN
PRINT("Próba wysłania wiadomości przez CAN\n");
if (mcp2515_send_message(&message)) {
PRINT("Wiadomość została napisana w buforze\n\n");
}
else {
PRINT("Błąd: Nie można wysłać wiadomości\n\n");
}
PRINT("Oczekiwanie na odebranie wiadomości\n\n");
while (1) {
// Czekaj, aż pojawi się wiadomość
if (mcp2515_check_message()) {
PRINT("Odebrano wiadomość!\n");
// Czytanie wiadomości z buforów MCP2515
if (mcp2515_get_message(&message)) {
print_can_message(&message);
PRINT("\n");
}
else {
PRINT("Nie można odczytać wiadomości\n\n");
}
}
}
return 0;
}[/syntax]
No panowie mam nadzieję że jest to jasne
Potrzebna biblioteka i pliki nagłówkowe w załączniku , nie jest mojego autorstwa , ale używam jej dosyć często
i wiem że jest OK, po za tym niema potrzeby wymyślania koła od nowa w tym akurat przypadku
Polecam również zapoznać się wieloma opracowaniami i dokumentami w sieci , którymi również się posiłkowałem
materiałów jest ilość spora aż nie sposób wyliczyć...
Teraz możecie się bawić CANEM już do WOLI.
Statystyki: Napisane przez SunRiver — 30 cze 2012, o 16:39
]]>
??