[Dla początkujących] Podłączanie i obsługa urządzeń zewnętrznych w robotyce i elektronice

[bartek1333]

Początek drogi z zarówno robotyką jak i elektroniką, nie jest prosty. Początkujący często mają problemy z obsługą programową np. wyświetlacza oraz problemy z podłączeniem urządzeń zewnętrznych takich jak mostki, czujniki itp. Również to że niektórzy myślą, że pisanie programów w C obsługujących np. wyświetlacz jest „kosmosem”.

Artykuł zawiera schematy podłączania oraz opis niektórych często używanych urządzeń zewnętrznych w robotyce amatorskiej. Pod niektórymi podzespołami są przykładowe kody obsługi w języku C; między innymi wyświetlacz ze sterownikiem HD44780. Opisany jest również interfejs 1-wire. W każdym kodzie są szczegółowe komentarza dotyczące programu/funkcji obsługi danego podzespołu.

I tak, po kolei będę opisywał:

1. HD44780; wyświetlacz alfanumeryczny

2. Mostki: L298N, L293D, TB6612

3. GP2Y0D340K – czujnik odległości

4. DS18B20 – termometr oparty na 1-wire

5. Transoptory refleksyjne np. CNY70, KTIR0711S, TCRT1000 itp.

6. TSOP312xx

7. Generowanie fali 36kHz za pomocą mikrokontrolera

Zaczynamy!

1 Wyświetlacz oparty o sterownik HD44780.

Może służyć np. do modyfikowania wypełnienia PWM pomiędzy jazdami LF lub walkami robotów sumo.

Schemat poniżej przedstawia podłączanie wyświetlacza 2x16 sterowanego w trybie 4-bitowym z zapisem do układu.

Jak widać, linie danych są podłączone od D4…D7. Pin E oraz RS również do uC. Pin R/W do masy.

Oznaczają one:

- D4, D5, D6, D7 – linie danych, którymi będziemy przesyłać komendy i dane do sterownika HD44780 poprzez odpowiednie ustawianie ich w stan niski lub wysoki

- R/W – pin odpowiadający za odczyt/zapis, poszczególne jego stany odpowiadają za:

R/W = 0 do HD44780 można zapisywać dane

R/W = 1 z HD44780 można odczytywać dane

- R/S – pin odpowiadający za rejestry w HD44780, odpowiednio:

R/S = 0 rejestr instrukcji (do zapisu) lub do odczytu licznika adresu

R/S = 1 rejestr danych (do zapisu lub odczytu)

- E – pin odpowiadający za zapoczątkowanie zapisu/odczytu do HD44780. Tłumacząc: najpierw ustawimy wysoki stan na E, potem ustawimy odpowiednie wyjścia (D4…D7), na końcu, aby spowodować zapis do wyświetlacza, ustawimy stan niski na E.

Tryb 4-bitowy oznacza, że dane 8-bitowe wysyłamy w dwóch pół-bajtach poczynając od jego starszej połówki.

Przejdźmy teraz do implementacji kodu obsługi w C.

Zdefiniujmy na początku poszczególne piny, aby łatwiej się nimi posługiwać:

#define DDR_D4  DDRD  // jest to port, do którego będzie podpięty pin D4
#define PORT_D4 PORTD
#define D4      PD2

#define DDR_D5  DDRD
#define PORT_D5 PORTD
#define D5      PD3

#define DDR_D6  DDRD
#define PORT_D6 PORTD
#define D6      PD4

#define DDR_DB7  DDRD
#define PORT_DB7 PORTD
#define D7      PD5

#define DDR_RS   DDRD
#define PORT_RS  PORTD
#define RS       PD0

#define DDR_E    DDRD
#define PORT_E   PORTD
#define E        PD1

Instrukcje ustawiania (SET) oraz resetowania pinu (CLR) też zrealizujemy na instrukcjach preprocesora C - #define

#define SET_DB4 PORT_D4 |= _BV(D4)
#define CLR_DB4 PORT_D4 &= ~_BV(D4)

#define SET_DB5 PORT_D5 |= _BV(D5)
#define CLR_DB5 PORT_D5 &= ~_BV(D5)

#define SET_DB6 PORT_D6 |= _BV(D6)
#define CLR_DB6 PORT_D6 &= ~_BV(D6)

#define SET_DB7 PORT_D7 |= _BV(D7)
#define CLR_DB7 PORT_D7 &= ~_BV(D7)

#define SET_E PORT_E |= _BV(E)
#define CLR_E PORT_E &= ~_BV(E)

#define SET_RS PORT_RS |= _BV(RS)
#define CLR_RS PORT_RS &= ~_BV(RS) 

Teraz funkcja wystawiająca pół-bajt na magistrale danych D4…D7:

void set_half_byte(char x)
{
if(x & _BV(0)) SET_D4; else  CLR_D4;
/* jeżeli w pół-bajcie pierwszy bit jest 1, to ustaw pin D4, jeżeli jest zero wyczyść pin D4*/
if(x & _BV(1)) SET_D5; else  CLR_D5;
/* jeżeli w pół-bajcie drugi bit jest 1, to ustaw pin D5, jeżeli jest zero wyczyść pin D5  itd. */
if(x & _BV(2)) SET_D6; else  CLR_D6;
if(x & _BV(3)) SET_D7; else  CLR_D7;
}

Teraz funkcja, która dzieli i wysyła te pół-bajty do funkcji poprzedniej, aby mogła ona ustawić odpowiednie piny w uC:

void write_to_lcd(char x)
{
SET_E;                           // na E stan wysoki
set_half_byte (x >> 4); /* ustawienie na szynę danych starszej połówki bajtu; tłumacząc: 
                                      jeżeli mamy bit x który wynosi w systemie binarnym: 01001011,
                                to po wykonaniu operacji: x>>4, otrzymamy bit który wynosi: 00000100,
                                    wtedy funkcja wystawi te bity (pogrubiona czcionka): 0100
                                    po prostu przesuwamy bity w prawo o 4 pozycje */

CLR_E;                       // opadające zbocze na E powoduje zapis do wyświetlacza
SET_E;                        //na E stan wysoki
set_half_byte (x);       /* wystawienie na szynę danych młodszej połówki bajtu, wtedy
                                     funkcja wystawi na magistralę (linię danych) następujące
                                      bity (pogrubione): 1011
CLR_E;                      // opadające zbocze na E powoduje zapis do wyświetlacza
_delay_ms(1);             /* opóźnienie ok 1ms jest niezbędne, aby wyświetlacz mógł
                                    zapisać dane które przed chwilą wysłaliśmy */
}

W ten sposób zapisaliśmy cały bajt do wyświetlacza.

Proste, prawda?

Następne funkcje będą się opierały w zasadzie tylko na odpowiednim ustawianiu linii R/S oraz wysyłaniu funkcją write_to_lcd() bajtów rozkazów lub danych do wyświetlacza.

I tak, teraz funkcja zapisująca komendę do HD44780:

// Funkcja zapisu rozkazu do wyświetlacza
void write_command(char x)
{
CLR_RS;                      // gdy R/S = 0, do wyświetlacza można zapisywać komendy
write_to_lcd(x);            // zapis do LCD komendy x
} 

Funkcja zapisująca pojedynczy znak do wyświetlacza (ta funkcja będzie potrzebna przy zapisywaniu tekstu):

void write_char(char x)
{
SET_RS;                       // gdy R/S = 1, do wyświetlacza moża zapisywać dane
write_to_lcd(x);            // zapis do LCD danej x
}

Funkcja zapisująca tekst do wyświetlacza:

void write_text(char * s)
{
while(*s)       /* wskaźnik wskazujący na kolejny znak tekstu; funkcja będzie się
                        wykonywała dopóki znak jest różny od zera, w przeciwnym razie,
                       gdy s=0, oznacza to że jest koniec tekstu i funkcja poprzestanie zapisywaniu
                        tekstu */
 {
 write_char(*s);  // zapisz znak wskazywany przez s na LCD
 s++;                   // inkrementuj s (przygotuj następny znak do wysłania)
 }
}

Funkcja ustawiająca kursor w wybranym położeniu (x,y) na wyświetlczu. Współżędna x odpowiada za kolumny (0...15), y za wiersze (0...1).

void LCDxy(char x,char y)
{
  unsigned char com=0x80;
  com|=(x|(y<<6));
  write_command(com);
}

Czyszczenie ekranu:

void lcd_clear(void)
{
write_command(0x01); // komenda 0x01 odpowiada za wyczyszczenie ekranu
}

I teraz najważniejsze: inicjalizacja tą funkcję musimy wywołać gdzieś w funkcji main() głównego programu aby móc korzystać z wyświetlacza; nie ma potrzeby wywoływania jej kilka razy, np. w pętli while(1).

void lcd_init(void)
{
DDR_D4 |= _BV(D4);     // wszystkie linie sterujące wyjściowe
DDR_D5 |= _BV(D5);
DDR_D6 |= _BV(D6);
DDR_D7 |= _BV(D7);
DDR_E |= _BV(E);
DDR_RS |= _BV(RS);
//
_delay_ms(20);                /* czekamy 20ms na ustabilizowanie się napięcia zasilającego
                                           (w datasheet układu jest napisane że minimum 15 ms */
CLR_E;                          // E = 0
CLR_RS;                       // RS = 0

char i;                             /* zmianna licznikowa do pętli for(), instrukcje w niej zawarte muszę 
for(i = 0; i < 3; i++)        się wykonać 3 razy służy to inicjalizacji */
 {
 SET_E;                         // E = 1
 set_half_byte(0x03);    // wysłanie instrukcji 0x03 wymagane podczas inicjalizacji
 CLR_E;                        // E = 0
 _delay_ms(5);              // czekaj 5ms wymagane podczas inicjalizacji
 }

SET_E; // E = 1
out_nibble(0x02);
CLR_E; // E = 0
_delay_ms(1);                // czekaj 1ms
write_command(0x28); // interfejs 4-bity, 2-linie, znak 5x7
write_command(0x08); // wyłącz LCD, kursor i miganie
write_command(0x01); // wyczyść LCD
write_command(0x06); // ustaw bez przesuwania w prawo
write_command(0x0C); // włącz LCD, bez kursora i mrugania
}

To na tyle z obsługą wyświetlacza. Jakbym chciał szczegółowo opisać sterownik HD44780 i jego komendy to zajęło by cały artykuł.

Pora przejść dalej.

2 Mostki: L298N, L293D i TB6612

Służą do sterowania silnikami. L293D ma wydajność prądową na kanał 600mA ciągłego prądu, L298N wydajność 2A na kanał. TB6612 do 1,2A Nie wolno przekraczać tych wartości.

Schemat podłączenia mostków:

Piny CURRENT SENSING A i B (L298N) można podłączyć przez rezystory do masy, zmniejszając w ten sposób prąd płynący przez silniki. Jeżeli chcemy, aby do silników płynął maksymalny prąd, podłączamy te wyjścia po prostu do masy.

Dobrą rzeczą jest dawać przy wejściach napięcia zasilania silników kondensatory* low ESR, tantalowy, które zapewnią dobrą filtrację napięcia. I oczywiście mały kondensatorek ceramiczny np. 100nF.

Kondensatorek 100nF dobrze jest również dawać tuż przy wyprowadzeniach z silnika.

Diody (L298N) muszą być bardzo szybkie - SCHOTTKY - i o prądzie minimalnym równym maksymalnemu prądowi który pobiera silnik - ja wybrałem 1N5822 o prądzie do 3A.

Mostkami steruje się bardzo prosto. Wejścia/wyjścia poszczególnych mostków są następujące: (nazwy pinów)

...............................L293D...... L298N....TB6612

Wejście kanał 1....| 1A, 2A | input 1,2 | AIN 1,2

Wejście kanał 2....| 3A, 4A | input 3,4 | BIN 1,2

PWM 1.................| 1,2EN | ENABLE A | PWMA

PWM 2 ................| 3,4EN | ENABLE B | PWMB

Silnik 1................| 1Y, 2Y | output 1,2 | AO 1,2

Silnik 2................| 3Y, 4Y | output 3,4 | AO 3,4

Teraz tylko wystarczy podawać na odpowiednie piny (wejścia) logiczne 0 lub 1. np.

1A = 1; 2A = 0 (silnik kręci się w jedną stronę)

1A = 0; 2A = 1 (silnik kręci się w drugą stronę)

1A = 0; 2A = 0 (silnik hamuje)

Podając stan wysoki na obydwa piny, spowodujemy (wg noty L293D) szybkie hamowanie.

*Uwaga do kondensatorów elektrolitycznych: wartości na schematach są przykładowe, jeśli silniki pobierają większy prąd, powinno się dawać większe.

3 GP2Y0D340K

Jest to często wykorzystywany czujnik odległości, działa na odległości ok. 40cm. Jeżeli czujnik wykryje przeszkodę, na wyjściu będzie stan L.

I schemat podłączenia:

4 DS18B20

Obsługa interfejsu 1-wire często sprawia problemy, więc postanowiłem go opisać w skrócie, a w między czasie napiszemy kod obsługi, na przykładzie termometru DS18B20.

Dlaczego opisuję 1-wire, a nie np. SPI gdzie jest więcej zastosowań? Ponieważ na forum już jest bardzo obszerny artykuł z kodami obsługi C jak i Asembler SPI, a 1-wire nie ma. Myślę, że warto go znać.

Linia danych musi być podciągnięta rezystorem ok. 4,7k do VCC (pull-up).

Inicjalizacja składa się z dwóch rzeczy: master wysyła RESET PULSE przez ustawienie magistrali w stan niski przez min. 480us; następnie układ slave odpowiada mu PRESENCE PULSE po 15-60us przez ustawienie w stan niski na 60 – 240us.

Najpierw ustalmy makra żeby łatwiej obsługiwać pin I/O do którego będzie podłączony DS18B20:

#define SET_WIRE     PORTB  |=  (1<<PB1)   // ustawia stan H
#define CLR_WIRE     PORTB  &= ~(1<<PB1)  // ustawia stan L
#define IS_SET   PINB   &   (1<<PB1)        // maskuje bit pinu, do kórego podłączony jest DS
#define OUT_DDR  DDRB   |=  (1<<PB1)  // ustawia pin jako wyjście
#define IN_DDR   DDRB   &= ~(1<<PB1)  // ustawia pin jako wejście

Poniższa funkcja zwraca 1 gdy układ odpowiedział; 0 gdy nie odpowiedział (uszkodzony lub nie łączy linia danych):

unsigned char DS_Reset(void)
{
unsigned char presence;

OUT_DDR;              // wyjście
CLR_WIRE;            // stan niski
_delay_us(500);       // na 500us

SET_WIRE;           // zwalnia magistrale ustawia stan początkowy czyli wysoki
_delay_us(70);        // czekamy na odpowiedź min. 60us, my czekamy 70us
IN_DDR;                // wejście
if(!(IS_SET))          // jezeli DS ustawił stan niski
presence = 1;          // ustaw zmienną na 1
else                         // jeżeli nie odpowiedział
presence = 0;          // ustaw zmienną na 0
_delay_us(500);     // czekamy na zakończenie trwania PRESENCE IMPULS
return presence;     // zwróć presence: 1-układ jest;  0-układu nie ma
}

Aby zapisać bit, należy postępować zgodnie z WRITE TIME SLOT. Trwa on minimum 60us, z przerwą min. 1us pomiędzy kolejnymi bitami.

Po 15us od rozpoczęcia WRITE TIME SLOT, DS sprawdza stan magistrali w ciągu 45us; jeżeli będzie stan wysoki zapisywana jest jedynka, w przeciwnym razie 0.

Więc zapisywanie 1 powinno wyglądać tak:

CLR_WIRE; // stan niski

_delay_us(7); // czekamy 7us

SET_WIRE; //stan wysoki

_delay_us(70); // czekamy na zakończenie write time slot

Żeby zapisać cały bajt, użyjemy funkcji która jest podobna do algorytmu wyżej, tylko dodane jest zapisywanie 0 i przesuwanie bitów, żeby wysyłać od najmłodszego:

void DS_Write(unsigned char byte)
{
  unsigned char i;            // zmienna licznikowa

  for (i=0; i<8; i++)        // pętla wykonuje się 8 razy, aby wysłać bit po bicie cały bajt
  {
   OUT_DDR;                 // pin wyjściowy

    if (byte & 0x01)         // jeżeli trzeba wysłać 1
    {
      CLR_WIRE;            // stan niski
      _delay_us(7);           // czekamy 7us
      SET_WIRE;            // stan wysoki
      _delay_us(70);         // czekamy do końca write time slot
    } 
    else                             // jeżeli trzeba wysłać 0
    {
       CLR_WIRE;           // stan niski
       _delay_us(70);         // czekamy 70us
       SET_WIRE;            // stan wysoki 
       _delay_us(7);           // czekamy 7us do następnego write time slot
    }

byte >>= 1;                /* przesuwamy bity w prawo, aby znów wysłać kolejny bit; działa tak:
                           jeżeli mamy bajt: 01110101 to po wykonianiu byte >>=1 bajt staje się taki: 
                           00111010 /*
  }
}

Aby zapisać bit, należy postępować zgodnie z READ TIME SLOT. Podobnie jak poprzednio trwa on minimum 60us, z przerwą min. 1us pomiędzy kolejnymi bitami.

Trzeba zainicjować Read Time Slot w następujący sposób: ustawiamy magistralę w stan niski przez minimum 1us, następnie zwalniamy. Po tym układ DS zaczyna generować dane, które są dostępne 15us po rozpoczęciu inicjacji.

Kiedy w tym czasie stan magistrali jest wysoki transmitowane jest 1; kiedy jest niski – 0.

Funkcja odbierająca bajt z układu wygląda następująco:

unsigned char DS_Read(void)
{
 unsigned char i, byte = 0;             // zmienne: licznikowa oraz przechowująca odebrany bajt

OUT_DDR;                                    // pin jako wejście
 for (i=0; i<8; i++)                        /* pętla wykonuje się 8 razy odbiera bit po bicie 
{                                                       zaczynając od najstarszego /*
    CLR_WIRE;                             // stan niski 
    _delay_us(3);                            // czekamy 3us
    SET_WIRE;                             // stan wysoki - zwalniamy magistrale
    _delay_us(7);                            // czekamy 7us

    if(IS_SET) byte |= 0x01<<i;     /* jeżeli stan wysoki to ustaw bit 1, po czym przesuń
                                                          w lewo, żeby ten pierwszy był najstarszy */
    _delay_us(70);                          // czekaj na zakończenie Read Time Slot
 }
 return byte;                                 // zwróć odebrany bajt
}

Teraz tylko minimum kodu, aby odczytać temperaturę z układu (poszczególne instrukcje zapisywane do układu będą tylko w skrócie omówione, po resztę zapraszam do zapoznania się z datasheet).

unsigned char temp1 = 0; // zmienne przechowujące wartości
unsigned char temp2 = 0; // odebraną z ds18b20
unsigned char DS_gotowy = 0; // zmienna gotowości DS

int main()
{
if(DS_Reset())                       // jeżeli układ jest na linii i odpowiedział
{
DS_Write(0xcc);        // SKIP ROM
DS_Write(0x44);       // CONVERT T
DS_gotowy = 1;        /* ustawiamy zmienną oznaczającą gotowość układu będzie 
                                                 potrzebna później */ 
}
else                                        // jeżeli układ nie odpowiedział
DS_gotowy = 0;                   // ustaw zmienną gotowości na 0

_delay_ms(200);
_delay_ms(200);                  /* czekamy na zakończenie konwersji temperatury; fabrycznie
_delay_ms(200);                    konwersja ustawiona jest na 12bit, która trwa do 750ms;
_delay_ms(200);                   my poczekamy 800ms

if(DS_gotowy == 1)            // jeżeli układ był na linii
{
if(DS_Reset())         // trzeba ponownie zresetować układ i jeżeli odpowiedział
{
	DS_Write(0xcc); // SKIP ROM
	DS_Write(0xbe); // READ SCRATCHPAD		
	temp1 = DS_Read(); // czytaj 2 bajty temperatury
	temp2 = DS_Read();
	a = DS_Reset();  // reset - koniec czytania
}
}

5 Transoptory refleksyjne

Są to często stosowane czujniki linii w LF, Minisumu itp.

Na jednym schemacie jest pokazane podłączenie przez komparatory, dzięki czemu otrzymujemy od razu cyfrowe wyniki; jest to najszybszy sposób na sprawne otrzymywanie wyników.

Drugi schemat przedstawia podłączenie do przetwornika analogowo-cyfrowego mikrokontrolera. Jest to nieco wolniejszy sposób, jednak do początkowych konstrukcji jak i nawet tych lepszych jest to rozwiązanie często stosowane.

Potencjometrem regulujemy próg przełączania komparatora. Do wyjścia LM339 konieczne jest dołączenie rezystora pull-up o wartości ok. 100k lub włączyć w uC wewnętrzny pull-up gdyż ma wyjście typy „otwarty kolektor”. Gdy czujnik wykryje linię, na wyjściu pojawi się stan wysoki.

Żeby zaprojektować płytkę z tym czujnikiem, należy tylko w nocie katalogowej odnaleźć gdzie jest katoda, anoda i można rysować.

6 TSOP312xx

Są to często stosowane odbiorniki modulowanej podczerwieni. Końcówka xx oznacza daną częstotliwość, np. TSOP31236 oznacza odbiornik na 36kHz. Gdy odbiornik wykryje falę podczerwoną 36kHz, na wyjściu pojawia się stan niski.

Schemat podłączenia przedstawia poniższy schemat:

Rezystor R1, zgodnie z datasheet powinien mieć od 33R do 1k. Natomiast kondensator C1 powinien mieć wartość większą od 100nF.

Ważną rzeczą o której należy wspomnieć jest to, że TSOP ten ma opóźnienie w sygnale wyjściowym (stan niski, gdy wykryje 36kHz) wynoszące od 7 do 15 okresów fali.

7 Modulowanie sygnału 36kHz

Na koniec jeszcze krótki program pozwalający na modulowanie 36kHz diodą podczerwoną.

Wykorzystamy tutaj tryb CTC Timera1. Bity WGM(13:0) ustawione są na 4. Dzięki temu otrzymujemy tryb CTC z maksymalną wartością zliczaną do OCR1A.

Przekształcając wzór podany w datasheet, otrzymujemy, że przy oscylatorze 8MHz, preskalerze 1, do OCR1A wpisujemy 111. Wtedy otrzymamy w przybliżeniu 36 036 Hz, co jest bardzo bliskie 36kHz (TSOPy na szczęście mają pewną tolerancje częstotliwości).

#include <avr/io.h>
int main(void)
{
DDRB = 0x02;                              // Pin PB1 jako wyjście

OCR1A = 111;                              // wartość wpisana do OCR1A
TCCR1A |= (1 << COM1A0);                 // przy zrównaniu przełacz stan pinu na przeciwny
TCCR1B |= (1 << WGM12) | (1 << CS10);   // tryb CTC - max. OCR1A, preskaler 1

while(1)                                 // pusta pętla programu
{}
}

Jeszcze do tego schemat, jak podłączyć diodę. Podłączamy ją przez tranzystor. Narysowałem schemat tak, aby przez diodą płynął prąd ok 58mA.

Zakończnie.

Pisząc artykuł, posiłkowałem się prawie tylko notami katalogowymi układów; poza bibliotekami (HD44780, DS18B20), które już posiadałem.

I link do artykułu na forum o użyciu SPI (tak jak napisałem przy 1-wire):

Obsługa SPI

Dla początkujących:

Zachęcam bardzo gorąco do korzystania z not katalogowych przed napisaniem nowego tematu. O ile znalezienie informacji po polsku o prostych układach jest proste, to bardziej skomplikowane układy są dostępne często jedynie w wersji anglojęzycznej.

Jeżeli nie rozumiesz, co jest w nocie napisane, spróbuj to przetłumaczyć w „Tłumacz Google”, a jak jeszcze nie rozumiesz, wtedy napisz temat na forum.

Z początku, jak słabo znasz angielski, będzie to trudne. Jednak gdy będziesz często z tego korzystał, szybko nauczysz się zwrotów i słówek po angielsku, a wtedy poznawanie i zrozumienie nowych, lepszych układów będzie o wiele prostsze.

Starałem się opisać ważniejsze układy stosowane w robotyce amatorskiej. Wszystkich nie byłem w stanie, bo powstał by niezły esej.

Tyle na ten temat.

Liczę na krytykę i sugestie dotyczące artykułu.

Pozdrawiam,
bartek1333

__________

Komentarz dodany przez: Treker

Dodałem brakujący załącznik.

[Armir]

Nie zgodzę się z pojemnościami przy tb6612. Zawsze powinno stosować się zalecane przez producenta mostka. Sharp gdy wykryje przeszkodę podaje stan L.

[MacGyver]

Drugi schemat przedstawia podłączenie do przetwornika analogowo-cyfrowego mikrokontrolera. Jest to nieco wolniejszy sposób, jednak do początkowych konstrukcji jak i nawet tych lepszych jest to rozwiązanie często stosowane.

Moim zdaniem to zawsze odczyt przez komparator będzie szybszy od ADC

Do wyjścia LM339 konieczne jest dołączenie rezystora pull-up o wartości ok. 100k, gdyż ma wyjście typy „otwarty kolektor”. Gdy czujnik wykryje linię, na wyjściu pojawi się stan wysoki.

Lub włączyć rezystor Pull-up w uC

[bartek1333]

Sharp gdy wykryje przeszkodę podaje stan L.

Masz rację, źle odczytałem diagram w datasheet :-> . Poprawione.

Zawsze powinno stosować się zalecane przez producenta mostka.

Masz rację, poprawiłem również. Ale na przykład w L293D w nocie nie ma na schematach narysowanych kondensatorów (chyba że czegoś nie doczytałem), a takie się stosuje.

A jak silnik będzie pobierał duży prąd to nie lepiej jest dać większy kondensator od 10uF low ESR?

Pytam, bo nie wiem do końca jak to jest.

Moim zdaniem to zawsze odczyt przez komparator będzie szybszy od ADC

I tak też napisałem:

Drugi schemat przedstawia podłączenie do przetwornika analogowo-cyfrowego mikrokontrolera. Jest to nieco wolniejszy sposób,

[MacGyver]

Ja w swoim robocie posiadam L298 i szczerze mówiąc nie mam tam żadnego kondensatora. Wszystko działa bez najmniejszych problemów

[bartek1333]

Ja w swoim robocie posiadam L298 i szczerze mówiąc nie mam tam żadnego kondensatora. Wszystko działa bez najmniejszych problemów

Masz rację. Jednak gdzieś przeczytałem (elportal chyba), że dobrym nawykiem jest odprzęganie każdego pinu zasilającego.

[marek1707]

Schemat zasilania TSOP'a jest nieprawidłowy. Nie ma sensu zasilanie odbiornika IR przez rezystor chyba, że za nim jest kondensator filtrujący. No i warto wspomnieć o dość dużym opóźnieniu od 7 do 15 okresów sygnału wejściowego, spowodowanym filtrowaniem.

[bartek1333]

Nie ma sensu zasilanie odbiornika IR przez rezystor chyba, że za nim jest kondensator filtrujący.

Sugerowałem się notą, gdzie rzeczywiście jest kondensator za rezystorem. Nie pomyślełem, że robi to taką różnicę :-> . Już poprawiam.

Dzięki za wszelkie uwagi.

[MacGyver]

Drugi schemat przedstawia podłączenie do przetwornika analogowo-cyfrowego

Na drugim schemacie pokazany jest komparator a nie ADC Jak każdy człowiek, bardziej rozwinięty zmysł mam do zapamiętywania obrazków(schemat w tym przypadku) niż tekstu.Wprowadziłeś mnie w błąd :DD

[bartek1333]

Na drugim schemacie pokazany jest komparator a nie ADC

eehh, rzeczywiście. Dopracowywałem ten artykuł od południa, nie licząc dni wcześniejszych, toteż proszę wybaczyć niektóre błache "byki".

Dzięki.

[BlackJack]

Po takim szybkim helikopter-wiu. Przy mostkach piszesz o L293D w wstawiłeś schemat dla L293N, wypadało by wspomnieć czym te mostki się różnią tzn. L293D - ma w sobie diody przepięciowe, a L293N ich nie ma.

Opis najprostszego sterowania moskiem jest OK, może lepiej nowicjuszom nie męcić głowy PWMem.

Przy TSOPach też wypadało by wymienić podstawowe częstotliwości nośne. jest ich 6 standardowych 30, 33, 36, 38, 40 i 56KHz.

[bartek1333]

Przy mostkach piszesz o L293D w wstawiłeś schemat dla L293N,

Trochę nie rozumiem. Na schemacie jest mostek L293D. Który mostem masz na myśli?

[Robomaniak]

Blackowi chyba chodziło o l298n

[bartek1333]

Blackowi chyba chodziło o l298n

W takim razie na schemacie są diody przepięciowe. I napisałem o nich pogrubionym drukiem.

[Ksawery]

Jeśli mam coś doradzić staraj się nie prowadzić połączeń przez układ scalony, ponieważ źle to wygląda i co gorsze prawie ni widać tego połączenia (masa na schemacie dotyczącym mostka L293D).