ATNEL tech-forum

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-21T22:55:14+01:00

Quote:

Sterowanie przepływem odbywa się prawidłowo, sprawdzone oscyloskopem.

No to nie ma o czym rozmawiać skoro prawidłowo .... czyli wszystko działa - gratulacje

Statystyki: Napisane przez mirekk36 — 21 wrz 2017, o 22:55

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-21T10:24:21+01:00

Przecież dodałem, co z resztą widać na załączonym kodzie bootloadera:

[syntax=c]static void UART_TX_Byte(const uint8_t ch)
{
while(!(UCSRA & (1<
PORTA |= (1< UDR = ch; // write char
while(!(UCSRA & (1< UCSRA |= (1< PORTA &= ~(1<}[/syntax]

Sterowanie przepływem odbywa się prawidłowo, sprawdzone oscyloskopem. Dodatkowo sygnały zmierzone na kablu RS485 pokazują komunikację w dwie strony.

Przejściówka po stronie komputera też działa, gdyż na komputerze mam uruchomiony docklight do symulacji urządzeń slave kiedy pracuję w sieci (oczywiście kiedy programuję to odłączam wszystkie pozostałe układy i wyłączam docklight'a).

Statystyki: Napisane przez robosom — 21 wrz 2017, o 10:24

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-21T00:21:49+01:00

Podpowiem - w bootloaderze musisz dodać odpowiednie sterowanie kierunkiem przepływu.

Statystyki: Napisane przez micky — 21 wrz 2017, o 00:21

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-20T23:15:14+01:00

robosom napisał(a):

Co do full-duplexu chodziło mi o to, że w trybie rs232 jest możliwa wymiana full-duplex i w tej konfiguracji wszystko pasuje lecz w sieci RS485 już mamy tylko half-duplex więc program musiałby niejako wystawić slot czasowy i poczekać na odpowiedź procesora po każdej stronie wysłanego kodu, czyż nie?

odpowiem tak: czyż nie

a kolega wie co to jest MAX485 i sterowanie linią kierunku przepływu danych?

Statystyki: Napisane przez mirekk36 — 20 wrz 2017, o 23:15

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-20T22:48:50+01:00

mirekk36 napisał(a):

Trzeba sobie zatem samemu przerobić kod BLS we wasnym zakresie do komunikacji we własnej sieci RS485 i wcale nie musi być żaden ful duplex ... toż wystarczy prawidłowo strować kierunkiem przepływu - czego pewnie nie robisz w ogóle albo źle robisz. Trzeba sobie nadawać adresu urządzeń i jakoś je adresować - no chyba że chodzi ci o połączenie 1:1 po RS485 to wtedy najmniejszy problem

Tak, chodzi o połączenie 1:1. Sterowanie przepływem na pewno działa prawidłowo gdyż urządzenie już pracuje w sieci i komunikuje się z innymi, Z reszta na jednym z oscylogramów widać, że do transmisji od strony PC próbuje wbić się procesor, przez to poziom sygnału jest podniesiony i zaburzony.

Co do full-duplexu chodziło mi o to, że w trybie rs232 jest możliwa wymiana full-duplex i w tej konfiguracji wszystko pasuje lecz w sieci RS485 już mamy tylko half-duplex więc program musiałby niejako wystawić slot czasowy i poczekać na odpowiedź procesora po każdej stronie wysłanego kodu, czyż nie?

Nie wiem tylko do końca jak działa protokół wymiany danych programu z bootloaderem. Gdyby ktoś nakierował mnie na to to rozwiązałbym problem sam.

Statystyki: Napisane przez robosom — 20 wrz 2017, o 22:48

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-20T21:16:13+01:00

Ooo to może wrócą wtorki z Delphi

Statystyki: Napisane przez north — 20 wrz 2017, o 21:16

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-20T21:02:16+01:00

Ja jestem do końca tygodnia tutaj:

http://delphi.pl/zlot/

czytam sobie jednak wątek i się dziwię, skąd koledze przyszło do głowy, że MkBootloader działa natywnie z RS485? Czy ja gdzieś o tym pisałem? Mówiłem?

nigdzie teggo nie mówiłem ani nie pisałem

Trzeba sobie zatem samemu przerobić kod BLS we wasnym zakresie do komunikacji we własnej sieci RS485 i wcale nie musi być żaden ful duplex ... toż wystarczy prawidłowo strować kierunkiem przepływu - czego pewnie nie robisz w ogóle albo źle robisz. Trzeba sobie nadawać adresu urządzeń i jakoś je adresować - no chyba że chodzi ci o połączenie 1:1 po RS485 to wtedy najmniejszy problem

wielu ludzi zrobiło sobie komunikację po RS485 - ja nie bo nie miałem jak na raze takiej potrzeby a przecież kod BLS do procka masz otwarty w programie

więc zacznij od jego przeróbki i prawidłowego sterowania linią kierunku przepływu scalaka MAX485 - to podstawa

Statystyki: Napisane przez mirekk36 — 20 wrz 2017, o 21:02

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-20T20:28:48+01:00

Zrobiłem próby z generowaniem plików z kreatora i z własnych plików. Oba bootloadery działają lecz nie działa tryb RS485.
Mam wrażenie, że program przygotowany jest do pracy Full-duplex co odcina pracę w sieci RS485. Na załączonym screenie procesor odpowiada lecz program nawet nie przewidział dla niego okna czasowego na odpowiedź, przez co dostajemy odpowiedź w programie "time out".

Panie Mirku, poradzi Pan coś?

Statystyki: Napisane przez robosom — 20 wrz 2017, o 20:28

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-20T15:42:01+01:00

W bootloader kreatorze kieruj się wybranym prockiem i podpowiedzią z boku rozwijanej listy adresów.

Statystyki: Napisane przez micky — 20 wrz 2017, o 15:42

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-20T14:25:40+01:00

Właśnie na RS232 wszystko działa jak należy. Co ciekawe gdy wygeneruje z czystych plików bootloader to program działa i wszystko się ładuje poprawnie, nawet gdy wprowadzę zmiany dla rs485 a wyślę program przez rs232 to poprawnie wchodzi.

Ciekawi mnie fakt dlaczego BLS_Start jest inny względem obliczeń a inny względem opisu w programie:

w stosunku do obliczeń ze strony: 0x7E00 *2 = 0xFC00

W sumie nawet na stronie z obliczeniami są błędy. Sam już nic nie wiem

Statystyki: Napisane przez robosom — 20 wrz 2017, o 14:25

Re: MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-20T12:46:42+01:00

Na RS232 wszystko jest ok? Jak tak to może źle sterujesz kierunkiem przepływu?

Statystyki: Napisane przez micky — 20 wrz 2017, o 12:46

MkBootloader + RS485: Problem z wgraniem wsadu

2017-09-20T11:29:21+01:00

Witam serdecznie.

Pracuję na mikrokontrolerze ATmega64 i ładuje wsady przez bootloader. Wsad bootloadera generowany z "plików wzorcowych". Prędkość to 115200 bodów transmitowane przez USB i przejściówke na FT232.
Urządzenie docelowo ma pracować w sieci opartej o RS485

postanowiłem więc od nowa wygenerować bootloader do pracy w sieci. Natknąłem się na wątek:
http://forum.atnel.pl/topic2168.html?hilit=mkbootloader%20485
gdzie bardzo fajnie została opisana zmiana bootloadera. Ustawiłem więc wszystko tak jak w artykuje:

[syntax=c]////////////////////////////////////////////////////////////////////////////////
/* Bootloader
* Autor: Mirosław Kardaś (2009-06-16)
* Modyfikacje: Paweł Szramowski (2009-07-08)
* Wersja: 2009-07-03 04:00 */
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/* Dołączenie bibliotek */
////////////////////////////////////////////////////////////////////////////////

/* biblioteki avr-libc */
#include
#include
#include
#include
#include
#include
#include
//#include

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

//#define UART_BAUD 57600// tu definiujemy interesującą nas prędkość
#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

/* 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 ) ) );
}

#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 )
{
/* konfiguracja i włączenie interfejsu UART */
UBRRH = __UBRR>>8;//UBRRH_VALUE;
UBRRL = __UBRR;//UBRRL_VALUE;
/*
#if USE_2X
UCSRA = 1 << U2X;
#else
UCSRA = 0;
#endif
*/
//wyjscie do rs485
DDRA |= (1< PORTA &= ~(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 * 10; Retries_Left; --Retries_Left )
{
UART_TX_Byte( '?' );
//_delay_ms(100);

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

while ( 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' )
{

/* 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 )
{
/* 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;

/* 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 ch)
{
while(!(UCSRA & (1<
PORTA |= (1< UDR = ch; // write char
while(!(UCSRA & (1< UCSRA |= (1< PORTA &= ~(1<}

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( (BLS_START&0xF0000UL) + (uint32_t)(uint16_t)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]

Plik makefile ustawiony tak:

[syntax=c]# MCU name
MCU = atmega64

# MCU frequency (without UL suffix)
F_CPU = 14745600

# Bootloader options
# m128, m1284p = 0x1FC00
# m32, m328 = 0x7E00
# m16, m168 = 0x3E00
# m8, m88 = 0x1E00
BLS_START = 0xFE00

# dla połączeń Bluetooth czas oczekiwania min 3 s
BOOT_WAIT = 5

BAUD_RATE = 9600[/syntax]

BLS start ustawiony tak jak w "plikach wzorcowych" czyli 0xFE00
Wszystko się bardzo dobrze kompiliuje i wgrywa do procka. Fusebity ustawione tak:

Jednak podczas próby wgrania programu przez RS485 występuje błąd.

Procesor odzywa się i wysyła wszystkie dane na temat bootloadera, jednak w momencie kiedy program wysyła dane, procek spóźnia się z odesłaniem potwierdzenia "@" albo wysyła go w momencie kiedy wysyłane są dane z komputera (dwie wysokie szpilki na drugim screenie).

Myślałem, że źle ustawiłem parametry bootloadera, i za drugim razem ustawiłem BLS_START tak jak na stronie:
http://atnel.pl/mkbootloader.html
czyli: 0x7E00 *2 = 0xFC00, Ustawiłem więc nowy BLS lecz problem dalej pozostał ten sam.

Nie wiem czy jest to problem z przejściówką (opartą o FT232 i MAX485) czy programu ale skoro odczyt parametrów odbywa się poprawnie to nie wiem dlaczego transmisja już nie.
Jakieś podpowiedzi co ustawione jest źle?

Błagam, męczę się z tym już kilka dni a deadline goni

Statystyki: Napisane przez robosom — 20 wrz 2017, o 11:29