BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Masz problem z Arduino? Tutaj możesz szukać pomocy.
ODPOWIEDZ
Awatar użytkownika
Procent
Młodszy majsterkowicz
Posty: 21
Rejestracja: 6 lis 2013, 14:46
Kontakt:

BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: Procent » 18 lis 2013, 20:33

"Co to są te biblioteki i z czym to się je?"

Walcząc z tematem Nawadnianie trawnika ( http://majsterkowo.pl/forum/post9081.html#p9081 ) doszedłem do wniosku że warto zadać pytanie o tak ważną rzecz w programowaniu na Arduino (i nie tylko Arduino) jak BIBLIOTEKI

Biblioteki to fantastyczna sprawa (tak mogę podejrzewać) - MASZ GOTOWCA I TYLKO GO UŻYWAĆ !

ba ... ale jak on naprawdę jest skonstruowany ten gotowiec i jak naprawdę z nim "gadać" ???

naprawdę nie znalazłem w necie takiego tematu ... Wszyscy piszą o tym jaką bibliotekę do czego wykorzystać... ale nie ma info dla maluczkich - z czego to się tak naprawdę składa i jak się z tym komunikować.

Potrzebuję wykorzystać bibliotekę do obsługi Zegara Czasu Rzeczywistego (RTC) i najbardziej chciałbym się o niej czegoś dowiedzieć więc na tym oprę dalsze wypociny:

Co wiem (jak mniemam hehe):

Biblioteki to pliki które ładują się do naszego programu jeśli zostaną tam "wywołane" z pamięci programu do obsługi Arduino. Pojawia się wtedy w kodzie linia rozpoczęta znakiem "#" a w moim przypadku #include <RTClib.h>

Poza tą linią programu nie widzimy NIC
Co zatem zawiera tak naprawdę taka biblioteka?
Co robi taka biblioteka?
Jak z nią się komunikować?
Gdzie znaleźć informacje o niej i o sposobie komunikacji?

Po zainstalowaniu takiej biblioteki można podejrzeć w katalogu (w którym się ona rozpakowała) że istnieją tam różne pliki a nawet katalogi.
Biblioteka musi zawierać co najmniej dwa pliki "***.h" oraz "***.cpp (gdzieś wyczytałem w trakcie swojego krótkiego arduinowego życia że te dwa to podstawa)

W mojej bibliotece do obsługi zegara jest jeszcze plik tekstowy "keywords" czyli "słowa kluczowe"
Do tego dołączony jest też katalog "examples" zawierający przykłady kodów które coś wykonują z taką biblioteką. W nim można podglądnąć jak używać takiej biblioteki ale ...

Czy mógłby ktoś wyjaśnić jak krowie na rowie -

CO TO SĄ TE KEYWORDS I PO CO TO ?
CZY NALEŻY PATRZEĆ W TE PLIKI BIBLIOTECZNE ŻEBY BIBLIOTEKĘ ZROZUMIEĆ?
W pliku "***.h" są jakieś klasy a w pliku "***.cpp" jest program który ich używa?

No ludzie - NIECH KTOŚ NAPISZE CO TU JEST SILNIKIEM A CO SKRZYNIĄ BIEGÓW I JAK SIĘ TO OBSŁUGUJE !

najlepiej jak dla faceta (ale takiego który ma jeszcze mniej niż roczek)
Codzienne zmagania:
http://www.ertec.pl/

Co miesiąc do wygrania nagrody o wartości ponad 1600 zł!


Awatar użytkownika
rafalzaq
Majsterkowicz
Posty: 180
Rejestracja: 2 maja 2013, 23:57

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: rafalzaq » 18 lis 2013, 21:16

Generalnie z bibliotekami jest tak, że masz wiedzieć jakich funkcjonalności dostarczają i jak się ich używa. Do biblioteki powinna być dołączona jakaś dokumentacja żeby wszystko wiedzieć. To w jaki sposób jest wszystko zrealizowane zasadniczo nie ma znaczenia i się tym nie musisz interesować. Oczywiście kod masz dostępny i możesz tam zaglądać jeśli chcesz poszerzać swoją wiedzę (lub nawet poprawić bibliotekę).
Biblioteki do arduino to zwykle klasy, a klasy w C++ zwyczajowo zapisuje się w dwóch plikach. W pliku nagłówkowym (.h) są tylko informacje o klasie i jej metodach (funkcjach), a w drugim pliku (.cpp) znajduje się już konkretny kod.
Bibliotekę można przyrównać do takiej czarnej skrzynki. Masz jakieś wejścia, do których coś dajesz i w efekcie masz coś na wyjściu (czy to sama funkcja zwraca czy też na ekranie). Bym powiedział, że to nawet cały samochód (oczywiście to zależy co zdefiniujemy jako najmniejszy, niepodzielny element). Do samochodu wlewasz paliwo (jakieś wejście), wciskasz pedał gazu (inne wejście) i w efekcie masz jakąś prędkość (wyjście). Teoretycznie nie musisz wiedzieć czy i jaki masz silnik albo jakie koloru są jakieś wężyki. Musisz tylko wiedzieć co masz dać na wejściu (rodzaj i ilość paliwa czy w jaki sposób obsługiwać pedał gazu) i co w efekcie otrzymasz.
Awatar użytkownika
cube
Złota rączka
Posty: 834
Rejestracja: 2 gru 2012, 17:02

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: cube » 18 lis 2013, 22:06

To ja powiem tak.
Każdy program na arduino składa się z dwóch głównych części. void setup() i void loop(). To są dwie główne funkcje programu, gdzie konfigurujesz go i podajesz co ma robić bez końca. setup jest wywoływana tylko raz, po włączeniu zasilania, loop to pętla główna, która wywoływana jest bez końca. Ale możesz stworzyć własną funkcję, przed lub za funkcją loop. Program wtedy będzie wyglądać tak:

Kod: Zaznacz cały

void setup(){
(bla bla bla)
}
void loop(){
(bla bla bla)
}
void moja_funkcja(){
a=a+1;
}
moja_funkcja() ma jedno zadanie. Powiększyć zmienną a o 1. funkcja zostanie wykonana tylko, jeśli zostanie wywołana w trakcie pętli głównej:

Kod: Zaznacz cały

void setup(){
(bla bla bla)
}
void loop(){
(bla bla bla)
moja_funkcja();
(bla bla bla)
}
void moja_funkcja(){
a=a+1;
}
W ten sposób operację powiększania o 1 możemy wywołać w dowolnym momencie poprzez wywołanie funkcji. Oczywiście można użyć w kodzie, za kazdym razem, a=a+1; ale wyobraź sobie że masz takich operacji trzydzieści i każdą chcesz zmienić z a=a+1 na a=a+2. Jeśli będzie to "na zewnątrz" głównej pętli, musisz zmienić kod tylko w jednym miejscu. Jeśli nie wyciągniesz tego - trzydzieści razy będziesz przeklikiwał jedynkę na dwójkę. Niektóre bardziej rozbudowane operacje jak wysłanie całego pakietu danych, określonym protokołem, były by bardzo żmudne do wielokrotnego pisania. Również bardzo utrudniły by analizę kodu. Można więc je "wyjąć" z pętli głównej, do funkcji. A teraz wyobraź sobie że ta skomplikowana operacja jest uniwersalna i przydatna wielu ludziom. Więc można ją wyciągnąć dalej, do oddzielnego pliku, aby łatwo było się nią podzielić. Czyli zamiast odwoływać się do funkcji w kodzie, odwołujemy się do funkcji zapisanej w innym pliku. Nagłówek #include informuje kompilator w których plikach ma szukać źródła wywoływanej funkcji.
Każda instrukcja typu digitalWrite(), analogRead() jest funkcją biblioteki standardowej Arduino.h (WProgram.h w starszych IDE). Biblioteki standardowej nie musisz załączać, bo robi to za Ciebie kompilator. Ale resztę już musisz mu wskazać.
Awatar użytkownika
Procent
Młodszy majsterkowicz
Posty: 21
Rejestracja: 6 lis 2013, 14:46
Kontakt:

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: Procent » 19 lis 2013, 08:45

Generalnie z bibliotekami jest tak, że masz wiedzieć jakich funkcjonalności dostarczają i jak się ich używa. Do biblioteki powinna być dołączona jakaś dokumentacja żeby wszystko wiedzieć. To w jaki sposób jest wszystko zrealizowane zasadniczo nie ma znaczenia i się tym nie musisz interesować.
No właśnie - dokładnie tak to sobie wyobrażałem. Ale na co konkretnie patrzeć przykładowo właśnie w biibliotece RTClib która obsługuje zegar? Pytanie głównie brzmi - GDZIE SĄ INFORMACJE JAK OBSŁUŻYĆ BIBLIOTEKĘ
Chcę głównie odczytywać dane z zegara co jakiś czas. Gdzie szukac tej \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"instrukcji obsługi\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
Oczywiście kod masz dostępny i możesz tam zaglądać jeśli chcesz poszerzać swoją wiedzę (lub nawet poprawić bibliotekę).
Biblioteki do arduino to zwykle klasy, a klasy w C++ zwyczajowo zapisuje się w dwóch plikach. W pliku nagłówkowym (.h) są tylko informacje o klasie i jej metodach (funkcjach), a w drugim pliku (.cpp) znajduje się już konkretny kod.
Czyli że nie muszę zaglądać wewnątrz tych plików lecz szukać informacji (o obsłudze biblioteki) w dodatkowej dokumentacji?
Tak wyglądają pliki tej biblioteki o której mowa:
PLIK \\\\\\\"h\\\\\\\":

Kod: Zaznacz cały

// Code by JeeLabs http://news.jeelabs.org/code/
// Released to the public domain! Enjoy!

#ifndef _RTCLIB_H_
#define _RTCLIB_H_

// Simple general-purpose date/time class (no TZ / DST / leap second handling!)
class DateTime {
public:
    DateTime (uint32_t t =0);
    DateTime (uint16_t year, uint8_t month, uint8_t day,
                uint8_t hour =0, uint8_t min =0, uint8_t sec =0);
    DateTime (const char* date, const char* time);
    uint16_t year() const       { return 2000 + yOff; }
    uint8_t month() const       { return m; }
    uint8_t day() const         { return d; }
    uint8_t hour() const        { return hh; }
    uint8_t minute() const      { return mm; }
    uint8_t second() const      { return ss; }
    uint8_t dayOfWeek() const;

    // 32-bit times as seconds since 1/1/2000
    long secondstime() const;   
    // 32-bit times as seconds since 1/1/1970
    uint32_t unixtime(void) const;

protected:
    uint8_t yOff, m, d, hh, mm, ss;
};

// RTC based on the DS1307 chip connected via I2C and the Wire library
class RTC_DS1307 {
public:
    static uint8_t begin(void);
    static void adjust(const DateTime& dt);
    uint8_t isrunning(void);
    static DateTime now();
};

// RTC using the internal millis() clock, has to be initialized before use
// NOTE: this clock won\\\\\\\'t be correct once the millis() timer rolls over (>49d?)
class RTC_Millis {
public:
    static void begin(const DateTime& dt) { adjust(dt); }
    static void adjust(const DateTime& dt);
    static DateTime now();

protected:
    static long offset;
};

#endif // _RTCLIB_H_
i plik \\\\\\\"cpp\\\\\\\"

Kod: Zaznacz cały

// Code by JeeLabs http://news.jeelabs.org/code/
// Released to the public domain! Enjoy!

#include <Wire.h>
#include \\\\\\\"RTClib.h\\\\\\\"
#ifdef __AVR__
 #include <avr/pgmspace.h>
 #define WIRE Wire
#else
 #define PROGMEM
 #define pgm_read_byte(addr) (*(const unsigned char *)(addr))
 #define WIRE Wire1
#endif

#define DS1307_ADDRESS 0x68
#define SECONDS_PER_DAY 86400L

#define SECONDS_FROM_1970_TO_2000 946684800

#if (ARDUINO >= 100)
 #include <Arduino.h> // capital A so it is error prone on case-sensitive filesystems
#else
 #include <WProgram.h>
#endif

////////////////////////////////////////////////////////////////////////////////
// utility code, some of this could be exposed in the DateTime API if needed

const uint8_t daysInMonth [] PROGMEM = { 31,28,31,30,31,30,31,31,30,31,30,31 };

// number of days since 2000/01/01, valid for 2001..2099
static uint16_t date2days(uint16_t y, uint8_t m, uint8_t d) {
    if (y >= 2000)
        y -= 2000;
    uint16_t days = d;
    for (uint8_t i = 1; i < m; ++i)
        days += pgm_read_byte(daysInMonth + i - 1);
    if (m > 2 && y % 4 == 0)
        ++days;
    return days + 365 * y + (y + 3) / 4 - 1;
}

static long time2long(uint16_t days, uint8_t h, uint8_t m, uint8_t s) {
    return ((days * 24L + h) * 60 + m) * 60 + s;
}

////////////////////////////////////////////////////////////////////////////////
// DateTime implementation - ignores time zones and DST changes
// NOTE: also ignores leap seconds, see http://en.wikipedia.org/wiki/Leap_second

DateTime::DateTime (uint32_t t) {
  t -= SECONDS_FROM_1970_TO_2000;    // bring to 2000 timestamp from 1970

    ss = t % 60;
    t /= 60;
    mm = t % 60;
    t /= 60;
    hh = t % 24;
    uint16_t days = t / 24;
    uint8_t leap;
    for (yOff = 0; ; ++yOff) {
        leap = yOff % 4 == 0;
        if (days < 365 + leap)
            break;
        days -= 365 + leap;
    }
    for (m = 1; ; ++m) {
        uint8_t daysPerMonth = pgm_read_byte(daysInMonth + m - 1);
        if (leap && m == 2)
            ++daysPerMonth;
        if (days < daysPerMonth)
            break;
        days -= daysPerMonth;
    }
    d = days + 1;
}

DateTime::DateTime (uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t min, uint8_t sec) {
    if (year >= 2000)
        year -= 2000;
    yOff = year;
    m = month;
    d = day;
    hh = hour;
    mm = min;
    ss = sec;
}

static uint8_t conv2d(const char* p) {
    uint8_t v = 0;
    if (\\\\\\\'0\\\\\\\' <= *p && *p <= \\\\\\\'9\\\\\\\')
        v = *p - \\\\\\\'0\\\\\\\';
    return 10 * v + *++p - \\\\\\\'0\\\\\\\';
}

// A convenient constructor for using \\\\\\\"the compiler\\\\\\\'s time\\\\\\\":
//   DateTime now (__DATE__, __TIME__);
// NOTE: using PSTR would further reduce the RAM footprint
DateTime::DateTime (const char* date, const char* time) {
    // sample input: date = \\\\\\\"Dec 26 2009\\\\\\\", time = \\\\\\\"12:34:56\\\\\\\"
    yOff = conv2d(date + 9);
    // Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec 
    switch (date[0]) {
        case \\\\\\\'J\\\\\\\': m = date[1] == \\\\\\\'a\\\\\\\' ? 1 : m = date[2] == \\\\\\\'n\\\\\\\' ? 6 : 7; break;
        case \\\\\\\'F\\\\\\\': m = 2; break;
        case \\\\\\\'A\\\\\\\': m = date[2] == \\\\\\\'r\\\\\\\' ? 4 : 8; break;
        case \\\\\\\'M\\\\\\\': m = date[2] == \\\\\\\'r\\\\\\\' ? 3 : 5; break;
        case \\\\\\\'S\\\\\\\': m = 9; break;
        case \\\\\\\'O\\\\\\\': m = 10; break;
        case \\\\\\\'N\\\\\\\': m = 11; break;
        case \\\\\\\'D\\\\\\\': m = 12; break;
    }
    d = conv2d(date + 4);
    hh = conv2d(time);
    mm = conv2d(time + 3);
    ss = conv2d(time + 6);
}

uint8_t DateTime::dayOfWeek() const {    
    uint16_t day = date2days(yOff, m, d);
    return (day + 6) % 7; // Jan 1, 2000 is a Saturday, i.e. returns 6
}

uint32_t DateTime::unixtime(void) const {
  uint32_t t;
  uint16_t days = date2days(yOff, m, d);
  t = time2long(days, hh, mm, ss);
  t += SECONDS_FROM_1970_TO_2000;  // seconds from 1970 to 2000

  return t;
}

////////////////////////////////////////////////////////////////////////////////
// RTC_DS1307 implementation

static uint8_t bcd2bin (uint8_t val) { return val - 6 * (val >> 4); }
static uint8_t bin2bcd (uint8_t val) { return val + 6 * (val / 10); }

uint8_t RTC_DS1307::begin(void) {
  return 1;
}


#if (ARDUINO >= 100)

uint8_t RTC_DS1307::isrunning(void) {
  WIRE.beginTransmission(DS1307_ADDRESS);
  WIRE.write(0);
  WIRE.endTransmission();

  WIRE.requestFrom(DS1307_ADDRESS, 1);
  uint8_t ss = WIRE.read();
  return !(ss>>7);
}

void RTC_DS1307::adjust(const DateTime& dt) {
    WIRE.beginTransmission(DS1307_ADDRESS);
    WIRE.write(0);
    WIRE.write(bin2bcd(dt.second()));
    WIRE.write(bin2bcd(dt.minute()));
    WIRE.write(bin2bcd(dt.hour()));
    WIRE.write(bin2bcd(0));
    WIRE.write(bin2bcd(dt.day()));
    WIRE.write(bin2bcd(dt.month()));
    WIRE.write(bin2bcd(dt.year() - 2000));
    WIRE.write(0);
    WIRE.endTransmission();
}

DateTime RTC_DS1307::now() {
  WIRE.beginTransmission(DS1307_ADDRESS);
  WIRE.write(0);	
  WIRE.endTransmission();

  WIRE.requestFrom(DS1307_ADDRESS, 7);
  uint8_t ss = bcd2bin(WIRE.read() & 0x7F);
  uint8_t mm = bcd2bin(WIRE.read());
  uint8_t hh = bcd2bin(WIRE.read());
  WIRE.read();
  uint8_t d = bcd2bin(WIRE.read());
  uint8_t m = bcd2bin(WIRE.read());
  uint16_t y = bcd2bin(WIRE.read()) + 2000;
  
  return DateTime (y, m, d, hh, mm, ss);
}

#else

uint8_t RTC_DS1307::isrunning(void) {
  WIRE.beginTransmission(DS1307_ADDRESS);
  WIRE.send(0);	
  WIRE.endTransmission();

  WIRE.requestFrom(DS1307_ADDRESS, 1);
  uint8_t ss = WIRE.receive();
  return !(ss>>7);
}

void RTC_DS1307::adjust(const DateTime& dt) {
    WIRE.beginTransmission(DS1307_ADDRESS);
    WIRE.send(0);
    WIRE.send(bin2bcd(dt.second()));
    WIRE.send(bin2bcd(dt.minute()));
    WIRE.send(bin2bcd(dt.hour()));
    WIRE.send(bin2bcd(0));
    WIRE.send(bin2bcd(dt.day()));
    WIRE.send(bin2bcd(dt.month()));
    WIRE.send(bin2bcd(dt.year() - 2000));
    WIRE.send(0);
    WIRE.endTransmission();
}

DateTime RTC_DS1307::now() {
  WIRE.beginTransmission(DS1307_ADDRESS);
  WIRE.send(0);	
  WIRE.endTransmission();
  
  WIRE.requestFrom(DS1307_ADDRESS, 7);
  uint8_t ss = bcd2bin(WIRE.receive() & 0x7F);
  uint8_t mm = bcd2bin(WIRE.receive());
  uint8_t hh = bcd2bin(WIRE.receive());
  WIRE.receive();
  uint8_t d = bcd2bin(WIRE.receive());
  uint8_t m = bcd2bin(WIRE.receive());
  uint16_t y = bcd2bin(WIRE.receive()) + 2000;
  
  return DateTime (y, m, d, hh, mm, ss);
}

#endif


////////////////////////////////////////////////////////////////////////////////
// RTC_Millis implementation

long RTC_Millis::offset = 0;

void RTC_Millis::adjust(const DateTime& dt) {
    offset = dt.unixtime() - millis() / 1000;
}

DateTime RTC_Millis::now() {
  return (uint32_t)(offset + millis() / 1000);
}

////////////////////////////////////////////////////////////////////////////////
Ostatnio zmieniony 19 lis 2013, 18:46 przez Procent, łącznie zmieniany 1 raz.
Codzienne zmagania:
http://www.ertec.pl/
Awatar użytkownika
wojtekizk
Starszy majsterkowicz
Posty: 311
Rejestracja: 19 lis 2013, 10:54
Lokalizacja: Bydgoszcz

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: wojtekizk » 19 lis 2013, 12:10

I ja dołączę swoje 3 grosze do tematu. Generalnie koledzy wyjaśnili z grubsza sedno sprawy. Model czarnej skrzynki wydaję się być tutaj najodpowiedniejszy, tyle że masz także w bibliotece narzędzia jak z niej samej korzystać. Powinieneś z pliku nagłówkowego *.h odczytać nazwy używanych zmiennych i funkcji. W przypadku funkcji musisz przynajmniej wiedzieć co robi, tzn. jakich argumentów używa i jakie zwraca wartości. Niestety na tym etapie potrzebna jest znajomość języka C++ w minimalnym stopniu chociaż. Ale jest na to także rada - w każdej porządnej bibliotece znajdziesz folder examples gdzie są zamieszczone przykładowe kody. Wystarczy tylko pobieżnie chociaż przeanalizować taki przykład lub co jeszcze lepsze - podpiąć swoje arduino, potem skompilować i załadować taki przykład a następnie poobserwować co program wyprawia z Twoją płytką :-) Będziesz już teraz wiedział co robi dana funkcja i jak jej użyć w Twoim projekcie. Ja przy pracy z nieznaną biblioteką kopiuję sobie plik *.h oraz taki przykład do notepada ++ i potem mam z czego zassać :-).
Tak na marginesie lektura bibliotek jest tutaj kopalnią wiedzy. Standardowe biblioteki są w katalogu libraries natomiast wszystkie inne - dołączone w katalogu \\\\\\\'Moje Dokumenty\\\\\\\\arduino\\\\\\\\libraries\\\\\\\'.
W IDE Arduino masz opcję : Szkic -> Importuj bibliotekę ->Add Library . Potem wskazujesz spakowany plik biblioteki z rozszerzeniem *.zip i Arduino zaciągnie bibliotekę do \\\\\\\'Moje Dokumenty\\\\\\\\arduino\\\\\\\\libraries\\\\\\\'. W ten katalog możesz wrzucać także już wcześniej rozpakowane biblioteki. Jeżeli w trakcie kompilacji Twojego programiku wywalają się błędy związane z nazwami funkcji bibliotecznych najpierw sprawdź, czy oby sama biblioteka jest właśnie w tym katalogu, bo arduino będzie jej tam szukał. To częsty błąd popełniany przy migracji kodów źródłowych - kod jest a biblioteka nie :-).
Większość dostępnych płytek(shields) dla ARDUINO ma także podane linki do stron gdzie można pobrać bibliotekę obsługującą danego shielda.
pozdrawiam ... wojtekizk ([email protected])
Ostatnio zmieniony 19 lis 2013, 21:02 przez wojtekizk, łącznie zmieniany 1 raz.
Awatar użytkownika
Procent
Młodszy majsterkowicz
Posty: 21
Rejestracja: 6 lis 2013, 14:46
Kontakt:

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: Procent » 19 lis 2013, 19:24

Coś się chyba pierniczy z cytowaniem postów albo my nie umiemy ...
Cytuję więc kolegę cube:
To ja powiem tak.
Każdy program na arduino składa się z dwóch głównych części. void setup() i void loop(). To są dwie główne funkcje programu, gdzie konfigurujesz go i podajesz co ma robić bez końca. setup jest wywoływana tylko raz, po włączeniu zasilania, loop to pętla główna, która wywoływana jest bez końca. Ale możesz stworzyć własną funkcję, przed lub za funkcją loop. Program wtedy będzie wyglądać tak:

Kod: Zaznacz cały

void setup(){
(bla bla bla)
}
void loop(){
(bla bla bla)
}
void moja_funkcja(){
a=a+1;
}
moja_funkcja() ma jedno zadanie. Powiększyć zmienną a o 1. funkcja zostanie wykonana tylko, jeśli zostanie wywołana w trakcie pętli głównej:

Kod: Zaznacz cały

void setup(){
(bla bla bla)
}
void loop(){
(bla bla bla)
moja_funkcja();
(bla bla bla)
}
void moja_funkcja(){
a=a+1;
}
Czyli cube wracasz tu uparcie do tego co wskazywałeś mi już dwukrotnie ( http://arduino.cc/en/Reference/FunctionDeclaration) - DZIĘKI - zaczynam to doceniać. :-)

Takie zewnętrzne funkcje (poza pętlą loop) zostają w końcu zapisane jako biblioteki (w uproszczeniu ujmując).
Odwołujemy się do nich poprzez wywołania w naszym pisanym kodzie.

Tylko że ja po prostu usiłuję dociec gdzie jest instrukcja obsługi danej biblioteki. Z tego co tu piszecie (np wojtekizk) to - nie ma (albo rzadko ) jest taka instrukcja obsługi i trzeba jednak zagłębiać się w pliki biblioteki lub przykłady do niej dołączone aby zrozumieć jak się tym posługiwać.

Dla osób znających C++ to pewnie trywialność. Dla początkujących makabra.
Ja usiłuję zrozumieć co mi jest potrzebne żeby napisać prymitywny kod. Takie wiadomości przydały by się też innym początkującym - jak komunikować się z biblioteką i gdzie szukać informacji o sposobie komunikacji

Ostatnio podano mi taką bibliotekę do obsługi silnika krokowego która zdaje się być super dobrze opisana (ale aż za dobrze hehe). Link prowadzi do strony bardzo rozbudowanej która mówi chyba wszystko na temat tej biblioteki. W tym przypadku gubię się w nadmiarze informacji. Tu link http://www.airspayce.com/mikem/arduino/ ... epper.html

Czyli panowie (pań nie zauważyłem) - nie ma jednoznacznych miejsc w których jest opisany sposób komunikacji z biblioteką i trzeba zagłębiać się w przykłady oraz pliki tej biblioteki???
Codzienne zmagania:
http://www.ertec.pl/
Awatar użytkownika
cube
Złota rączka
Posty: 834
Rejestracja: 2 gru 2012, 17:02

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: cube » 19 lis 2013, 19:39

To fakt, nie każda biblioteka jest dobrze udokumentowana. Czasem brakuje nawet wypisu wszystkich jej funkcji i argumentów jakie można/należy im podać. Wtedy zostają przykłady i przeglądanie kodów innych osób, które jej użyły.
Awatar użytkownika
Procent
Młodszy majsterkowicz
Posty: 21
Rejestracja: 6 lis 2013, 14:46
Kontakt:

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: Procent » 19 lis 2013, 19:47

[quote=\\\\\\\"cube\\\\\\\"]To fakt, nie każda biblioteka jest dobrze udokumentowana. Czasem brakuje nawet wypisu wszystkich jej funkcji i argumentów jakie można/należy im podać. Wtedy zostają przykłady i przeglądanie kodów innych osób, które jej użyły.[/quote]
a co myślisz cube o tej bibliotece do silników krokowych i o jej opisach ? Zerknij na tamten link i powiedz gdzie szukac (w jakiej zakładce) najlepiej ... (sposobów komunikacji)

albo opisz co jaka zakładka mniej więcej mówi...
To może pomóc - zwłaszcza że akurat mi potrzebna jest taka biblioteka to innego projektu związanego z silnikiem krokowym (ale to już inna bajka)

PS
co się dzieje z cytowaniem ??
Codzienne zmagania:
http://www.ertec.pl/
Awatar użytkownika
wojtekizk
Starszy majsterkowicz
Posty: 311
Rejestracja: 19 lis 2013, 10:54
Lokalizacja: Bydgoszcz

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: wojtekizk » 19 lis 2013, 20:43

Tak to już jest niestety. Coś takiego jak dobrze udokumentowana biblioteka w stricte darmowych środowiskach programistycznych praktycznie nie istnieje. To darmowy kod, darmowe oprogramowanie i dobra wola ich twórców. Coś za coś niestety. Komercyjne pakiety kosztują niestety często pieniądze nie warte ich zawartości - patrz np. Microsoft Office - chłam z każdą kolejną wersją kosztuje jeszcze więcej i coraz bardziej wkurza nowym wyglądem, po prostu coraz trudniej cokolwiek znaleźć i komu to przeszkadzało żeby to całkiem pozmieniać?... a już Office 2013, który śmiga tylko z podłączonym netem to już kompletna paranoja - gdzie wersja na CD?
Tutaj jesteś natomiast członkiem ogromnej społeczności, która za darmochę tworzy kawał dobrej roboty dla wszystkich.
Reasumując trudno tu komuś tak od A do Z pomóc... Staraj się poznawać podstawy C++, kup na początek jakąś pozycję z serii \"dla opornych\" (sorry nie wyśmiewam się bynajmniej), to dla opornych to wymysł wydawców, taki \"chłyt reklamowy\" jak mawia pewien chiński emigrant w kabarecie :-)
A wracając do tematu w pliku *.h masz deklaracje wszystkich zmiennych i funkcji a w examples kilka przykładów... staraj się je czytać i zrozumieć. Jak dotąd nie ma jeszcze na polskim rynku pozycji godnej polecenia traktującej o ARDUINO... ale jest światełko w tunelu - Helion po 23.11.2013 wypuszcza \"Arduino. 65 praktycznych projektów\" ...niestety to o zgrozo dokładne tłumaczenie oryginału, bez odrobiny własnej inwencji... szkoda. Oryginał po angielsku znajdziesz na chomiku, więc jeśli znasz język to nie warto wydawać 70 zł. lepiej kupić ze 2 shieldy :-)
pozdrawiam ... wojtekizk ([email protected])
Awatar użytkownika
rafalzaq
Majsterkowicz
Posty: 180
Rejestracja: 2 maja 2013, 23:57

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: rafalzaq » 19 lis 2013, 21:44

No niestety z tą dokumentacją nie zawsze jest tak różowo. Jeśli nie ma żądnych plików z opisem czy przykładami, a na stronie \'producenta\' tez pustki to musisz szukać po internecie jakichś przykładów. Problem pojawia się gdy już coś znajdziesz, a tu okazuje się, że biblioteka nazywa się tak samo, ale funkcje są zupełnie inne.
Jeśli trafisz na tak dobrze opisaną bibliotekę i się gubisz lub po prostu nie masz ochoty na zapoznawanie się ze wszystkimi możliwymi funkcjami jeśli użyjesz np. tylko 10% to warto zajrzeć w pierwszej kolejności do przykładów (jeśli są). Jeśli przykładów nie ma to krótkie poszukiwania w googlu. Jeśli dalej nic ciekawego się nie trafi to trzeba przeczytać przynajmniej opis konstruktorów i nazwy funkcji (bo nazwy powinny mówić co robi funkcja).

Podsumowując. Nie, nie ma żadnego miejsca gdzie muszą się znajdować opisy bibliotek. Autor powinien przynajmniej jakiś krótki opis zamieścić.
Awatar użytkownika
Procent
Młodszy majsterkowicz
Posty: 21
Rejestracja: 6 lis 2013, 14:46
Kontakt:

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: Procent » 20 lis 2013, 08:13

Jak dotąd nie ma jeszcze na polskim rynku pozycji godnej polecenia traktującej o ARDUINO... ale jest światełko w tunelu - Helion po 23.11.2013 wypuszcza \"Arduino. 65 praktycznych projektów\" ...niestety to o zgrozo dokładne tłumaczenie oryginału, bez odrobiny własnej inwencji... szkoda. Oryginał po angielsku znajdziesz na chomiku, więc jeśli znasz język to nie warto wydawać 70 zł. lepiej kupić ze 2 shieldy :-)
pozdrawiam ... wojtekizk ([email protected])
Helionowi się wcale nie dziwię. Sam bym trzepał kasę na tym że nie ma czegoś na rynku. Smutek tylko polega na tym że oni kopiują...
Osobiście gdybym miał wiedzę na temat programowania w Arduino inną niż suche opisy na arduino.cc to sam bym taką książkę napisał bo NAPRAWDĘ JEST PUSTKA po polsku a wydaje mi się że istnieje olbrzymi potencjał wśród użytkowników.
Poszukam tej pozycji po angielsku...

Jeśli możesz jeszcze coś polecić to bardzo proszę.

Podsumowując. Nie, nie ma żadnego miejsca gdzie muszą się znajdować opisy bibliotek. Autor powinien przynajmniej jakiś krótki opis zamieścić.
Dzięki - to w takim razie sporo wyjaśnia. Naprawdę. Od tej pory zamiast się zastanawiać gdzie szukać <<instrukcji obsługi>> do bibliotek - będę się skupiał na ich zrozumieniu i na przykładach.
Temat jak dla mnie wyczerpany. Myślę że jeśli ktoś podobnie jak ja zaawansowany tutaj zajrzy to też się czegoś nauczy
Codzienne zmagania:
http://www.ertec.pl/
Awatar użytkownika
Maxik
Starszy majsterkowicz
Posty: 405
Rejestracja: 6 lip 2012, 18:27
Lokalizacja: Gdańsk
Kontakt:

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: Maxik » 20 lis 2013, 23:34

Smutek tylko polega na tym że oni kopiują...
W jaki sposób wydawanie przetłumaczonych książek jest kopiowaniem? Nie rozumiem tego toku myślenia. Czy polskie wydanie \"Sztuki podstępu\" Mitnicka albo \"Harryego Pottera\" Rowling też jest kopiowaniem? Czy to, że tłumacz stara się być wierny oryginałowi można uznać za brak własnej inwencji?
Awatar użytkownika
Procent
Młodszy majsterkowicz
Posty: 21
Rejestracja: 6 lis 2013, 14:46
Kontakt:

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: Procent » 21 lis 2013, 11:58


W jaki sposób wydawanie przetłumaczonych książek jest kopiowaniem? Nie rozumiem tego toku myślenia. Czy polskie wydanie \\\\\\\\\\\\\\\"Sztuki podstępu\\\\\\\\\\\\\\\" Mitnicka albo \\\\\\\\\\\\\\\"Harryego Pottera\\\\\\\\\\\\\\\" Rowling też jest kopiowaniem? Czy to, że tłumacz stara się być wierny oryginałowi można uznać za brak własnej inwencji?
No jeśli już się zastanawiać nad sformułowaniami to - OCZYWIŚCIE że można uznac za brak inwencji - przecież nie ma żadnej inwencji w przetłumaczeniu.
W sumie natomiast to \\\\\\\"nie jest szkoda\\\\\\\" że Helion tłumaczy bo cóż niby innego ma robić wydawnictwo.

Żal natomiast że nie ma polskiej TFUrczości... i na tym polega mój smutek
Codzienne zmagania:
http://www.ertec.pl/
Awatar użytkownika
cube
Złota rączka
Posty: 834
Rejestracja: 2 gru 2012, 17:02

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: cube » 21 lis 2013, 12:01

Czytając książki, w wielu przypadkach chciałbym aby tłumacz nie miał własnej inwencji. Przy tytułach filmów jest to samo ;)
Awatar użytkownika
Procent
Młodszy majsterkowicz
Posty: 21
Rejestracja: 6 lis 2013, 14:46
Kontakt:

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: Procent » 21 lis 2013, 14:48

a co dopiero przy TREŚCI dialogów w filmach..... Osobiście wielokrotnie zmieniałem tłumaczenia bo mimo że nie jestem mistrzem angielskiego nie dawało się wytrzymać
Codzienne zmagania:
http://www.ertec.pl/
Awatar użytkownika
wojtekizk
Starszy majsterkowicz
Posty: 311
Rejestracja: 19 lis 2013, 10:54
Lokalizacja: Bydgoszcz

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: wojtekizk » 22 lis 2013, 17:34

W sumie kolega Maxik ma sporo racji obstając przy dosłownych tłumaczeniach, niestety bywały i w Helionie fatalne tłumaczenia, najgorsze są te, gdzie autor nie ma pojęcia o programowaniu lub chociaż o składni danego języka. Były także zabawne wpadki: driver - kierowca czy nieśmiertelny autoexec.bat - autoexec.nietoperz :-)
Osobiście uważam, że dawniej bywało dużo lepiej - było o niebo mniej pozycji ale za to bardziej wartościowe. Podam tylko przykłady tzw. Biblii ( Excel, World, Programowanie Windows Charlesa Petzolda). Były produkty Microsoft Press i O\\\'Reilly. Teraz każde wydawnictwo zalewa nas kilkunastoma pozycjami traktującymi o tym samym, często powielając te same przykłady, traktując pobieżnie każdy temat. Tylko czasem uda się wydać coś wartościowego (np. Heliona Thinking in Java, czy Core Java). Generalnie ikoną dla C++ jest symfonia, którą zgłębiają już bodaj wszyscy studenci kierunków technicznych. Co do pozycji z cyklu \\\"dla opornych \\\" czy \\\"compendium w 24 godziny\\\" wolę się nie wypowiadać.
Podobna sytuacja jest na wielu uczelniach - student na jednym wykładzie poznaje podstawy składni a już chwilę potem na ćwiczeniach realizuje\\\"program\\\" pisząc klasę typu samochód lub uczeń. Nie wie jak zadeklarować dwuwymiarową tablicę zmiennych, nie wie czym jest wskaźnik do funkcji a już zajmuje się dziedziczeniem klas... żenada. Dawniej uczono działań na bitach, czym jest preprocesor, co robi kompliator, o predefinicjach i manifestach, uniach i strukturach, potem były klasy i obiekty... teraz jest 3 razy Z - zakuć, zaliczyć, zapomnieć. Szkoda.
Ostatnio zmieniony 22 lis 2013, 18:54 przez wojtekizk, łącznie zmieniany 1 raz.
Awatar użytkownika
wojtekizk
Starszy majsterkowicz
Posty: 311
Rejestracja: 19 lis 2013, 10:54
Lokalizacja: Bydgoszcz

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: wojtekizk » 22 lis 2013, 17:58

Odpowiem koledze MrLewerence - oj nie do końca tak jest... na początek zaprezentowałeś przykład, który się nie skompiluje - błąd już po void, nie wspominając już, że odwołujesz się do bla zamiast do funkcji. Następnie trzeba uważać czy aby ciało tego co masz w zewnętrznym pliki *.h nie musi przypadkiem korzystać także z bibliotek, bo często tak bywa, że bedziesz tam musiał zaincludować przynajmniej Arduino.h. Potem dojdzie problem zakresu widoczności zmiennych, funkcji private czy public w klasach. Trzeba się sporo napocić nieraz :-) Jest jednak światełko w tunelu - pisanie własnych bibliotek w Arduino jest i tak o niebo prostsze niż np. w Builderze. Zacznij od poprawnej składni, potem spróbuj skompilować taki pliczek. Jak się nie da to musisz najpierw umieścić go w samym programie *.ino czy *.pde, a potem dopiero robić z tego cpp i h. Generalnie trzymaj się zasady: deklaracje w pliku *.h a definicje w *.cpp. SKŁADNIA jest najważniejsza !
Pozdrawiam
Awatar użytkownika
rafalzaq
Majsterkowicz
Posty: 180
Rejestracja: 2 maja 2013, 23:57

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: rafalzaq » 22 lis 2013, 19:36

Posiadam Core Java Heliona i faktycznie nie ma się do czego przyczepić. Mam również \"Programowanie w języku Ruby\" (tzw. pickaxe) tego samego wydawnictwa i tu już nie jest tak różowo. Dość dużo literówek. Nawet w przykładowym kodzie się trafiają. Może już jest jakieś nowsze wydanie gdzie to poprawili, ale mogli się lepiej postarać.
Awatar użytkownika
hyena
Młodszy majsterkowicz
Posty: 34
Rejestracja: 28 lis 2013, 23:51

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: hyena » 29 lis 2013, 01:25

Procent pisze:
Jak dotąd nie ma jeszcze na polskim rynku pozycji godnej polecenia traktującej o ARDUINO... ale jest światełko w tunelu - Helion po 23.11.2013 wypuszcza \"Arduino. 65 praktycznych projektów\" ...niestety to o zgrozo dokładne tłumaczenie oryginału, bez odrobiny własnej inwencji... szkoda. Oryginał po angielsku znajdziesz na chomiku, więc jeśli znasz język to nie warto wydawać 70 zł. lepiej kupić ze 2 shieldy :-)
pozdrawiam ... wojtekizk ([email protected])
Mam tą książkę, była u mnie 22.11.13 czy to jest dobre, czy nie, nie wiem ale już się coś z niej dowiedzaiałem. Polska jest zawsze 100lat za murzynami (nie ubliżając czarnoskórym), niestety nie zanm Angielskiego bo jak ja chodziłem do szkoły to był Rosyjski. Więc musiałem kupić ksążkę. Jeżeli chcecie przeglądnąć projekty z książki to mam linka ale nie mogę wstawić. (Nowicjusz) Ale... można tak: ftp : // ftp . helion . pl / przyklady / ardupp.zip Nie był bym polakiem gdybym nie mógł tego wykombinować jak ominąć ograniczenia. :))
Awatar użytkownika
wojtekizk
Starszy majsterkowicz
Posty: 311
Rejestracja: 19 lis 2013, 10:54
Lokalizacja: Bydgoszcz

Re: BIBLIOTEKI - jak są zbudowane i jak je obsługiwać

Post autor: wojtekizk » 29 lis 2013, 15:14

właśnie i ja przeglądam ten polski "oryginał"... hmmm może wywołam tym niepotrzebną burzę ale szczerze - no nie opadła mi kopara... niby proste, niby wszystko jest ale.... no właśnie czegoś tu brakuje... podstaw niestety... a zresztą niech się inni wypowiedzą :-) Pozdrawiam
ODPOWIEDZ

Strony partnerskie: