ATNEL tech-forum

Re: RS485 + MKBOOTLOADER

2014-01-02T22:52:31+01:00

Witam.
Linię DE masz podpiętą pod PD4?
Pozdrawiam
Jarek

Statystyki: Napisane przez jark — 2 sty 2014, o 22:52

Re: RS485 + MKBOOTLOADER

2013-12-19T13:25:51+01:00

Znowu odgrzewamy kotleta:).
Kombinuje z bootloaderem również po rs485 1:1. Zmodyfikowałem funkcje UART_Rx_Byte. Bootloader sie ładnie wgrywa, procek daje znać o sobie. Lecz problem z wgraniem wsadu. BLS się nie zawiesza w głównej pętli, sprawdziłem diodą led.
Aha procek to atmega324pa

[syntax=c]/* biblioteki avr-libc */
#include
#include
#include
#include
#include
#include
#include

////////////////////////////////////////////////////////////////////////////////
/* Definicje stałych programowych i makr */
////////////////////////////////////////////////////////////////////////////////

// BAUD zdefiniowane w makefile
#define __UBRR ((F_CPU+BAUD*8UL)/(16UL*BAUD)-1) // obliczamy UBRR dla U2X=0

/* wersja bootloadera */
#define BOOTLOADER_VERSION 1

/* ustawienia UART */
#define UART_DATA_BITS 8
#define UART_PARITY 'n'
#define UART_STOP_BITS 1

// definicje na potrzeby RS485
#define UART_DE_PORT PORTD
#define UART_DE_DIR DDRD
#define UART_DE_BIT (1<
#define UART_DE_NADAWANIE UART_DE_PORT |= UART_DE_BIT
#define UART_DE_ODBIERANIE UART_DE_PORT &=~ UART_DE_BIT

/* czas przesyłania jednego znaku przez UART [us] */
#if UART_PARITY == 'n'
#define UART_BYTE_TIME \
( 1000000UL / ( BAUD / ( 1 + UART_DATA_BITS + UART_STOP_BITS ) ) )
#elif ( UART_PARITY == 'e' ) || ( UART_PARITY == 'o' )
#define UART_BYTE_TIME \
( 1000000UL / ( BAUD / ( 1 + UART_DATA_BITS + 1 + UART_STOP_BITS ) ) )
#endif

/* podstawienie nazwa rejestrów UART */
#ifndef UCSRA
#define UCSRA UCSR0A
#endif
#ifndef UCSRB
#define UCSRB UCSR0B
#endif
#ifndef UCSRC
#define UCSRC UCSR0C
#endif
#ifndef UBRRL
#define UBRRL UBRR0L
#endif
#ifndef UBRRH
#define UBRRH UBRR0H
#endif
#ifndef UDR
#define UDR UDR0
#endif

/* podstawienie nazw bitów w rejestrze UCSRA */
#ifndef RXC
#define RXC RXC0
#endif
#ifndef TXC
#define TXC TXC0
#endif
#ifndef UDRE
#define UDRE UDRE0
#endif
#ifndef FE
#define FE FE0
#endif
#ifndef DOR
#define DOR DOR0
#endif
#ifndef UPE
#define UPE UPE0
#endif
#ifndef U2X
#define U2X U2X0
#endif
#ifndef MPCM
#define MPCM MPCM0
#endif

/* podstawienie nazw bitów w rejestrze UCSRB */
#ifndef RXCIE
#define RXCIE RXCIE0
#endif
#ifndef TXCIE
#define TXCIE TXCIE0
#endif
#ifndef UDRIE
#define UDRIE UDRIE0
#endif
#ifndef RXEN
#define RXEN RXEN0
#endif
#ifndef TXEN
#define TXEN TXEN0
#endif
#ifndef UCSZ2
#define UCSZ2 UCSZ02
#endif
#ifndef RXB8
#define RXB8 RXB80
#endif
#ifndef TXB8
#define TXB8 TXB80
#endif

/* podstawienie nazw bitów w rejestrze UCSRC */
#ifndef UMSEL
#ifdef UMSEL0
#define UMSEL UMSEL0
#else
#define UMSEL UMSEL00
#define UMSEL0 UMSEL00
#define UMSEL1 UMSEL01
#endif
#endif
#ifndef UPM1
#define UPM1 UPM01
#endif
#ifndef UPM0
#define UPM0 UPM00
#endif
#ifndef USBS
#define USBS USBS0
#endif
#ifndef UCSZ1
#define UCSZ1 UCSZ01
#endif
#ifndef UCSZ0
#define UCSZ0 UCSZ00
#endif
#ifndef UCPOL
#define UCPOL UCPOL0
#endif

/* ustawienia bitów konfiguracyjnych UART */
#if UART_DATA_BITS == 5
#define UCSRB_DATA_BITS ( 0 << UCSZ2 )
#define UCSRC_DATA_BITS ( 0 << UCSZ1 | 0 << UCSZ0 )
#elif UART_DATA_BITS == 6
#define UCSRB_DATA_BITS ( 0 << UCSZ2 )
#define UCSRC_DATA_BITS ( 0 << UCSZ1 | 1 << UCSZ0 )
#elif UART_DATA_BITS == 7
#define UCSRB_DATA_BITS ( 0 << UCSZ2 )
#define UCSRC_DATA_BITS ( 1 << UCSZ1 | 0 << UCSZ0 )
#elif UART_DATA_BITS == 8
#define UCSRB_DATA_BITS ( 0 << UCSZ2 )
#define UCSRC_DATA_BITS ( 1 << UCSZ1 | 1 << UCSZ0 )
#elif UART_DATA_BITS == 9
#define UCSRB_DATA_BITS ( 1 << UCSZ2 )
#define UCSRC_DATA_BITS ( 1 << UCSZ1 | 1 << UCSZ0 )
#endif

#if UART_PARITY == 'n'
#define UCSRC_PARITY ( 0 << UPM1 | 0 << UPM0 )
#elif UART_PARITY == 'e'
#define UCSRC_PARITY ( 1 << UPM1 | 0 << UPM0 )
#elif UART_PARITY == 'o'
#define UCSRC_PARITY ( 1 << UPM1 | 1 << UPM0 )
#endif

#if UART_STOP_BITS == 1
#define UCSRC_STOP_BITS ( 0 << USBS )
#elif UART_STOP_BITS == 2
#define UCSRC_STOP_BITS ( 1 << USBS )
#endif

/* makro zamieniające podany argument na łańcuch znaków */
#define TOSTRING( x ) STRINGIFY( x )
#define STRINGIFY( x ) #x

////////////////////////////////////////////////////////////////////////////////
/* Deklaracje funkcji statycznych */
////////////////////////////////////////////////////////////////////////////////

static void UART_TX_Byte(
const uint8_t Data );

static void UART_TX_String_P(
const char *String_Ptr );

static uint16_t _UART_RX_Wait(
uint16_t Timeout );

/* Makro przeliczające argument w milisekundach na przyjmowaną przez funkcję
* _UART_RX_Wait wielokrotność czasu przesyłania jednego znaku. */
//#define UART_RX_Wait( x ) _UART_RX_Wait( ( ( x ) > UART_BYTE_TIME ) ? \
// ( ( ( x ) * 1000UL ) / UART_BYTE_TIME ) : 1 )

#define UART_RX_Wait( x ) _UART_RX_Wait( ( x * 1000UL ) / UART_BYTE_TIME )

////////////////////////////////////////////////////////////////////////////////
/* Definicje funkcji */
////////////////////////////////////////////////////////////////////////////////

static void __vectors( void )
__attribute__ (( section( ".vectors" ), naked, used ));
static void __vectors( void )
{
/* skok do sekcji .init2 (konieczny ze względu na umieszczanie stałych z
* pamięci programu pomiędzy sekcjami .vectors a .init0, a więc na samym
* początku programu w przypadku wykorzystania opcji -nostartfiles */
asm (
"rjmp __init2" "\n\t"
: : );
}

static void __init2( void )
__attribute__ (( section( ".init2" ), naked, used ));
static void __init2( void )
{
/* inicjalizacja wskaźnika stosu, rejestru z zerem i rejestru flag */
asm volatile (
"out __SP_L__, %A0" "\n\t"
"out __SP_H__, %B0" "\n\t"
"clr __zero_reg__" "\n\t"
"out __SREG__, __zero_reg__" "\n\t"
: : "r"( ( uint16_t )( RAMEND ) ) );
}

//#define WDIF

//#ifdef WDIF
static void __init3( void )
__attribute__ (( section( ".init3" ), naked, used ));
static void __init3( void )
{
/* wyłączenie watchdoga (w tych mikrokontrolerach, w których watchdog
* ma możliwość generowania przerwania pozostaje on też aktywny po
* resecie) */
MCUSR = 0;
_WD_CONTROL_REG = 1 << _WD_CHANGE_BIT | 1 << WDE;
_WD_CONTROL_REG = 0;
}
//#endif

static void __init9( void )
__attribute__ (( section( ".init9" ), naked, used ));
static void __init9( void )
{
/* skok do funkcji main */
asm ( "rjmp main" "\n\t" : : );
}

int main( void )
__attribute__ (( noreturn ));
int main( void )
{
DDRC |= (1<PORTC |=(1< /* konfiguracja i włączenie interfejsu UART */
UBRRH = __UBRR>>8;//UBRRH_VALUE;
UBRRL = __UBRR;//UBRRL_VALUE;

UART_DE_DIR |= UART_DE_BIT;
UART_DE_ODBIERANIE;
UCSR0B |= (1<
#ifdef URSEL
UCSRC = 1 << URSEL | UCSRC_DATA_BITS | UCSRC_PARITY | UCSRC_STOP_BITS;
#else
UCSRC = UCSRC_DATA_BITS | UCSRC_PARITY | UCSRC_STOP_BITS;
#endif
UCSRB = 1 << RXEN | 1 << TXEN | UCSRB_DATA_BITS;

/* deklaracja zmiennych */
uint16_t Received_Char;

/* wysyłanie znaku '?' do odebrania znaku 'u' lub upłynięcia czasu
* oczekiwania */
for ( uint8_t Retries_Left = BOOT_WAIT * 100; Retries_Left; --Retries_Left )
{
UART_TX_Byte( '?' );
_delay_ms(100);

if ( ( uint8_t )UART_RX_Wait( 1000 ) == 'u' )
{
/* definicja zmiennych */
bool Is_Comm_Lost = false;

while ( 1 )
{
PORTC ^=(1< /* odebranie znaku */
uint16_t Received_Char = UART_RX_Wait( 1000 );

if ( ( uint8_t )Received_Char == 'i' )
{
/* jeśli odebrano znak 'i', to wysłanie ciągu znaków
* identyfikujących mikrokontroler i bootloader */
UART_TX_String_P( PSTR( "\r\n" "&"
TOSTRING( SPM_PAGESIZE ) ","
TOSTRING( BLS_START ) ","
TOSTRING( MCU ) ","
TOSTRING( XTAL ) ","
TOSTRING( BOOTLOADER_VERSION )
"*" "\r\n" ) );
}
else if ( ( uint8_t )Received_Char == 'w' )
{
PORTC ^=(1< /* odczekanie do zakończenia operacji na pamięci EEPROM
* i Flash */
eeprom_busy_wait();
boot_spm_busy_wait();

/* kasowanie całej pamięci programu */
for ( uint32_t Page_Address = 0; Page_Address < BLS_START;
Page_Address += SPM_PAGESIZE )
{
/* skasowanie strony pamięci */
boot_page_erase( Page_Address );
boot_spm_busy_wait();
}

/* programowanie pamięci programu */
for ( uint32_t Page_Address = 0; Page_Address < BLS_START;
Page_Address += SPM_PAGESIZE )
{

/* wysłanie znaku '@' */
UART_TX_Byte( '@' );

/* jeśli odebrano zero lub upłynął czas oczekiwania na
* odpowiedź, to zakończenie pracy bootloadera */
Received_Char = UART_RX_Wait( 1000 );
if ( !Received_Char || Received_Char > 0xff )
break;

/* zapełnienie bufora strony */
for ( uint16_t Byte_Address = 0;
Byte_Address < SPM_PAGESIZE; Byte_Address += 2 )
{
PORTC &=~(1< /* próba odebrania młodszego bajtu słowa z pamięci
* programu */
if ( ( Received_Char = UART_RX_Wait( 1000 ) )
> 0xff )
{
Is_Comm_Lost = true;
break;
}

uint16_t Instruction = Received_Char;

/* próba odebrania starszego bajtu słowa z pamięci
* programu */
if ( ( Received_Char = UART_RX_Wait( 1000 ) )
> 0xff )
{
Is_Comm_Lost = true;
break;
}

Instruction += Received_Char << 8;

/* zapisanie instrukcji do bufora */
boot_page_fill( Byte_Address, Instruction );
}

if ( Is_Comm_Lost )
break;
PORTC &=~(1< /* zapisanie strony pamięci */
boot_page_write( Page_Address );
boot_spm_busy_wait();
}

/* odblokowanie sekcji Read-While-Write */
boot_rww_enable();

/* zakończenie pracy bootloadera */
break;
}
else
{
/* jeśli odebrano inny znak lub upłynął czas oczekiwania na
* odpowiedź, to zakończenie pracy bootloadera */
break;
}
}

/* jeśli komunikacja z komputerem urwała się podczas przesyłania
* strony, to bootloader jest uruchamiany ponownie, w przeciwnym
* przypadku zakończenie pracy bootloadera */
if ( Is_Comm_Lost )
Retries_Left = BOOT_WAIT * 10;
else
break;
}
}

/* wyłączenie interfejsu UART (dzieje się to dopiero po zakończeniu
* wysyłania) i odczekanie do końca ewentualnej transmisji */
UCSRB = 0;
//_delay_us( UART_BYTE_TIME );

/* skok do właściwego programu */
#if defined( __AVR_HAVE_JMP_CALL__ )
asm volatile (
"jmp 0" "\n\t"
: : );
#elif defined( EIND )
EIND = 0;
asm volatile (
"eijmp" "\n\t"
: : "z" ( 0 ) );
#else
asm volatile (
"ijmp" "\n\t"
: : "z" ( 0 ) );
#endif

/* nieskończona pętla (konieczna, by kompilator nie wygenerował
* niepotrzebnego kodu) */
while ( 1 )
{}
}

static void UART_TX_Byte(
const uint8_t Data )
{
while ( !( UCSRA & 1 << UDRE ) ) wdt_reset();
UART_DE_NADAWANIE;
UDR = Data;
while(!(UCSRA & 1< UCSRA |= 1< UART_DE_ODBIERANIE;
}

static void UART_TX_String_P(
const char *String_Ptr )
{
uint8_t Single_Char;

#ifdef __AVR_HAVE_ELPM__
while ( ( Single_Char = pgm_read_byte_far( String_Ptr++ ) ) )

#else
while ( ( Single_Char = pgm_read_byte_near( String_Ptr++ ) ) )
#endif
UART_TX_Byte( Single_Char );

}

static uint16_t _UART_RX_Wait(
uint16_t Timeout )
{
do
{
if ( UCSRA & 1 << RXC )
return ( uint16_t )UDR;

_delay_us( UART_BYTE_TIME );
} while ( --Timeout );

return 0xffff;
}[/syntax]

Statystyki: Napisane przez developer85 — 19 gru 2013, o 13:25

Re: RS485 + MKBOOTLOADER

2013-05-06T13:18:22+01:00

bss34 napisał(a):

U siebie zrobiłem podobnie! Z tym, że działa to z 31 modułami, również rozrzuconymi po domu i ogrodzie, u mnie przykładowy format komendy do soft resetu to "!99r" Gdzie ! początek rozkazu, 99 adres modułu, a r to restart i wejście w tryb bootloadera na 5 sekund.

No i piękna sprawa gotowy przepis

Statystyki: Napisane przez mirekk36 — 6 maja 2013, o 13:18

Re: RS485 + MKBOOTLOADER

2013-05-06T12:28:03+01:00

jark napisał(a):

Witam.
Odgrzeję starego kotleta ale wątek mi pomógł więc napiszę.
Dzięki za poprawki do bootloadera - świetnie działa z rs485.
Oczywiście też czekam na update mkbootloadera do pełnej obsługi rs485 ale chciałbym napisać że również z tą wersją można sobie trochę ułatwić programowanie wielu układów połączonych w sieć. Wprawdzie nie wszystkie na raz ale pojedynczo (ale bez odłączania od sieci) działa całkiem sprawnie. Mam 3 moduły rozrzucone po domu (to nie problem bo dom nie duży) ale mocno zabudowane tzn. do każdego żeby się dostać to trochę się trzeba nademontować Wszystkie komunikowały się ze sobą (a raczej z masterem będącym w dogodnym miejscu) po rs485. Protokół prosty jakiś tam sobie wymysliłem czyli np $1X oznacza:
$ - (oznaczenie początku rozkazu)
1 - adres modułu.
X - komenda np odczyt to R, zapis to W+FF (wartość w hex) jest też reset - S
I teraz jak chcę zaktualizować we wszystkich modułach programy z jednego miejsca to się wpinam kompem w sieć rs485, wyłączam mastera (transmisja więc ustaje bo protokół jest tak zbudowany że slave-y siedzą cicho do momentu aż konkretnego master nie zapyta), odpalam mkbootloader, otwieram plik ze wsadem dla odpowiedniego slave-a i ustawiam [software reset] np $1S (jeśli chcę zaktualizować slave-a nr 1), wciskam wstrzyknij i po chwili mam wsad zaktualizowany. I tak z każdym po kolei zmieniając ciąg znaków w opcji [software reset].
Wiem że ameryki nie odkryłem ale może się komuś ta uproszczona wersja przyda bo mi baaaaardzo ułatwiła życie.
Pozdrawiam
Jarek

Statystyki: Napisane przez bss34 — 6 maja 2013, o 12:28

Re: RS485 + MKBOOTLOADER

2013-05-04T07:08:32+01:00

jark no i bardzo fajny sposób

Statystyki: Napisane przez mirekk36 — 4 maja 2013, o 07:08

Re: RS485 + MKBOOTLOADER

2013-05-04T01:00:52+01:00

Statystyki: Napisane przez jark — 4 maja 2013, o 01:00

Re: Odp: RS485 + MKBOOTLOADER

2013-02-17T20:44:32+01:00

Sprawdz czy pin i port od kierunku transmisjii wysterowujesz

Statystyki: Napisane przez rayden — 17 lut 2013, o 20:44

Re: RS485 + MKBOOTLOADER

2013-02-17T18:40:33+01:00

Dwie linijki wyżej niż:
[syntax=c]UART_TX_Byte( '?' );[/syntax]
jest
[syntax=c]UART_RX_Wait(100)[/syntax]
możliwe, że czas oczekiwania jest za krótki dla RS485.

Zalecam też sprawdzenie komunikacji w obie strony na prostszym przykładzie, aby upewnić się, że nie ma kłopotów z komunikacją.

Statystyki: Napisane przez Krauser — 17 lut 2013, o 18:40

Re: RS485 + MKBOOTLOADER

2013-02-17T15:27:09+01:00

tak tylko problem w tym, że po połączeniu z terminalem działają mi tylko znaki zachęty "??????????", bootloader via rs485 nie zgłasza się na komendy "U" i "I". Przejściówka usb-rs485 sprawna:-) Myślałem, że gdzieś tu jest wina.

Statystyki: Napisane przez bss34 — 17 lut 2013, o 15:27

Re: RS485 + MKBOOTLOADER

2013-02-17T14:21:06+01:00

W nagłówku avr/wdt.h masz zdefiniowane makro wdt_reset()

Statystyki: Napisane przez Krauser — 17 lut 2013, o 14:21

Re: RS485 + MKBOOTLOADER

2013-02-17T13:38:46+01:00

rayden napisał(a):

drobna pomylka w kodzie poprzednim ponizej poprawny:
[syntax=c]static void UART_TX_Byte(unsigned char ch)
{
while(!(UCSRA & 1<
RS485PORT |= RS485TXE; // switch to TX mode
UDR = ch; // write char
while(!(UCSRA & 1< UCSRA |= 1< RS485PORT &= ~RS485TXE; // switch to RX mode
}[/syntax]

Mam jeszcze drobny problem z WDR(); jak powinien być zdefiniowany?

Statystyki: Napisane przez bss34 — 17 lut 2013, o 13:38

Re: RS485 + MKBOOTLOADER

2013-01-30T11:32:58+01:00

Statystyki: Napisane przez rayden — 30 sty 2013, o 11:32

Re: RS485 + MKBOOTLOADER

2013-01-30T08:09:02+01:00

Proszę bardzo:
[syntax=c]static void UART_TX_Byte(unsigned char ch)
{
while(!(UCSRA & UDRE)) WDR(); // wait for empty transmit buffer

RS485PORT |= RS485TXE; // switch to TX mode
UDR = ch; // write char
while(!(UCSRA & 1< UCSRA |= 1< RS485PORT &= ~RS485TXE; // switch to RX mode
}[/syntax]

No i gdzieś na początku funkcji main trzeba ustawić:
[syntax=c]RS485DDR |= RS485TXE; // RS485 pin as output
RS485PORT &= ~RS485TXE; // set RS485 in Rx mode[/syntax]

Natomiast jeszcze przed funkcją main zdefiniować sobie makra do rejestru DDR i rejestru PORT (już pomijam).

Statystyki: Napisane przez rayden — 30 sty 2013, o 08:09

Re: RS485 + MKBOOTLOADER

2013-01-29T23:10:18+01:00

Jeżeli można to poprosiłbym o zaktualizowany kod

Statystyki: Napisane przez bss34 — 29 sty 2013, o 23:10

Re: RS485 + MKBOOTLOADER

2013-01-29T22:47:49+01:00

Zgadzam się z kolegą może priorytet w przyszłości nieco wzrośnie?
Póki co bez problemów da się przerobić MkBootloader w ten sposób, żeby programował jeden układ przez 485. Wystarczy w kodzie bootloadera na avr sterować kierunkiem przepływu przed i po wysłaniu znaku. Kilka linijek kodu w sumie. Jak ktoś potrzebuje to zamieszczę zmianę. Szkoda, że nie da się eepromu programować i lockbitów programować od bootloadera (chociaż to 2 da się przeżyć). Ogólnie program rozwojowy jest. Swego czasu przybierałem się do aktualizacji oprogramowania w układach pracujących w sieci wyposażonej w RFM ciekawe do zabawy, polecam

Statystyki: Napisane przez rayden — 29 sty 2013, o 22:47

Re: RS485 + MKBOOTLOADER

2013-01-22T13:43:48+01:00

mirekk36 napisał(a):

1:1 powinno spokojnie działać - sterowanie linią kierunku dla MAX485 masz przecież w przykładach w książce niebieskiej.

A jeśli chodzi o sieć z wieloma układami Slave to trzeba byłoby przerabiać już aplikację na PC. Mam to w planach i jest na liście rozwojowej programu ale niestety ma niski priorytet

Za to pomyśl sobie o innym sposobie aktualizacji wsadów w trudno dostępnych sterownikach. Bluetooth, tylko nie pisz mi zaraz że to za drogie - bo odpowiem ci że można to wręcz za DARMO zrobić nie trzeba przecież wkładać BT do każdego sterownika SLAVE, tylko wyprowadzić na wierzch obudowy gniazdko na moduł BT, z którym chodzisz i masz go w walizce serwisowej. Potrzebujesz podmienić wsad? to wyjmujesz moduł BT z walizki, wpinasz w obudowę i bez żadnych kabli pięknie tym samym bootloaderem lecisz .... może troszkę wolniejsza transmisja ale za to JAKA WYGODA

obejrzyj sobie to:

http://mirekk36.blogspot.com/2012/12/bt ... -do-z.html

Dziekuję za pomoc, jak wrócę do domu sprawdzę przykłady z książki, z przenośnym BT jest to świetny pomysł, ale wolałbym nie wyprowadzać więcej przewodów niż to potrzebne. Obudowa będzie typu 'zalewajka żywicą poliuretanową" więc ciężko mi będzie dodatkowe kable lub złącze odpowiednio ułożyć. Szkoda, ża aplikacja na PC obsługująca wiele modułów slave ma na razie niski priorytet ( Ale wydaje mi się, że warto będzie poczekać )

Statystyki: Napisane przez bss34 — 22 sty 2013, o 13:43

Re: RS485 + MKBOOTLOADER

2013-01-22T13:17:19+01:00

Statystyki: Napisane przez mirekk36 — 22 sty 2013, o 13:17

Re: RS485 + MKBOOTLOADER

2013-01-22T12:33:53+01:00

W sieci RS485 byłoby przeidealnie, ale na razie wystarczy również 1:1. Mam 32 moduły w których musiałem się dolutowywać kynarkiem przed SN75176 aby móc wrzucić wsad (nie projektowałem złącza ISP w płytce). Docelowo będą one schowane w puszkach podtynkowych więc będzie utrudniony dostęp aby zrobić aktualizację firmware.

Statystyki: Napisane przez bss34 — 22 sty 2013, o 12:33

Re: RS485 + MKBOOTLOADER

2013-01-22T12:11:22+01:00

Ale tobie chodzi o połączenie RS485 tak 1:1 , czy żeby działał w sieci gdzie jest wiele układów SLAVE ?

Statystyki: Napisane przez mirekk36 — 22 sty 2013, o 12:11

RS485 + MKBOOTLOADER

2013-01-22T11:30:47+01:00

Witam!

Mam malutkie pytanie, jak przerobić mkbootloader aby był w stanie współpracować z RS485 w half-duplex. Po RS232 wszystko działa bez zarzutu, po rs485 widać znaki zapytania w terminalu natomiast nie reaguje na "U" i "I". Pin do zmiany kierunku transmisji do PD2 (INT0) w Atmega8. Chodzi mi o kawałek kodu, który wysłałby zachętę np:"???" a potem przełączył się na odbiór. Jeżeli chodzi o język C to dopiero zaczynam się uczyć....

pozdrawiam
BS

Statystyki: Napisane przez bss34 — 22 sty 2013, o 11:30