Ploter: 1. dio - Uvod

Ovih dana me baš i nije bilo na blogu, bila sam poprilično zauzeta traženjem nekog cool projekta. Ljeto je dugo (nadam se) pa da sve te dane bezveze ne potratim surfajući netom odlučila sam pronaći neki projektić i time se pozabaviti.

Dakle sigurno se pitate što je to ploter, obzirom da slika govori 1000 riječi, a video sigurno i više to je ovo:

Za sada sam uspjela nabaviti step motor sa 6 žica, pošto je takvima (tatinim riječima) najlakše upravljati. U videu se ne koristi takav motor, no ionako nigdje nema koda i sheme kako tako nešto napraviti, pa ću sve morati sama, tako da ovo ne bi trebao biti problem. Jučer sam uspjela natjerati motor da se okreće, što je zapravo jako veliki uspjeh! Jer mi prekjučer to baš i nije išlo.

Ukratko o mom 6-žičnom motoru:

Sa 1,2,3,4 sam označila žice koji su njegovi izvodi koji se spajanju "na" pinove čipa kojim se upravlja motorom, a A i B su izvodi motora koji se spajaju na "+" napajanja motora, "-" napajanja motora se spaja zajedno sa GND-om čipa, no o tome malo kasnije.

Kada je pred vama step motor sa 6 žica glavno je pitanje kako odrediti koja je koja žica. Bezveze je tražiti po internetu  koja boja žice odgovara žici 1, pa koja boja odgovara čici 2 itd. Najlakši način je uzeti ommetar i početi mjeriti otpore žica. Svaka zavojnica ima neki otpor jer je to obromna količina bakra.

Kako odrediti:

Uzmete neku žicu i sad gledate gdje vam se javlja otpor, od svega par oma, ukoliko vam ommetar ispisuje da je beskonačan otpor, znači da ste uzeli žicu druge zavojnica (kao što se vidi na slici, 2 zavojnice nisu spojene iz čega slijedi da je otpor beskonačan). Samo kada se uzmu 3 žice međusobno se pokazuje neki manji otpor. Između prve i druge žice je npr. otpor 10oma, sada pogledate onu 3. žicu koja je isto pokazivala otpor s nekom od ove dvije i utvrdite otpor između treće i prve te vidite da je otpor tu 20oma. Iz toga zaključite da prva žica  odgovara žici 1 na slici, druga žica odgovara A žici na slici i treća žica odgovara žici 2 sa slike.

Prema istom tom principu odredite i preostale 3 žice.
Nemojte se opterećivati ako otpor između 1 i A, te 2 i A nebude u decimalu identičan, to je normalno pošto i mjerni uređaji griješe kao što je sigurna i neka manja greškica u namotajima zavojnice. Bitno je da su vrijednosti približne.

Kada su žice određene mogla bih objasniti i kako se pokreće step motor...

Kako napisati program... (za lpc1343)
(kod ću na kraju odlomka objaviti)

Svakom pinu odgovara jedan "brojčani" izvod motora, A i B izvode zanemarite za sada (oni se samo spajaju na "+" napajanja). U programu je potrebno inicijalizirati GPIO, definirati neka 4 pina kao izlazna (u registru DIR) i da bi se motor mogao okretati morate tablicu sa slike pretvoriti u kod.

Zapravo je to sve što trebate znati. U nastavku ću napisati neke programske probleme koji me nisu zaobišli.

/*
===============================================================================
 Name        : main.c
 Author      : Karolina
 Version     :
 Copyright   : Copyright (C)
 Description : main definition
===============================================================================
*/

#ifdef __USE_CMSIS
#include "LPC13xx.h"
#endif
a
#include <cr_section_macros.h>
#include <NXP/crp.h>
__CRP const unsigned int CRP_WORD = CRP_NO_CRP ;
#include "timer32.h"
#include "gpio.h"
int main(void) {
    GPIOInit();
    init_timer32(0,TIME_INTERVAL);
    enable_timer32(0);
    LPC_GPIO1->DIR|=0x100;
    LPC_GPIO0->DIR|=0x40;
    LPC_GPIO3->DIR|=0x5;
    LPC_GPIO1->DIR|=0x20;
 
    while (1){
//prvi redak tablice
    GPIOSetValue(PORT1,8,0);
    GPIOSetValue(PORT3,0,0);
    GPIOSetValue(PORT0,6,1);
    GPIOSetValue(PORT3,2,1);
    delay32Ms(0,5);

//drugi redak tablice
    GPIOSetValue(PORT1,8,0);
    GPIOSetValue(PORT3,2,0);
    GPIOSetValue(PORT0,6,1);
    GPIOSetValue(PORT3,0,1);
    delay32Ms(0,5);

//treći redak tablice
    GPIOSetValue(PORT0,6,0);
    GPIOSetValue(PORT3,2,0);
    GPIOSetValue(PORT1,8,1);
    GPIOSetValue(PORT3,0,1);
    delay32Ms(0,5);



//cetvrti redak tablice
    GPIOSetValue(PORT0,6,0);
    GPIOSetValue(PORT3,0,0);
    GPIOSetValue(PORT1,8,1);
    GPIOSetValue(PORT3,2,1);
    delay32Ms(0,5);
    }
    return 0 ;
}

No ništa u ovom svijetu nije tako jednostavno kao što se čini (s time imam dosta iskustva), evo nekih problema s kojima sam se susrela kod programiranja...

Cijelu tablicu sam pretočila u kod baš kako piše, što je zapravo djelomično krivo. To jesu kombinacije koje u određenim stanjima moraju biti na pinovima, ALI...

Kod kombinacija u tablici pri prijelazu iz nekog stanja u sljedeće zna se nakratko desiti da je na 3 pina istovremeno isto stanje (to nije dopušteno, tj. motor se neće okretati)! Da bi se to spriječilo prvo se napiše koji se sve pinovi postavljaju u 0, a tek onda se napišu pinovi koji (p)ostaju jedinice. Ako je neki pin 0 ništa se neće desiti, motor neće okrenuti rotor sve stoji, tek kada se prebaci u 1 onda se u motoru nešto promijeni.

Ukoliko ćete to s ledicama prvo ić provjeravat (što toplo preporučam, jer dosta deprimirajuće postaje kad motor ne radi) nećete opaziti da su u isto vrijeme 3 ledice upaljene, no motor hoće i stajati će dosta dugo na mjestu, tj. nikada se neće pomaknuti. Rekla sam da preporučam da s ledicama provjeravate zato što ćete vidjeti da li vam svi pinovi rade, recimo meni pin P0.10 ne radi, zato što bih trebala ić nešto onemogućavati u nekom registru  da bi proradio (a iskreno nije mi se dalo to raditi za ovakav primjer).

Još ukratko što se nalazi na kojem pinu: u gornjem primjeru koda i slike.
1 - P1.8
2 - P0.6
3 - P3.0
4 - P3.2


Evo sheme kako je sve spojeno i slike kako to zapravo izgleda

Prvo da prokomentiram (bijelu sliku) shemu. S lijeve strane sam napisla izvodi čipa to zapravo znači da su to svi oni izvodi kojima ćete upravljati motorom, također piše i GND 2 puta na shemi. Ovaj prvi GND je od čipa, znači taj GND spajate zajedno s GND-om napajanja motora (to obavezno morate napraviti, ja nisam i nije radilo, naravno). Na slici (plava pozadina) vidite zelenim slovima napisano napajanje za motor, pošto nemam pravi podesivi ispravljač snašla sam se i raskopala neki stari punjač za mobitel koji na svojim izvodima daje 5,11V, zaokruženo 5V. Također pametno je (obavezno) odgonetnuti + i - tog ispravljača.

Prijatelj mi rekao da bi bilo dobro napisati čemu služe i ove diode na shemi. Naime pošto radim sa zavonicama (koje su sastavni dio motora) normalno je da će se inducirati napon i poteći struja. U ovom slučaju ta struja nam može naštetiti, tj. šteti tranzistorima. Da bi se spriječio negativan utjecaj struje stavljaju se diode kojima je jedina uloga da zaštite tranzistore.

Mislim da je to skoro sve što bi trebalo reći o ovom dijelu prijekta, ukoliko ima kakvih pitanja, konataktirajte me :)

LEDice, spajanje i proračun

Pošto se s programom lpcXpresso već dobije programček za lpc1343 blinking, odlučila sam to malo "nadograditi" i pogledati jesam li dobro sve to shvatila. Tako da sam mrvicu promjenila kod (portove i malo se poigrala s timerom).
U ovom postu cilj mi je objasniti ovo:

• proračun otpornika za LED
• kako se određuje koja "nožica" je anoda, a koja katoda
• par slikica da se sve lakše shvatiti
• kod neću stavljati iz razloga što mislim da nema smisla, pošto se sve može legalno downloadati s njihove stranice

 P.S. primjetiti ćete da ne pišem "LED dioda" čisto iz razloga što je u samom nazivu LED sadržana riječ dioda (light emitting diode).


Pa započinimo s najjednostavnijim: proračun otpornika.
 
Za početak moramo znati koliki napon "daje" naš čip na pinovima koje planiramo koristiti kao izlazne. To se lako sazna iz datasheeta tog čipa, konkretno za ovaj (lpc1343) je napon na I/O pinovima 3,3V i maksimalna struja koje može davati čip je 20mA po pinu.

Sada kada to znamo moram odrediti kakvom diodom želimo upravljati. Za svoje primjere koristim "bijele" diode (tj. diode bijele svjetlosti) i ako proguglate vidjet ćete da je za njih pad napona oko 3V, to znači da ako se na nju spoji napon koji je manji od ovog ona neće svjetliti ili če jako slabo svjetliti (tzv. napon praga diode - ako nekoga više zanima nešto o toj "pojavi").

Skupili smo sve napone, sada kreće računanje!

(LED se crta tako da su ove 2 strelice prema gore, a ne dole kao na slici)
potencijal izlaza čipa Uč= 3.3V
pad napona na diodi Ud=3V
Iz ova 2 napona lako se dobije koliki pad napona mora biti na otporniku to je U= 0.3V (minimalno). Minimalno sam napisala jer ništa u našem strujnom krugu ne radi idealno, što znači da u jednom trenutku napon koji daje čip može biti možda čak i 3.5V! Što znači da bi naš otpornik sve to trebao "preuzeti" i zaštititi diodu od bržeg "trošenja".

Da bi dobili otpor, još nam fali samo struja, znamo da je max struja koju daje čip I=20mA, a obično nam za diode i treba 20mA (struje za diode općenito se kreći između 15mA i 25mA), pa uzimamo tu vrijednost i izračunavamo otpor otpornika koji mora biti R=U/I=15oma, ukoliko takav otpornik ne možete naći za kupiti, kupite otpornih nešto većeg otpora, nikako manjeg!

Sada još jedna sitnica koja će nam u sljedećem dijelu zatrebati, ovaj širi dio diode (gdje je "baza" trokuta) je anoda i spaja se na "+", tj. na pin preko elemenata (otpornika, drugih dioda i sl.), a ova crtica na shemi je katoda ona se spaja na "-" stranu el. sheme.


Kako prepoznati anodu i katodu

  

Sigurno se čuli kako je dulja/kraća nožica anoda/katoda. Ja to baš tako i ne pamtim, najviše zato što ledicama često savijam nožice pa se duljina baš i ne primjećuje, a da ne govorim ako vam netko odreže nožicu diode. Dakle najsigurniji način određivanja anode i katode kod LED diode je prema ovom unutarnjem metalu. Kao što vidite malo je odvojen unutra, nije sve od jednog dijela materijala napravljeno, već postoji neki prorez. S lijeve strane je manji dio tog materijala, a s desne je veći dio tog materijala. Što govori da je s desne strane katoda, a lijeve anoda. E sad kako to zapamtiti???

Ja imam neki svoj način kako to pamtim i još me nikada nije iznevjerio, a to je da katoda ima slovo T koja dosta mjesta zauzima (xD), a anoda nema to slovo T, a pomalo i ovaj desni dio ledice podsjeća na slovo T, pa je to kaToda. Sad kad znam da je to katoda onda znam da je ono drugo sigurno anoda :).

Kada sam objasnila kako izračunati otpornik, kako prepoznati anodu/katodu i nacrtala opću shemu, mislim da biste znali bez problema sami napraviti shemu i spojiti. 

Little tip: znači onu shemu od gore samo umnožite onoliko puta koliko ledica spajate na pojedine pinove. Također u kodu morate prepraviti GPIO izlaze, tako da odgovaraju portu i pinu na kojem vam se nalazi ledica. 

Maloprije sam vidjela frendov mail i dao mi je dosta korisnih savjeta, također naveo je i kako on pamti koja je katoda a koja anoda:

• "Moj način pamćenja katode.... GND je uvijek velika površina... tj. pločice se ispunjavaju gndom protiv smetnji npr... e, a baš je i u LED-ici taj komad metala velike površine i spaja se na GND, tj. -" dcihlar

• "uzmeš multimetar i provjeriš polaritet ledice i vidiš kak je treba spojiti :P" Anonymus

I to je to :-)

P.S. ako i vi imate neki svoj načim pamćenja katode/anode slobodno ostavite u komentaru i probat ću to u što kraćem roku staviti u post :).

Opća shema tipke

Evo kratkog tutorijala kako spojiti tipku na neki čip...
Ova shema je isprobana na PIC mikrokontrolerima i tamo je izvrsno radila, danas sam uspjela isprobati tu istu shemu i na armu i radi više nego izvrsno! :)

1. Ovako izgleda shema po kojoj bi trebalo spojiti tipku na čip.

Čip koji je u ovom primjeru upotrebljen je neki koji sam našla u programu (za crtanje shema), tako da se previše ne zamarajte time. Bitno je uočiti 2 važna elementa na ovoj slici, otpornik od 10k oma i tipka te način na koji su spojeni međusobno i način kako su spojeni na čip. Pošto ta dva elementa nisu polarizirani ne morate paziti kako ćete ih okrenuti.

Za neke koji 1. put ovo slažu bitno je da uočite GND i +5V, to je isti onaj napon na koji spajate čip, ukoliko vam se čip nalazi na nekoj pločici koja je USB-om spojena na komp, onda ćete taj napon dobiti tako da s čipa "izvučete" njegov GND i +5V.

2.  Na ovim slikama ću pokazati kako se to u stvarnosti spaja...

Na zadnjoj slici je prikazano izbliza kako izgleda onaj dio sheme samo s tipkom, a ledica je dodana zbog provjere ispravnosti interrupta.

Program (kod) sam preuzela sa ove stranice, to je primjer (unutar .zip foldera) gpio.
Jedino što morate promijeniti je:

1.  u datoteci gpiotest.c "zalijepite" samo ovaj kod:

-------------------------------------------------------------------------------------------------------------------------

#include "LPC13xx.h"          

#include "gpio.h"

volatile uint32_t val=0;

int main (void){

  GPIOInit(); //inicijalizacija GPIO-a, to samo napišete narebu niš ne dirate

  GPIOSetDir( PORT2, 2, 0 ); //P2.2 trigger ovdje definitare na kojem portu i koji pin će biti tipka

  GPIOSetDir( PORT2, 1, 1 );//P2.1 LED ovdje je definirano na kojem portu i koji pin je led

  GPIOSetInterrupt( PORT2, 2, 0, 0, 0 );

  GPIOIntEnable( PORT2, 2 );

  while( 1 ){

      GPIOSetValue( PORT2, 1, 0 ); //LED je izgašena jer tipka nije stisnuta

  };

}

-------------------------------------------------------------------------------------------------------------------------

2. u datoteci gpio.c sve pobrišete i ovo zalijepite: (najvjerojatnije ima dosta nepotrebnih linija koda, al pošto učim kako sve to funkcionira, nadam se da mi opraštate :P)

-------------------------------------------------------------------------------------------------------------------------

#include "LPC13xx.h"            /* LPC13xx Peripheral Registers */
#include "gpio.h"

/* ===================
 * CodeRed - Modified file to extract out interrupt handler related code,
 * which is really application project specific.
 * Set TIMER16_GENERIC_INTS to 1 to reenable original code.
 * =================== */
#define GPIO_GENERIC_INTS 1

#ifdef GPIO_GENERIC_INTS
volatile uint32_t gpio0_counter = 0;
volatile uint32_t gpio1_counter = 0;
volatile uint32_t gpio2_counter = 0;
volatile uint32_t gpio3_counter = 0;
volatile uint32_t p0_1_counter  = 0;
volatile uint32_t p1_1_counter  = 0;
volatile uint32_t p2_1_counter  = 0;
volatile uint32_t p3_1_counter  = 0;

void PIOINT2_IRQHandler(void)
{
  volatile uint32_t val=0;
  uint32_t regVal;
  val=1;
  gpio2_counter++;
  regVal = GPIOIntStatus( PORT2, 2 );

  while (1){
      GPIOSetValue( PORT2, 1, 1 );
  }
  if ( regVal )
  {
    p2_1_counter++;
    GPIOIntClear( PORT2, 2 );
  }       
  return;
}

#endif //GPIO_GENERIC_INTS

/*****************************************************************************
** Function name:        GPIOInit
**
** Descriptions:        Initialize GPIO, install the
**                        GPIO interrupt handler
**
** parameters:            None
** Returned value:        true or false, return false if the VIC table
**                        is full and GPIO interrupt handler can be
**                        installed.
**
*****************************************************************************/
void GPIOInit( void )
{
  /* Enable AHB clock to the GPIO domain. */
  LPC_SYSCON->SYSAHBCLKCTRL |= (1<<6);

#ifdef __JTAG_DISABLED 
  LPC_IOCON->JTAG_TDO_PIO1_1  &= ~0x07;
  LPC_IOCON->JTAG_TDO_PIO1_1  |= 0x01;
#endif

  /* Set up NVIC when I/O pins are configured as external interrupts. */
  NVIC_EnableIRQ(EINT0_IRQn);
  NVIC_EnableIRQ(EINT1_IRQn);
  NVIC_EnableIRQ(EINT2_IRQn);
  NVIC_EnableIRQ(EINT3_IRQn);
  return;
}

/*****************************************************************************
** Function name:        GPIOSetInterrupt
**
** Descriptions:        Set interrupt sense, event, etc.
**                        edge or level, 0 is edge, 1 is level
**                        single or double edge, 0 is single, 1 is double
**                        active high or low, etc.
**
** parameters:            port num, bit position, sense, single/doube, polarity
** Returned value:        None
**
*****************************************************************************/
void GPIOSetInterrupt( uint32_t portNum, uint32_t bitPosi, uint32_t sense,
            uint32_t single, uint32_t event )
{
  switch ( portNum )
  {
    case PORT0:
      if ( sense == 0 )
      {
        LPC_GPIO0->IS &= ~(0x1<<bitPosi);
        /* single or double only applies when sense is 0(edge trigger). */
        if ( single == 0 )
          LPC_GPIO0->IBE &= ~(0x1<<bitPosi);
        else
          LPC_GPIO0->IBE |= (0x1<<bitPosi);
      }
      else
          LPC_GPIO0->IS |= (0x1<<bitPosi);
      if ( event == 0 )
        LPC_GPIO0->IEV &= ~(0x1<<bitPosi);
      else
        LPC_GPIO0->IEV |= (0x1<<bitPosi);
    break;
     case PORT1:
      if ( sense == 0 )
      {
        LPC_GPIO1->IS &= ~(0x1<<bitPosi);
        /* single or double only applies when sense is 0(edge trigger). */
        if ( single == 0 )
          LPC_GPIO1->IBE &= ~(0x1<<bitPosi);
        else
          LPC_GPIO1->IBE |= (0x1<<bitPosi);
      }
      else
          LPC_GPIO1->IS |= (0x1<<bitPosi);
      if ( event == 0 )
        LPC_GPIO1->IEV &= ~(0x1<<bitPosi);
      else
        LPC_GPIO1->IEV |= (0x1<<bitPosi); 
    break;
    case PORT2:
      if ( sense == 0 )
      {
        LPC_GPIO2->IS &= ~(0x1<<bitPosi);
        /* single or double only applies when sense is 0(edge trigger). */
        if ( single == 0 )
          LPC_GPIO2->IBE &= ~(0x1<<bitPosi);
        else
          LPC_GPIO2->IBE |= (0x1<<bitPosi);
      }
      else
          LPC_GPIO2->IS |= (0x1<<bitPosi);
      if ( event == 0 )
        LPC_GPIO2->IEV &= ~(0x1<<bitPosi);
      else
        LPC_GPIO2->IEV |= (0x1<<bitPosi); 
    break;
    case PORT3:
      if ( sense == 0 )
      {
        LPC_GPIO3->IS &= ~(0x1<<bitPosi);
        /* single or double only applies when sense is 0(edge trigger). */
        if ( single == 0 )
          LPC_GPIO3->IBE &= ~(0x1<<bitPosi);
        else
          LPC_GPIO3->IBE |= (0x1<<bitPosi);
      }
      else
          LPC_GPIO3->IS |= (0x1<<bitPosi);
      if ( event == 0 )
        LPC_GPIO3->IEV &= ~(0x1<<bitPosi);
      else
        LPC_GPIO3->IEV |= (0x1<<bitPosi);     
    break;
    default:
      break;
  }
  return;
}

/*****************************************************************************
** Function name:        GPIOIntEnable
**
** Descriptions:        Enable Interrupt Mask for a port pin.
**
** parameters:            port num, bit position
** Returned value:        None
**
*****************************************************************************/
void GPIOIntEnable( uint32_t portNum, uint32_t bitPosi )
{
  switch ( portNum )
  {
    case PORT0:
      LPC_GPIO0->IE |= (0x1<<bitPosi);
    break;
     case PORT1:
      LPC_GPIO1->IE |= (0x1<<bitPosi);   
    break;
    case PORT2:
      LPC_GPIO2->IE |= (0x1<<bitPosi);       
    break;
    case PORT3:
      LPC_GPIO3->IE |= (0x1<<bitPosi);       
    break;
    default:
      break;
  }
  return;
}

/*****************************************************************************
** Function name:        GPIOIntDisable
**
** Descriptions:        Disable Interrupt Mask for a port pin.
**
** parameters:            port num, bit position
** Returned value:        None
**
*****************************************************************************/
void GPIOIntDisable( uint32_t portNum, uint32_t bitPosi )
{
  switch ( portNum )
  {
    case PORT0:
      LPC_GPIO0->IE &= ~(0x1<<bitPosi);
    break;
     case PORT1:
      LPC_GPIO1->IE &= ~(0x1<<bitPosi);   
    break;
    case PORT2:
      LPC_GPIO2->IE &= ~(0x1<<bitPosi);       
    break;
    case PORT3:
      LPC_GPIO3->IE &= ~(0x1<<bitPosi);       
    break;
    default:
      break;
  }
  return;
}

/*****************************************************************************
** Function name:        GPIOIntStatus
**
** Descriptions:        Get Interrupt status for a port pin.
**
** parameters:            port num, bit position
** Returned value:        None
**
*****************************************************************************/
uint32_t GPIOIntStatus( uint32_t portNum, uint32_t bitPosi )
{
  uint32_t regVal = 0;

  switch ( portNum )
  {
    case PORT0:
      if ( LPC_GPIO0->MIS & (0x1<<bitPosi) )
        regVal = 1;
    break;
     case PORT1:
      if ( LPC_GPIO1->MIS & (0x1<<bitPosi) )
        regVal = 1;   
    break;
    case PORT2:
      if ( LPC_GPIO2->MIS & (0x1<<bitPosi) )
        regVal = 1;           
    break;
    case PORT3:
      if ( LPC_GPIO3->MIS & (0x1<<bitPosi) )
        regVal = 1;           
    break;
    default:
      break;
  }
  return ( regVal );
}

/*****************************************************************************
** Function name:        GPIOIntClear
**
** Descriptions:        Clear Interrupt for a port pin.
**
** parameters:            port num, bit position
** Returned value:        None
**
*****************************************************************************/
void GPIOIntClear( uint32_t portNum, uint32_t bitPosi )
{
  switch ( portNum )
  {
    case PORT0:
      LPC_GPIO0->IC |= (0x1<<bitPosi);
    break;
     case PORT1:
      LPC_GPIO1->IC |= (0x1<<bitPosi);   
    break;
    case PORT2:
      LPC_GPIO2->IC |= (0x1<<bitPosi);       
    break;
    case PORT3:
      LPC_GPIO3->IC |= (0x1<<bitPosi);       
    break;
    default:
      break;
  }
  return;
}

-------------------------------------------------------------------------------------------------------------------------

Kako ova (eksperimentalna) pločica funkcionira:

Na slici je zelenom bojom označeno ono što se ponaša kao "čvorište" znači, da sve što tamo upiknete će biti spojeno, pripazite na to da su "gornji" i "donji" dio pločice kao odvojeni, oni su zapravo i elektročki odvojeni (zato sam nacrtala 3 zelene "gornje" crte i 3 zelene "donje" crte odvojene. Onda još imate crvene i sive crte. Crvene označavaju da je cijeli taj redak spojen (nisam cijelom dužinom povukla crtu jer je poružnilo sliku :P), također i siva crta isto to označava. Isto to se dešava i na donjoj strani pločice. NAPOMENA: "gornja" i "donja" pločica nisu povezane uopće, osim ako nekom žičicom vi to omogućite, znači crveno recimo spojite s crvenim dijelom pločice i tada se sve to nalazi na istom potencijalu, isto tako i plavo spojite s plavim dijelom.

Ako imate još kakvih pitanja, slobodno ostavite koji komentar =).