ATNEL tech-forum

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T21:22:06+01:00

Nie musisz z tego korzystać w swoim projekcie, ale warto wiedzieć. Twój podpis zobowiązuje.
A wracając do tematu to zrobisz to na funkcjach zwrotnych (callback) ?

Statystyki: Napisane przez Krauser — 28 lip 2013, o 21:22

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T22:48:54+01:00

W końcu przerobiłem bibliotekę Antystatycznego. Mam nadzieję, że niczego nie popsułem Pliki uart.c i uart.h tylko leciutko zmodyfikowane przy użyciu #ifdef, aby zmniejszyć rozmiar kodu.
Wyniki:
- bez użycia strumieni:
Program: 2320 bytes (3.5% Full)
(.text + .data + .bootloader)
Data: 114 bytes (2.8% Full)
(.data + .bss + .noinit)

- przy wykorzystaniu strumieni:
Program: 4056 bytes (6.2% Full)
(.text + .data + .bootloader)
Data: 168 bytes (4.1% Full)
(.data + .bss + .noinit)
Pliki:
-main.c:
[syntax=c]/*
* main.c
*
* Author: Antystatyczny
* Mod: Krauser
*/
#include
#include
#include
#include
#include "uart.h"
#include
#include

#if USE_STREAM == 1
#if (USART_NUMBER==0)||(USART_NUMBER==2)
char work_buffer0[RX0_BUFFER_SIZE];
int my_putchar0(char data, FILE *stream) //przerobienie funkcji
{
uart_put_char(0, data);
return 0;
}
int my_getchar0(FILE *stream) //przerobienie funkcji
{
return uart_get_char(0);
}
//zdefiniowanie strumieni
FILE my_stream0 = FDEV_SETUP_STREAM (my_putchar0, my_getchar0, _FDEV_SETUP_RW);
#endif

#if (USART_NUMBER==1)||(USART_NUMBER==2)
char work_buffer1[RX1_BUFFER_SIZE];
int my_putchar1(char data, FILE *stream) //przerobienie funkcji
{
uart_put_char(1, data);
return 0;
}
int my_getchar1(FILE *stream) //przerobienie funkcji
{
return uart_get_char(1);
}
//zdefiniowanie strumieni
FILE my_stream1 = FDEV_SETUP_STREAM (my_putchar1, my_getchar1, _FDEV_SETUP_RW);
#endif
#else
char work_buffer0[RX0_BUFFER_SIZE];
char work_buffer1[RX1_BUFFER_SIZE];
#endif

int main(void)
{
#if (USART_NUMBER==0)||(USART_NUMBER==2)
uart_init(0, __UBRR0);
#endif
#if (USART_NUMBER==1)||(USART_NUMBER==2)
uart_init(1, __UBRR1);
#endif
sei();
/* test funkcji */
#if USE_STREAM == 1
#if (USART_NUMBER==0)||(USART_NUMBER==2)

fputs("\r\nS", &my_stream0);
stdout = &my_stream0; //przekierowanie strumienia
puts("TART\r");
puts_P(PSTR ("USART0\r"));
printf("decimal=%d\r\n", -12345);
printf_P(PSTR("hex=%x\r\n"), 0xABcd);
#endif
#if (USART_NUMBER==1)||(USART_NUMBER==2)

fputs("\r\nST", &my_stream1);
stdout = &my_stream1; //przekierowanie strumienia
puts("ART\r");
puts_P(PSTR ("USART1\r"));
printf("decimal=%d\r\n", 6789);
printf_P(PSTR("hex=%X\r\n"), 0xef01);
#endif

while(1)
{
#if (USART_NUMBER==2)
//pobierz ze strumienia 1
if( strlen(fgets( work_buffer1, sizeof(work_buffer1)-1, &my_stream1)) )
{
fputs(work_buffer1, &my_stream0);//wyślij do strumienia 0
}
//pobierz ze strumienia 0
if( strlen(fgets( work_buffer0, sizeof(work_buffer0)-1, &my_stream0)) )
{
fputs(work_buffer0, &my_stream1); //wyślij do strumienia 1
}
#endif
#if (USART_NUMBER==0)
if( strlen(fgets( work_buffer0, sizeof(work_buffer0)-1, &my_stream0)) )
{
fputs(work_buffer0, &my_stream0);
}
#endif
#if (USART_NUMBER==1)
if( strlen(fgets( work_buffer1, sizeof(work_buffer1)-1, &my_stream1)) )
{
fputs(work_buffer1, &my_stream1);
}
#endif

_delay_ms(100);
}
#else
#if (USART_NUMBER==0)||(USART_NUMBER==2)
uart_put_char(0, 'S');
uart_put_string(0,"TART\r\n");
uart_put_string_P(0,PSTR("USART0\r\n"));
uart_put_int(0,-12345);
uart_put_hex(0,0xABCD);
#endif
#if (USART_NUMBER==1)||(USART_NUMBER==2)
uart_put_char(1, 'S');
uart_put_string(1,"TART\r\n");
uart_put_string_P(1,PSTR("USART1\r\n"));
uart_put_int(1,6789);
uart_put_hex(1,0xEF01);
#endif

while (1) {
#if (USART_NUMBER==0)
uart_get_string(0, work_buffer0);
uart_put_string(0, work_buffer0);
#elif (USART_NUMBER==1)
uart_get_string(1, work_buffer1);
uart_put_string(1, work_buffer1);
#else
uart_get_string(0, work_buffer0);
uart_put_string(1, work_buffer0);

uart_get_string(1, work_buffer1);
uart_put_string(0, work_buffer1);
#endif
_delay_ms(100);
}
#endif
}[/syntax]
-uart.h:
[syntax=c]/*
* uart.h
*
* Author: Antystatyczny
* Mod: Krauser
*/

#ifndef UART_H_
#define UART_H_

/************************************************************************************
* Compilation options *
************************************************************************************/
/************************************************************************************
* Enable/disable stream
* 0 - Disabled *
* 1 - Enabled *
*///
#define USE_STREAM 1
/************************************************************************************/
#if USE_STREAM == 0
/************************************************************************************
* Enable/disable transmitting strings from flash memory *
* 0 - Disabled *
* 1 - Enabled *
*/// *
#define USE_PROGMEM 1 // *
//***********************************************************************************

/************************************************************************************
* Enable/disable transmitting integers in decimal format (ASCII transmission) *
* 0 - Disabled *
* 1 - Enabled *
* By disabling this function you can save ca. 200 bytes of flash. *
*/// *
#define USE_INT 1 // *
//***********************************************************************************

/************************************************************************************
* Enable/disable transmitting integers in hexadecimal format (ASCII transmission) *
* 0 - Disabled *
* 1 - Enabled *
* By disabling this function you can save ca. 200 bytes of flash. *
*/// *
#define USE_HEX 1 // *
//***********************************************************************************

/************************************************************************************
* Enable/disable string transmitting *
* 0 - Disabled *
* 1 - Enabled *
*/// *
#define USE_PUT_STRING 1 // *
//***********************************************************************************

/************************************************************************************
* Enable/disable string receiving *
* 0 - Disabled *
* 1 - Enabled *
*/// *
#define USE_GET_STRING 1 // *
//***********************************************************************************
#endif //USE_STREAM

/************************************************************************************
* In some MCU's like ie. ATmega644 you can use usart0,usart1 or both of them. *
* Available options: *
* 0 - For USART0 *
* 1 - For USART1 *
* 2 - For USART0 and USART1 *
*/// *
#define USART_NUMBER 2 // *
//***********************************************************************************

/************************* Buffers and speeds ***************************************
* Below you can change size of usart buffers *
* Available sizes: 4, 8, 16, 32, 64, 128, 256 bytes. *
************************************************************************************/
#if(USART_NUMBER==0)||(USART_NUMBER==2)
/************************************************************************************
* USART0 receiver *
************************************************************************************/
#define RX0_BUFFER_SIZE 16
#define RX0_BUFFER_MASK (RX0_BUFFER_SIZE-1)//do not change

/************************************************************************************
* USART0 transmitter *
************************************************************************************/
#define TX0_BUFFER_SIZE 16
#define TX0_BUFFER_MASK (TX0_BUFFER_SIZE-1)//do not change

/************************************************************************************
* Define USART0 speed *
************************************************************************************/
#define USART0_BAUD 115200
#define __UBRR0 ((F_CPU+USART0_BAUD*8UL) / (16UL*USART0_BAUD)-1)//do not change
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
/************************************************************************************
* USART1 receiver *
************************************************************************************/
#define RX1_BUFFER_SIZE 16
#define RX1_BUFFER_MASK (RX1_BUFFER_SIZE-1)//do not change

/************************************************************************************
* USART1 transmitter *
************************************************************************************/
#define TX1_BUFFER_SIZE 16
#define TX1_BUFFER_MASK (TX1_BUFFER_SIZE-1)//do not change

/************************************************************************************
* Define USART1 speed *
************************************************************************************/
#define USART1_BAUD 115200
#define __UBRR1 ((F_CPU+USART1_BAUD*8UL) / (16UL*USART1_BAUD)-1)//do not change
#endif//USART_NUMBER

/************************************************************************************
* Transmitter functions *
************************************************************************************/
void uart_init(uint8_t usart_nr, uint16_t speed);
void uart_put_char(uint8_t usart_nr, char data);

#if USE_PUT_STRING == 1
void uart_put_string(uint8_t usart_nr, char * string);
#endif //USE_PUT_STRING

#if USE_PROGMEM == 1
void uart_put_string_P(uint8_t usart_nr, const char *string);
#endif //USE_PROGMEM

#if USE_INT == 1
void uart_put_int(uint8_t usart_nr, int16_t data);
#endif//USE_INT

#if USE_HEX == 1
void uart_put_hex(uint8_t usart_nr, int16_t data);
#endif//USE_HEX

/************************************************************************************
* Receiver functions *
************************************************************************************/
char uart_get_char(uint8_t usart_nr);

#if USE_GET_STRING == 1
void uart_get_string(uint8_t usart_nr, char *buffer);
#endif//USE_GET_STRING

/************************* MCU dependent section ************************************/

#if defined(__AVR_ATtiny2313__)||defined(__AVR_ATtiny2313A__)||defined(__AVR_ATtiny4313)
#define RX0_INTERRUPT USART_RX_vect
#define TX0_INTERRUPT USART_TX_vect
#define UDR0_REGISTER UDR
#define UBRR0L_REGISTER UBRRL
#define UBRR0H_REGISTER UBRRH
#define UCSR0B_REGISTER UCSRB
#define TXCIE0_BIT TXCIE
#define RXCIE0_BIT RXCIE
#define TXEN0_BIT TXEN
#define RXEN0_BIT RXEN
#endif

#if defined(__AVR_ATmega48__)||defined(__AVR_ATmega88__)||defined(__AVR_ATmega168__)||defined(__AVR_ATmega328__)
#define RX0_INTERRUPT USART_RX_vect
#define TX0_INTERRUPT USART_TX_vect
#define UDR0_REGISTER UDR0
#define UBRR0L_REGISTER UBRR0L
#define UBRR0H_REGISTER UBRR0H
#define UCSR0B_REGISTER UCSR0B
#define TXCIE0_BIT TXCIE0
#define RXCIE0_BIT RXCIE0
#define TXEN0_BIT TXEN0
#define RXEN0_BIT RXEN0
#endif

#if defined(__AVR_ATmega8__)||defined(__AVR_ATmega8P__)||defined(__AVR_ATmega16__)||defined(__AVR_ATmega32__)
#define RX0_INTERRUPT USART_RXC_vect
#define TX0_INTERRUPT USART_TXC_vect
#define UDR0_REGISTER UDR
#define UBRR0L_REGISTER UBRRL
#define UBRR0H_REGISTER UBRRH
#define UCSR0B_REGISTER UCSRB
#define TXCIE0_BIT TXCIE
#define RXCIE0_BIT RXCIE
#define TXEN0_BIT TXEN
#define RXEN0_BIT RXEN
#endif

#if defined(__AVR_ATmega644__)||defined(__AVR_ATmega644P__)||defined(__AVR_ATmega644PA__)\
||defined(__AVR_ATmega1284P__)||defined(__AVR_ATmega128__)
#if(USART_NUMBER==0)||(USART_NUMBER==2)
#define RX0_INTERRUPT USART0_RX_vect
#define TX0_INTERRUPT USART0_TX_vect
#define UDR0_REGISTER UDR0
#define UBRR0L_REGISTER UBRR0L
#define UBRR0H_REGISTER UBRR0H
#define UCSR0B_REGISTER UCSR0B
#define TXCIE0_BIT TXCIE0
#define RXCIE0_BIT RXCIE0
#define TXEN0_BIT TXEN0
#define RXEN0_BIT RXEN0
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
#define RX1_INTERRUPT USART1_RX_vect
#define TX1_INTERRUPT USART1_TX_vect
#define UDR1_REGISTER UDR1
#define UBRR1L_REGISTER UBRR1L
#define UBRR1H_REGISTER UBRR1H
#define UCSR1B_REGISTER UCSR1B
#define TXCIE1_BIT TXCIE1
#define RXCIE1_BIT RXCIE1
#define TXEN1_BIT TXEN1
#define RXEN1_BIT RXEN1
#endif//USART_NUMBER
#endif//MCU def's

#endif /* UART_H_ */[/syntax]
-uart.c
[syntax=c]/*
* uart.c
*
* Author: Antystatyczny
*
*/

#include
#include
#include
#include
#include"uart.h"

/************************ USART0 ************************************/
enum {locked, unlocked};
#if(USART_NUMBER==0)||(USART_NUMBER==2)
volatile uint8_t interrupt_init_semaphore0 = unlocked;

volatile uint8_t rx0_first_byte, rx0_last_byte;
volatile uint8_t tx0_first_byte, tx0_last_byte;

char rx0_buffer[RX0_BUFFER_SIZE];
char tx0_buffer[TX0_BUFFER_SIZE];
#endif//USART_NUMBER

/************************ USART1 ************************************/
#if(USART_NUMBER==1)||(USART_NUMBER==2)
volatile uint8_t interrupt_init_semaphore1 = unlocked;

volatile uint8_t rx1_first_byte, rx1_last_byte;
volatile uint8_t tx1_first_byte, tx1_last_byte;

char rx1_buffer[RX1_BUFFER_SIZE];
char tx1_buffer[TX1_BUFFER_SIZE];
#endif//USART_NUMBER

/***************************** Init ********************************/
void uart_init(uint8_t usart_nr, uint16_t speed)
{
#if(USART_NUMBER==0)||(USART_NUMBER==2)
if(usart_nr==0)
{
UBRR0L_REGISTER = (uint8_t) speed;
UBRR0H_REGISTER = (speed>>8);
UCSR0B_REGISTER = (1< }
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
if(usart_nr==1)
{
UBRR1L_REGISTER = (uint8_t) speed;
UBRR1H_REGISTER = (speed>>8);
UCSR1B_REGISTER = (1< }
#endif//USART_NUMBER
}

/********************************** TX ****************************/
void uart_put_char(uint8_t usart_nr, char data)
{
#if(USART_NUMBER==0)||(USART_NUMBER==2)
if(usart_nr == 0)
{
tx0_buffer[tx0_last_byte] = data;//pakujemy bajt do bufora
tx0_last_byte = (tx0_last_byte + 1) & TX0_BUFFER_MASK;

while(tx0_first_byte == tx0_last_byte);//niech przerwanie cokolwiek wysle w swiat

if(interrupt_init_semaphore0 == unlocked)
{
interrupt_init_semaphore0 = locked;
UDR0_REGISTER = tx0_buffer[tx0_first_byte];//wywolujemy pierwsze przerwanie
}
}
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
if(usart_nr == 1)
{
tx1_buffer[tx1_last_byte] = data;//pakujemy bajt do bufora
tx1_last_byte = (tx1_last_byte + 1) & TX1_BUFFER_MASK;

while(tx1_first_byte == tx1_last_byte);//niech przerwanie cokolwiek wysle w swiat

if(interrupt_init_semaphore1 == unlocked)
{
interrupt_init_semaphore1 = locked;
UDR1_REGISTER = tx1_buffer[tx1_first_byte];//wywolujemy pierwsze przerwanie
}
}
#endif//USART_NUMBER
}

#if USE_INT == 1
void uart_put_int(uint8_t usart_nr, int16_t data)
{
char temp_buffer[7];//znak wiodacy, 5 bajtow na cyfry oraz NULL
itoa(data, temp_buffer, 10);
switch(usart_nr)
{

#if(USART_NUMBER==0)||(USART_NUMBER==2)
case 0:
uart_put_string(0, temp_buffer);
break;
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
case 1:
uart_put_string(1, temp_buffer);
break;
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
case 2:
uart_put_string(0, temp_buffer);
uart_put_string(1, temp_buffer);
break;
#endif//USART_NUMBER
}
}
#endif//USE_INT

#if USE_HEX == 1
void uart_put_hex(uint8_t usart_nr, int16_t data)
{
char temp_buffer[6];//znak wiodacy, 4 bajty na cyfry oraz NULL
itoa(data, temp_buffer, 16);
switch(usart_nr)
{

#if(USART_NUMBER==0)||(USART_NUMBER==2)
case 0:
uart_put_string(0, temp_buffer);
break;
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
case 1:
uart_put_string(1, temp_buffer);
break;
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
case 2:
uart_put_string(0, temp_buffer);
uart_put_string(1, temp_buffer);
break;
#endif//USART_NUMBER
}
}
#endif//USE_HEX
#if USE_PUT_STRING == 1
void uart_put_string(uint8_t usart_nr, char *string)
{
switch(usart_nr)
{
#if(USART_NUMBER==0)||(USART_NUMBER==2)
case 0:
while(*string) uart_put_char(0, *string++);
break;
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
case 1:
while(*string) uart_put_char(1, *string++);
break;
#endif//USART_NUMBER

#if(USART_NUMBER==2)
case 2:
while(*string) uart_put_char(0, *string++);
while(*string) uart_put_char(1, *string++);
break;
#endif//USART_NUMBER
}
}
#endif
#if USE_PROGMEM == 1
void uart_put_string_P(uint8_t usart_nr, const char *string)
{
switch(usart_nr)
{
#if (USART_NUMBER==0)||(USART_NUMBER==2)
case 0:
while(pgm_read_byte(string)) uart_put_char(0, pgm_read_byte(string++));
break;
#endif//USART_NUMBER

#if (USART_NUMBER==1)||(USART_NUMBER==2)
case 1:
while(pgm_read_byte(string)) uart_put_char(1, pgm_read_byte(string++));
break;
#endif//USART_NUMBER

#if (USART_NUMBER==2)
case 2:
while(pgm_read_byte(string)) uart_put_char(0, pgm_read_byte(string++));
while(pgm_read_byte(string)) uart_put_char(1, pgm_read_byte(string++));
break;
#endif//USART_NUMBER
}
}
#endif//USE_PROGMEM

/**************************** RX ***********************/
char uart_get_char(uint8_t usart_nr)
{
register char temp = 0;
switch(usart_nr)
{
#if (USART_NUMBER==0)||(USART_NUMBER==2)
case 0:
temp = (rx0_first_byte == rx0_last_byte)? 0:rx0_buffer[rx0_first_byte];
if(rx0_first_byte != rx0_last_byte) rx0_first_byte = (rx0_first_byte+1) & RX0_BUFFER_MASK;
break;
#endif//USART_NUMBER

#if (USART_NUMBER==1)||(USART_NUMBER==2)
case 1:
temp = (rx1_first_byte == rx1_last_byte)? 0:rx1_buffer[rx1_first_byte];
if(rx1_first_byte != rx1_last_byte) rx1_first_byte = (rx1_first_byte+1) & RX1_BUFFER_MASK;
break;
#endif//USART_NUMBER
}
return temp;
}

#if USE_GET_STRING == 1
void uart_get_string(uint8_t usart_nr, char *buffer)
{
switch(usart_nr)
{
#if(USART_NUMBER==0)||(USART_NUMBER==2)
case 0:
do *buffer = uart_get_char(0);
while(*buffer++);
break;
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
case 1:
do *buffer = uart_get_char(1);
while(*buffer++);
break;
#endif//USART_NUMBER
}
}
#endif//USE_GET_STRING

#if(USART_NUMBER==0)||(USART_NUMBER==2)

//*************************** Interrupts *************************************
ISR(TX0_INTERRUPT)
{
tx0_first_byte = (tx0_first_byte + 1) & TX0_BUFFER_MASK;
if(tx0_first_byte != tx0_last_byte)
{
UDR0_REGISTER = tx0_buffer[tx0_first_byte];
}
else
{
interrupt_init_semaphore0 = unlocked;
}
}
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
ISR(TX1_INTERRUPT)
{
tx1_first_byte = (tx1_first_byte + 1) & TX1_BUFFER_MASK;
if(tx1_first_byte != tx1_last_byte)
{
UDR1_REGISTER = tx1_buffer[tx1_first_byte];
}
else
{
interrupt_init_semaphore1 = unlocked;
}
}
#endif//USART_NUMBER

#if(USART_NUMBER==0)||(USART_NUMBER==2)
ISR(RX0_INTERRUPT)
{
register char rx0_temp;

rx0_temp = UDR0_REGISTER;

if(rx0_first_byte != (rx0_last_byte+1))
{
if((rx0_temp != '\r') && (rx0_temp != '\n'))
{
rx0_buffer[rx0_last_byte] = rx0_temp;//txt
rx0_last_byte = (rx0_last_byte+1) & RX0_BUFFER_MASK;
}
if(rx0_temp == '\r')
{
rx0_buffer[rx0_last_byte] = 0;//null
rx0_last_byte = (rx0_last_byte+1) & RX0_BUFFER_MASK;
}
}
}
#endif//USART_NUMBER

#if(USART_NUMBER==1)||(USART_NUMBER==2)
ISR(RX1_INTERRUPT)
{
register char rx1_temp;

rx1_temp = UDR1_REGISTER;

if(rx1_first_byte != (rx1_last_byte+1))
{
if((rx1_temp != '\r') && (rx1_temp != '\n'))
{
rx1_buffer[rx1_last_byte] = rx1_temp;//txt
rx1_last_byte = (rx1_last_byte+1) & RX1_BUFFER_MASK;
}
if(rx1_temp == '\r')
{
rx1_buffer[rx1_last_byte] = 0;//null
rx1_last_byte = (rx1_last_byte+1) & RX1_BUFFER_MASK;
}
}
}
#endif//USART_NUMBER[/syntax]

Statystyki: Napisane przez Krauser — 28 lip 2013, o 21:02

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T18:28:47+01:00

w zasadzie jeśli robisz pod konkretny model to możesz zrobić wyłuskiwanie danych (rozbić zdania na konkretne informacje gotowe do prezentacji) jak np Time_GPS(); position_N(); Position_E(); sat_nr(); itd ...

co ułatwi wielu interpretację wysyłanych danych przez GPS

bo inaczej niema sensu .... gdyż i tak wysyła wszystko co potrzeba , a zazwyczaj nas interesuje tylko GGA

Statystyki: Napisane przez SunRiver — 28 lip 2013, o 18:28

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T18:21:31+01:00

Jest tylko jedno ALE Anty

GPSY różnych firm znacznie się różnią od siebie nie tyle konstrukcyjnie co wysyłanymi danymi

głównie chodzi o to że o ile odbiorniki OEM co prawda co 1s wysyłają komplet danych w zdaniach NMEA
to same zdania np najpopularniejsze GGA może być różnie zbudowane i można nie trafić w dane których się spodziewałeś
ponadto jeśli trafisz na odbiornik GPS nie OEM wymagana jest ręczna inicjalizacja i dane otrzymujesz tylko na żądanie poprzez odpytanie modułu o konkretną informację ....

Więc siła rzeczy libs będzie uwiązany z konkretnym typem lub przynajmniej producentem odbiornika GPS

Statystyki: Napisane przez SunRiver — 28 lip 2013, o 18:21

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T17:43:45+01:00

no coś w tym rodzaju , poprostu libs od GPS nie musi nic wiedzieć o uart, wystarczy że dane z uart w przerwaniu albo z bufora będą przekazywane przez funkcje do libsa GPS ... tak ja bym to widział.

Statystyki: Napisane przez xbary — 28 lip 2013, o 17:43

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T17:11:39+01:00

Anty , może libsa od GPS tak zrobić żeby wywoływał ze swojej struktury w której ma wskaźniki funkcji np obsługi wysłania literki i przyjęnia literki drugiej funkcji ... i to by działało na tej zasadzie że w main.c uruchamiasz uart a do GPS libsa dopisujesz tylko funkcje obsługi zdarzenia z gps o wysłanie literki. Zaletą tego jest to że nie konieczne jest później wysyłanie literki uartem, bo można wtedy wysłać czy wpisać do bufora gdzie się chce ... w zależności obsługi zdarzenia od GPS.

Statystyki: Napisane przez xbary — 28 lip 2013, o 17:11

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T17:03:32+01:00

Antystatyczny napisał(a):

Zaczynam widzieć w tym pewien dotąd ukrywany przede mną potencjał.

No ba! to na prawdę jest od dawna bardzo fajnie przemyślane ale chyba jak wszystko w naszym ukochanym że tak powiem C.

Nie mniej jednak próba korzystania z pritf'a na takim przecież procku który też ma sprzętowy UART jak np ATtiny2313 spowoduje że programista poużywa sobie jak przysłowiowy pies w studni .... bo po pierwszym-drugim użyciu zabraknie FLASH'a na wszystko inne.

A tymczasem do prostych aplikacji i takie procki się używa z takimi urządzeniami czy to gps czy gsm. Wiadomo też że zależy na jaką drogę decydujemy się przy tworzeniu LIB'sa

aha - fajnie ten sposób podmiany strumienia opisany był w serii kursu języka C (jednego z lepszych moim zdaniem), który ukazał się kiedyś na łamach EP. Jeśli może masz dostęp do archiwalnych numerów to śmiało możesz tam zajrzeć.

Statystyki: Napisane przez mirekk36 — 28 lip 2013, o 17:03

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T16:40:39+01:00

Jeśli ja coś mogę zauważyć, to....

ale najpierw uprzedzam, że wcale mi nie chodzi o to aby forsować akurat rozwiązania, których ja używałem

Anty - chcesz zrobić super uniwersalną bibliotekę - powiedziałbym hermetyczną i czystą ... Super. Czyli na końcu może z niej powstać wręcz prawdziwa biblioteka - bo już kiedyś też gdzieś pisałem ale nie tylko ja, że to co my tu zwykle robimy i sobie używamy określenia że robimy LIB'sy to tak na prawdę nie są żadne lib'sy . Prawdziwie biblioteki to te skompilowane do postaci (bodajże *.a) i można ich używać rzeczywiście tak jak

#include

później. W takim przypadku ja np też może i próbowałbym w tym co mówisz pójść drogą printf'a ... czyli podmianą strumienia itp bo wtedy mamy rzeczywiście pełną uniwersalność i praktycznie na każdy AVR

ale czy ty rzeczywiście chcesz taką bibliotekę *.a przygotować ?

Jeśli nie, a zależy ci na tym aby była ona np wygodna dla wszystkich to jednak warto pokusić się o dodanie nawet własnego LIB'sa do UART'a który poprzez kilka funkcji styka się z twoim UART'em. I to przecież przez kilka pewnie typowych funkcji takich jak do przesłania znaku, stringa, liczby itp bo czegóż więcej. A zatem na prawdę łatwo byłoby każdemu podłączyć w to miejsce jakąś inną 'ala' własną czy cudzą bibliotekę

natomiast podmiana strumienia i przystosowanie do printf'a może (ale to TYLKO moje nieobiektywne zdanie) raczej hmmm skomplikować całość do wykorzystania takiego LIB'sa dla przysłowiowego "jana kowalskiego"

Jeśli zaś zależy ci na tym aby kod był mega uniwersalny i przenośny między platformami to już można to zrozumieć - chociaż i tu będzie potworny haczyk. Bo czy tak czy siak przeniesienie takiej biblioteki np na PIC'a będzie i tak wymagało ogromnej ingerencji i przeróbek

z TRZECIEJ zaś strony - jeśli potraktować to jako samo szkolenie się w opracowywaniu bibliotek *.a - to bardzo fajna okazja

zresztą jak znam życie to nie ważne jakim sposobem to zrobisz i tak pewnie jak to zwykle u ciebie bywa niesamowicie zaskoczysz wszystkich pozytywnie i tego ci życzę

Statystyki: Napisane przez mirekk36 — 28 lip 2013, o 16:40

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T16:18:48+01:00

Napisz własną .

Statystyki: Napisane przez Gość — 28 lip 2013, o 16:18

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T15:58:06+01:00

A to ok, nie zrozumiałem intencji . A sam unikam printfa jak ognia .

Statystyki: Napisane przez Gość — 28 lip 2013, o 15:58

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T15:45:09+01:00

No ale co za problem . Wiesz u Mirka też trzeba posiedzieć chwilę by przystosować biblioteki czy soft, do innej biblioteki, ale dzieki temu że wszystko jest przejrzyste nie stwarza to problemu.
A tak jak wrzucisz do libsa GPSu obsługę sprzętową AVRowego UARTu to dupa, przerobić to np. na freescale nie będzie już tak łatwo. A tak zmieniasz tylko deklaracje funkcji podpinasz inną bibliotekę UARTa i działa.

------------------------ [ Dodano po: 2 minutach ]

Krauser napisał(a):

Użyj strumienia i w kodzie będziesz miał zawsze printf.

Ale czy to dobry sposób? 2K kodu dodatkowo tylko dla samego printf?

Statystyki: Napisane przez Gość — 28 lip 2013, o 15:45

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T15:44:27+01:00

Użyj strumienia i w kodzie będziesz miał zawsze printf.

Statystyki: Napisane przez Krauser — 28 lip 2013, o 15:44

Re: Pytanie o zależności pomiędzy libsami.

2013-07-28T15:38:51+01:00

Nie no, jak u Mirka bym powiedział jest wzorcowo, po co wyważać otwarte drzwi.
Po prostu umieszczamy bibliotekę w libsach potrzebną do obsługi UARTa i tyle.
Kod jest wtedy bardziej przenośny.

Statystyki: Napisane przez Gość — 28 lip 2013, o 15:38