TRANSFORMATORS.lv

Piedalies lielākajās Baltijas robotikas sacensībās „Baltic Robot Sumo 2012”!

Edgars — Fri, 20 Apr 2012 08:02:32 +0000

Robotika ir viena no visstraujāk augošajām nozarēm. Roboti tiek konstruēti industriāliem mērķiem, sadzīves atvieglošanai, kā arī priekam un sacensībām. Ja aizraujies ar robotiem un tev piemīt sacensību gars, tad tev jābūt lielākajā robotikas pasākumā Baltijā – Baltic Robot Sumo 2012. Piedalies sacensībās ar savu robotu un izcīni uzvaras! Baltijas robotikas sacensības „Baltic Robot Sumo” norisināsies 12. maijā Starptautiskajā izstāžu centrā Ķīpsalā, Ķīpsalas 8, Rīgā.

Pasākuma mērķis ir sekmēt robotikas nozares attīstību un sadarbību Latvijā un Baltijā, ar robotikas sacensību palīdzību, kā arī veicināt jauniešu, it īpaši skolēnu, interesi par inženierzinātnēm un paaugstināt inženierzinātņu prestižu sabiedrībā. Šogad ikvienam robotikas entuziastam ir iespēja piedalīties vairākās disciplīnās gan iesācēju, gan arī profesionāļu klasēs. Iesācēju klasē var piedalīties skolēni un jebkurš, kas sacensībās piedalās pirmo reizi. Visu disciplīnu uzvarētājus sagaida balvas, savukārt prestižās 3 kg Sumo disciplīnas uzvarētāji iegūs ielūgumu piedalīties All Japan Robot Sumo Tournament’s Grand Final, kas norisināsies šī gada nogalē Tokijā.

Šogad visas dienas garumā norisināsies cīņas šādās disciplīnās :

3kg Sumo
Mini Sumo (iesācēju un profesionāļu klase)
Roomba Sumo
Līnijas sekotāji (iesācēju un profesionāļu klase)
Latvijas Lego čempionāts (tikai skolēnu klase)
Taxi Driver (tikai skolēnu klase)
Freestyle

Nenokavē un piesaki savu robotu lielākajām sacensībām Baltijā līdz 7. maijam portālā www.balticrobotsumo.org! Piedalīšanās ir bez maksas, kā arī nav ierobežojumu reģistrēto robotu skaitam vai komandas dalībnieku skaitam, taču katrs dalībnieks drīkst būt tikai viena robota operators^*. Pirms sacensībām dalībniekiem būs iespēja uzlabot savus robotus, taču katra komanda drīkstēs izmantot tikai 1 lodāmuru, rokas instrumentus, kā arī portatīvos datorus un akumulatoru lādētājus. Sīkāk ar sacensību nolikumu izmaiņām vari iepazīties www.balticrobotsumo.org.

Baltijas robotikas sacensības „Baltic Robot Sumo” rīko RTU Robotikas klubs ciešā sadarbībā ar Bērnu zinātnes centru „Z(in)oo”, RTU Studentu parlamentu un Rīgas Tehnisko universitāti.

Vairāk informācijas : www.balticrobotsumo.org un www.robotika.lv

Jautājumiem, komentāriem, neskaidrībām : robootika@robotika.lv

*^* Operators – dalībnieks, kurš startē robotu

Edgars — Tue, 03 Apr 2012 07:14:02 +0000

Šoreiz gan februāra, gan marta labākā raksta autors ir KasparsL ar rakstiem: Li-Ion akumulatoru “gudrs” lādētājs ar MCP73843 un Atmega8 gaismas diožu vadība 2. daļa – nobīdes reģistri balvā iegūstot dāvanu karti 40 Ls vērtībā no SIA Argus Radiodetaļu Tirdzniecība. Arī nākamā mēneša labākā raksta autoram ir iespēja tikt pie dāvanu kartes!

Atceramies, ka tikai Jūsu balsojums noteiks laimētāju!

Pamācība raksta veidošanā atrodama šeit, un informācija par balsošanu – šeit.

P.S atgādinu ka vērtēšanas sistēma nav pakļauta kalendārajam mēnesim bet gan 40 dienām, lai gan balvas tiek izdalītas katra mēneša sākumā, līdz ar to jebkuram daudz maz vienlīdzīgas iespējas tikt pie balvas neatkarīgi no ievietošanas datuma.

Un vēl joprojām rakstu autoriem tiek piešķirta 15% atlaide vienam pirkumam no argus.lv

Informācija par balvu un atlaižu saņemšanu tiek sūtīta uz jūsu e-pastu, kas norādīts Jūsu transformators.lv profilā. Ja gadījumā kāds šo informāciju nav saņēmis – dodiet ziņu.

DIY Tranzistoru/Integrēto shēmu zemfrekvences jaudas pastiprinātāja būve : vispārīgi norādījumi.

Stereo audio līmeņa PPM/VU indikators ar Atmega8

KasparsL — Tue, 03 Apr 2012 06:18:44 +0000

“Sērfojot” internetā, skatoties visādus pašu darinājumus, uzdūros uz audio līmeņa indikātoriem ar mikrokontroliera vadību un radās vēlme arī tādu uztaisīt (no nulles protams!). Ķēros pie lietas. Neko ļoti sarežģītu un ar analogajiem filtriem nevēlējos taisīt, nolēmu, ka izmanošu to pašu nedaudz novecojušo mikrokontrolieri ATMEGA8. Lai atēlotās informācijas izšķirtspēja būtu acij daudz maz tīkama, izdomāju, ka katram kanālam (labajam un kreisajam) būs 24 gaismas diodes – kopā 48. Bet izvēlētajam mikrokontrolierim (Atmega8) nav tik daudz izvadu, lai pieslēgtu tādu skaitu gaismas diožu, bija jāizvēlas pārbīdes reģistri ,vai “multiplexing” – saukšu miltipleksēšana, gaismas diožu vadīšanai. Tā kā nevēlejos neko sarežģīt, un šim aparātam maksimāls spilgtums nav nepieciešams, izvēlējos otro – multipleksēšanu. Neieslīgstot multipleksēšanas sīkumos (jau iepriekš šeit pieminēts vairākas reizes) īsumā – informācija uz gaismas diodēm tiek attēlota pa daļām, manā gadījumā 6 grupas pa 8 gaismas diodēm. vienlaicīgi spīd tikai viena grupa, tad nākamā, nākamā utt. Tas notiek tik ātri, ka cilvēka acīm škiet, ka visas grupas spīd vienlaicīgi (“POV” – “Persistance Of Vision” effekts).

Tālāk, bija jāizlemj, kādā veidā audio signālu padarīt mikrokontrolierim saprotamu. Audio signāls no sadzīves iekārtām nāk laukā divpolārs, bet mūsu “atmegai” ir vienpolāra barošana. Tātad nepieciešams audio signāla taisngriezis! Internets ir pilns ar dažādiem variantiem un izpildījumiem, es izvēlējos shēmu, kas ir kompromiss manam audio līmeņa indikatoram starp sarežģītību un precizitāti (pilnībā pietiekama!).

Šis audio pilna perioda (“fullwave”) taisngriezis darbojas tāpat kā diožu tiltiņš maiņstrāvai, tikai šis to dara audio signālam un bez sprieguma kritumiem. Lai ši shēma – taisngriezis darbotos, nepieciešams operāciju pastiprinātājs ar vienpolāru barošanu, ar “rail to rail input and output”, un, kura ieejas signāls drīkst būt nedaudz negatīvs (svarīgi!). MCP6022 atbilst. Rezistoriem jābūt pēc iespējas precīziem – pielasiet ommetru (arī 1% klases rezistori derēs). tas vajadzīgs, lai abi pusperiodi tiktu pastiprināti vienādi. Dotā taisngrieža pastiprinājuma koeficients ir 0,5.
Vēl “priekšpusē” ievietoju parastu priekšpastiprinātāju, lai kompensētu taisngrieža vājinājumu divas reizes.

Priekšpastiprinātājam izvēlaties operāciju pastiprinātāju ar pēc iespējas mazāku izajas “offset” spriegumu, jo audio taisngriezis tiks pieslēgts pa tiešo pie izejas. Man bija pa rokai OPA2340. Šis priekšpastiprinātājs barojas no divpolāra barošanas avota, tādēļ nepieciešams izveidot negatīvu spriegumu no jau esošā +5V (Atmega8 barošana). Te mums palīdz vienkārša, šim nolūkam paredzēta mikroshēma ICL7660. Tai nepieciešami tikai divi ārēji elementi – divi kondensatori, lai pārveidotu +5V uz -5V. Izejā izmantoju lielākas kapacitātes kondensātoru, lai mazinātu pulsācijas no pārveidošanas.

Vēl viena lieta – tā kā izmantošu multipleksēšanu, 48 gaismas diožu vadībai būs nepieciešami tikai 14 izvadi. No šiem izvadiem 6 ir jāiztur 8 gaismas diožu strāva, kas sliktākajā gadījumā, kad visām gaismas diodēm ir jāspīd, pārsniedz atļautos 20-25mA uz mikrokontroliera izvadu. Tādēļ izveidoju vienkāršus strāvas pastiprinātājus (buferus) ar BC337 tranzistoriem.

Pietiks “niekoties”, liekam visu minēto kopā. Man sanāca sekojoša shēma.

Izmantoju ārējo 16Mhz kvarca rezonatoru, lai pēc iespējas biežāk varētu nolasīt signāla līmeni ieejās – uz ADC izvadiem.
Sākumā es “saspraudu” audio līmeņa indikatoru uz maketplates (bez priekšpastiprinātāja).

Kad tas bija izdarīts, vēru vaļā AVRStudio un sāku rakstīt programmu šim brīnumam ;)
Pirmais, ko izdarīju bija tiku skaidrībā ar multipleksēšanu, uzrakstīju funkcijas, kas mainīgo (0-24) spēj pārveidot un attēlot. Otrais – sāku spēlēties ar ADC. Izvēlējos to darbināt gandrīz nepārtrauktā režīmā un ar pārtaukumu, kad pārveidošana pabeigta (gandrīz nepārtrauktā – palaižam pārveidojumu un ieslēdzam pārtraukumu, kad notiek pārtraukums, apstrādājam un palaižam nākošo pārveidojumu). Tālāk savienoju to visu kopā un ieguvu parastu “PPM” (“Peak Program Meter”) audio signāla mērītāju. Tālāk papildināju programmu ar papildus apstrādes un attēlošanas režīmiem – ieguvu “VU” (precīzs gan tikai sinusoidāliem signāliem), “Peak hold” – maksimālā vērtība tiek kādurīdi “pieturēta”, “Peak rain” – max vētība tiek pieturēta un tad “krīt” lejā, “Dot mode” – tiek attēlots nevis stabiņš, bet viena gaismas diode un kombinācijas no tiem – “VU” + “PPM dot mode” + “Peak hold” utt. Visam tam klāt ir regulējami augšanas un krišanas ātrumi.
Pati programma (lejupielādēt varat raksta beigās):

//==================================================================================
//==== ATMEGA8 STEREO PPM/VU METER 2X 24LED ===

// Bibliotekas ---------------------------------------------------------------------
#include       // ieejas-izejas biblioteka
#include       // partraukumu biblioteka
#include      // aiztures biblioteka

// Definicijas ---------------------------------------------------------------------
#define analog_reference 3 // iebuvetais etalonavots 2,56V
#define LEFTCH 0  // kreisa kanala ieeja ADC0
#define RIGHTCH 1 // labaa kanala ieeja ADC1

// rezimi
#define CLIMBING_BARS 0 // leni kritoss peak stabins
#define PEAK_HOLD 1 // atri kritos peak stabins ar max vertibas ilgu aizturi
#define PEAK_RAIN 2 // atri kritos peak stabins ar max vertibas aizturi un tas krissanu
#define CLIMBING_DOTS 3 // leni kritos peak punkt
#define VU_PEAK_RAIN 4 // VU stabins un peak max vertibas ar krissanu
#define VU_AND_PEAK 5 // VU stabins ar peak punktu un peak aizturi uz pedejam 3 diodem
#define INTRO 6

#define SAMPLE_COUNT 160 // no cik vertibam tiek rekinats VU limenis
#define CORRECTION 112/100 // VU limena kalibracija

// ADC limenu slieksni
#define TRESHOLD01 4 //  -36db
#define TRESHOLD02 5 //  -34db
#define TRESHOLD03 6 //  -32db
#define TRESHOLD04 8 //  -30db
#define TRESHOLD05 10 // -28db
#define TRESHOLD06 13 // -26db
#define TRESHOLD07 16 // -24db
#define TRESHOLD08 20 // -22db
#define TRESHOLD09 25 // -20db
#define TRESHOLD10 31 // -18db
#define TRESHOLD11 40 // -16db
#define TRESHOLD12 50 // -14db
#define TRESHOLD13 63 // -12db
#define TRESHOLD14 79 // -10db
#define TRESHOLD15 100 // -8db
#define TRESHOLD16 125 // -6db
#define TRESHOLD17 158 // -4db
#define TRESHOLD18 177 // -3db
#define TRESHOLD19 199 // -2db
#define TRESHOLD20 223 // -1db
#define TRESHOLD21 250 //  0db // noregulee ieejas limeni, lai atbilst,
#define TRESHOLD22 281 // +1db //     tad visi pareejie arii sakritiis
#define TRESHOLD23 353 // +3db
#define TRESHOLD24 445 // +5db

// laiki
#define COUNTERGHOSTING_DELAY 1 // uSec anti-spokosanas aizture
#define PEAK_HOLD_TIMEOUT 2000 // peak max vertibas turesanas laiks cikli
#define PEAK_RAIN_HOLD 1000 // peak max vertibas turesana, ja ar krissanu
#define PEAK_RAIN_TIMEOUT 100 // peak max krissanas aatrums
#define BAR_FAST_TIMEOUT 10 // aatraa stabina krissanas aatrums
#define BAR_SLOW_TIMEOUT 55 // leenaa stabina krissanas aatrums

// Mainigie ------------------------------------------------------------------------

static uint8_t blockOut[6] = { // LED grupas izvads
 0b01000000,
 0b00000001,
 0b00010000,
 0b00100000,
 0b10000000,
 0b00000010 };

static uint8_t CRYSTALMASK = 0b00111111; // maska, lai nerakstitu uz kvarca izvadiem
static uint8_t ADCMASK = 0b00110000; // maska, lai nerakstitu uz adc ieejaam
static uint8_t BUTTONMASK = 0b00000100; // maska, lai nerakstitu uz pogas izvadu

volatile uint8_t mode = INTRO; // iesledzot, saakam ar so rezimu

volatile uint8_t blockIndex = 0; // diozu bloka indeks (0-5)
volatile uint8_t adcPin = LEFTCH; // ieeja (saksim ar kreiso kanalu)
volatile uint16_t leftBar=0; // kreisa stabina vertiba 0-24
volatile uint16_t rightBar=0; // labaa stabina vertiba 0-24
volatile uint32_t leftBarAvg=0; // kreisa stab. videja vertiba starp cikliem
volatile uint32_t rightBarAvg=0; // labaa stab. videja vertiba starp cikliem
volatile uint32_t leftBarSlow=0; // kreisa stab. vertiba, piemerojot krissanas atrumu
volatile uint32_t rightBarSlow=0; // labaa stab. vertiba, piemerojot krissanas atrumu
volatile uint32_t leftBarVU=0; // kreisa vu stabina vertiba
volatile uint32_t rightBarVU=0; // labaa vu stabina vertiba
volatile uint8_t leftBarDataVU[SAMPLE_COUNT]; // kreisais vu datu akumulators
volatile uint8_t rightBarDataVU[SAMPLE_COUNT]; // labais vu datu akumulators
volatile uint16_t samplePointerVU=0; // vu akumulatoru raadiitaajs
volatile uint16_t leftSamplesCount=1; // kreiso adc lasijumu skaits starp cikliem
volatile uint16_t rightSamplesCount=1; // labo adc lasijumu skaits starp cikliem
volatile uint32_t leftLEDs=0; // kreisīe gala dati, kas japaraada uz diodem
volatile uint32_t rightLEDs=0; // labie gala datim kas japaraada uz diodem
volatile uint8_t leftPeak=0; // peak max kreisa vertiba
volatile uint8_t rightPeak=0; // peak max laba vertiba

volatile uint32_t leftCounter1=0; // skaitiitaaji reziimu aiztureem
volatile uint32_t rightCounter1=0;
volatile uint32_t leftCounter2=0;
volatile uint32_t rightCounter2=0;
volatile uint32_t leftCounter3=0;
volatile uint32_t rightCounter3=0;
volatile uint32_t leftCounter4=0;
volatile uint32_t rightCounter4=0;

volatile uint8_t skipReading = 50; // iesledzot, izlaizam pirmos 50 adc lasijumus

//===============================================================================
// funkcijas ====================================================================
//===============================================================================

// izpildam ADC parveidojumu ====================================================
void sampleADC(){
 ADMUX = (analog_reference << 6)|((adcPin) & 0x07); // izvelamies salidzinamo avotu un ADC ieeju
 ADCSRA |= _BV(ADIE); // iesledzam ADC rezultata gatavibas partraukumu
 ADCSRA |= _BV(ADSC); // saakam parveidojumu
}

//parveidojam ADC uz BAR vertibu ================================================
//---------------------------------------------------------------------
uint32_t adcToBar(uint32_t adcData){
 uint32_t barData = 0;
 if(adcData > TRESHOLD24){barData = 24;}
 else if(adcData > TRESHOLD23){barData = 23;}
 else if(adcData > TRESHOLD22){barData = 22;}
 else if(adcData > TRESHOLD21){barData = 21;}
 else if(adcData > TRESHOLD20){barData = 20;}
 else if(adcData > TRESHOLD19){barData = 19;}
 else if(adcData > TRESHOLD18){barData = 18;}
 else if(adcData > TRESHOLD17){barData = 17;}
 else if(adcData > TRESHOLD16){barData = 16;}
 else if(adcData > TRESHOLD15){barData = 15;}
 else if(adcData > TRESHOLD14){barData = 14;}
 else if(adcData > TRESHOLD13){barData = 13;}
 else if(adcData > TRESHOLD12){barData = 12;}
 else if(adcData > TRESHOLD11){barData = 11;}
 else if(adcData > TRESHOLD10){barData = 10;}
 else if(adcData > TRESHOLD09){barData = 9;}
 else if(adcData > TRESHOLD08){barData = 8;}
 else if(adcData > TRESHOLD07){barData = 7;}
 else if(adcData > TRESHOLD06){barData = 6;}
 else if(adcData > TRESHOLD05){barData = 5;}
 else if(adcData > TRESHOLD04){barData = 4;}
 else if(adcData > TRESHOLD03){barData = 3;}
 else if(adcData > TRESHOLD02){barData = 2;}
 else if(adcData > TRESHOLD01){barData = 1;}
 else{barData = 0;}
 return barData;
}

// parveidojam BAR uz LED stabinu ===============================================
uint32_t barToLeds(uint32_t barData){
 uint32_t ledData = 0;
 if(barData == 0){
  ledData = 0;
 }else if(barData < 32){
  ledData = (1UL << barData)-1;
 }else{
  ledData = 0xFFFFFFFF;
 }
 return ledData;
}

// parveidojam BAR uz PEAK LED stabinu ==========================================
uint32_t peakToLeds(uint32_t peakData){
 uint32_t ledData = 0;
 if(peakData == 0){ledData = 0;}
 else if(peakData < 32){ledData = 1UL << (peakData-1);}
 else if(peakData == 32){ledData = 0b10000000000000000000000000000000;}
 return ledData;
}

//piemerojam stabinam augsanas un krissanas aiztures ============================
void findBarSlow(uint32_t timeOut, uint8_t riseTime){
 if(leftBar > leftBarSlow){
  if(riseTime == 0){
   leftBarSlow = leftBar;
  }else if(leftCounter4 > riseTime){
   leftBarSlow++;
   leftCounter4 = 0;
  }
  leftCounter2 = 0;
 }
 if(leftCounter2 > timeOut){
  if(leftBarSlow > 0){leftBarSlow -= 1;}
  leftCounter2 = 0;
 }
 if(rightBar > rightBarSlow){
  if(riseTime == 0){
   rightBarSlow = rightBar;
  }
  else if(rightCounter4 > riseTime){
   rightBarSlow++;
   rightCounter4 = 0;
  }
  rightCounter2 = 0;
 }
 if(rightCounter2 > timeOut){
  if(rightBarSlow){rightBarSlow -= 1;}
  rightCounter2 = 0;
 }
}
//piemerojam peak max aizturi vai aizturi un krissanu ========================
void findPeaks(uint8_t peakMode){
 if(leftBar > leftPeak){
  leftPeak = leftBar;
  leftCounter1 = 0;
  leftCounter3 = 0;
 }
 if(rightBar > rightPeak){
  rightPeak = rightBar;
  rightCounter1 = 0;
  rightCounter3 = 0;
 }

 if(peakMode == PEAK_HOLD){ // PEAK_HOLD
  if(leftCounter1 > PEAK_HOLD_TIMEOUT){
   leftPeak = leftBar;
   leftCounter1 = 0;
  }
  if(rightCounter1 > PEAK_HOLD_TIMEOUT){
   rightPeak = rightBar;
   rightCounter1 = 0;
  }
 }else{ // PEAK_RAIN
  if(leftCounter3 > PEAK_RAIN_HOLD){
   if(leftCounter1 > PEAK_RAIN_TIMEOUT){
    if(leftPeak > 0){leftPeak -= 1;}
    leftCounter1 = 0;
   }
  }
  if(rightCounter3 > PEAK_RAIN_HOLD){
   if(rightCounter1 > PEAK_RAIN_TIMEOUT){
    if(rightPeak > 0){rightPeak -= 1;}
    rightCounter1 = 0;
   }
  }
 }
}

// aprekinam VU stabinus =====================================================
void calcVU(){
 volatile uint32_t left2=0, right2=0;
 for(uint16_t a=0; a> 2) & ADCMASK); PORTB = (leftLEDs & CRYSTALMASK); break;
  case 1:   PORTC = ((leftLEDs >> 10) & ADCMASK); PORTB = ((leftLEDs >> 8) & CRYSTALMASK);  break;
  case 2:   PORTC = ((leftLEDs >> 18) & ADCMASK); PORTB = ((leftLEDs >> 16) & CRYSTALMASK); break;
  case 3:   PORTC = ((rightLEDs >> 2) & ADCMASK); PORTB = (rightLEDs & CRYSTALMASK); break;
  case 4:   PORTC = ((rightLEDs >> 10) & ADCMASK); PORTB = ((rightLEDs >> 8) & CRYSTALMASK); break;
  case 5:   PORTC = ((rightLEDs >> 18) & ADCMASK); PORTB = ((rightLEDs >> 16) & CRYSTALMASK); break;
  default:    break;
 }
 PORTD = (blockOut[blockIndex] | BUTTONMASK); // iesledzam tagadejo diozu bloku

 blockIndex++; // nakamreiz radisim nakoso bloku
 if(blockIndex>5){ // ja visi bloki paraditi
  blockIndex = 0; // nakamreiz radisim pirmo bloku
 }

// izrekinam un pielabojam VU BAR stabunu vertibask
 leftBarDataVU[samplePointerVU] = leftBarAvg*CORRECTION/leftSamplesCount;
 rightBarDataVU[samplePointerVU++] = rightBarAvg*CORRECTION/rightSamplesCount;
 if(samplePointerVU > SAMPLE_COUNT){samplePointerVU = 0;}

 switch(mode){ // reekinam un raadam izveeleetaa reziima datus
  default:
  case CLIMBING_BARS:
   showClimbingBars();
   break;

  case PEAK_HOLD:
   showPeakHold();
   break;

  case PEAK_RAIN:
   showPeakRain();
   break;

  case CLIMBING_DOTS:
   showClimbingDots();
   break;

  case VU_PEAK_RAIN:
   showVuPeakRain();
   break;

  case VU_AND_PEAK:
   showVuAndPeak();
   break;

  case INTRO:
   showIntro();
   break;
 }

 leftBarAvg = 0; // dzesam videjo vertibu akumulatorus un raadiitaajus
 rightBarAvg = 0;
 leftSamplesCount = 0;
 rightSamplesCount = 0;

 sei(); // iesleedzam partraukumus
}

//------------------------------------------------------------------------
//partraukums uz PD2 (INT0) - nospiesta poga
ISR(INT0_vect) {
 cli();    // izsledzam partraukumus, lai seit mus neviens nepartrauktu
 PORTB = 0b00000000;   // nodzesam visas diodes, pogas spiediena laika
 PORTC = 0b00000000;
 while(!(PIND & _BV(PD2))){    // gaidam, kamer poga tiks atlaista
  _delay_ms(30);   // 'debounce' pauzite
 }
 mode++;        //palielinam mainigo par 1
 if(mode > 5){
  mode = 0;    // ja mainigais lielaks par 5 pieskiram tam veribu 0
 }    // mainiga veriba pec partraukumiem 0-1-2-3-4-5-0-1-2-utt.
 sei();    // iesledam partraukumus atpakal
} // pec izpildisanas lecam atpakal, kur partraucamies

//=== sagatavojam mikrokontrolieri ==============================================
void ioinit(){
 DDRB = 0b11111111;     // PORTB visas izejas
 DDRD = 0b11111011;    // PD2 ieeja (pogai), parejas izejas
 DDRC = 0b11111100;  // acd0 un adc1 ieejas
 PORTD |= _BV(PD2);  // iesledzam "pullup" PD2 ieejai

//----- INT0 partraukuma sagatavosana -----
 MCUCR = 0;    // partraukums uz INT0 un INT1 kajam pie nulles limena, un mes negulam
 GICR |= _BV(INT0);    // aktivizejam INT0 partraukumu

 // Sagatavojam ADC
 //ADCSRA = _BV(ADPS2)|_BV(ADPS1)|_BV(ADPS0); // fosc/128
 //ADCSRA = _BV(ADPS2)|_BV(ADPS1); // fosc/64
 ADCSRA = _BV(ADPS2)|_BV(ADPS0); // fosc/32
 //ADCSRA = _BV(ADPS2); // fosc/16
 //ADCSRA = _BV(ADPS1); // fosc/8 prescaller
 ADCSRA |= _BV(ADEN); // iesledzam ADC moduli

 // TIMER2 sagatavosana
 //TCCR2 = _BV(CS21); // fosc/8
 //TCCR2 = _BV(CS21)|_BV(CS20); // fosc/32
 //TCCR2 = _BV(CS22); // fosc/64
 TCCR2 = _BV(CS22)|_BV(CS20); // fosc/128
 TCCR2 |= _BV(WGM21); // CTC rezims
 OCR2 = 150; // vertiba, liidz kurai taimeris skaitiis
 TIMSK |= _BV(OCIE2); // iesledzam sakrisanas partraugumu ar OCR2

 sei(); // iesledzam (atlaujam) partraukumus
}

//=== galvena funkcija ==========================================================
int main(void){
 ioinit(); // sagatavojam mikrokontrolieri
 sampleADC(); // saakam pirmo ADC parveidosaanu

 while(1){ // bezgaliga cilpa
 // te neko nedaram, viss notiek paartraukumu cilpaas
 }
 return 0;
}

Sīkāk neiedziļināšos, bet, ja rodas jautājumi, droši rakstiet komentāros!
Attēlošans režīmi:
1. “Climbing Bars” – PPM lēni krītoši stabiņi
2. “Peak Hold” – PPM ātri krītoši stabiņi ar PPM max vērtības aizturi (“Peak hold”)
3. “Peak Rain” – PPM ātri krītoši stabiņi ar PPM max vērtības īsu aizturi un krišanu (“Peak rain”)
4. “Climbing Dots” – PPM lēni krītoši punkti
5. “VU Peak Rain” – VU stabiņi ar PPM max vērības aizturi
6. “VU and Peak Rain” - VU stabiņi ar PPM punktu + PPM max aizturi uz pēdējām 3 gaismas diodēm (pie pārslodzes)
Protams, varēju nosaukt saprotamāk, ja nepatīk, varat droši pārsaukt programmā =]

Katrai gasmas diodei atbilst konkrēts audio signālā līmenis decibellos. Ja gribas izmainīt manis definētos līmeņus, starp lejupielādes dokumentiem esmu ielicis arī Exel dokumentu, ar kura palīdzību var aprēķināt ADC sliekšņu vērtības. Kā tas izskatās:

Video, kā tas izskatījās uz maketplates darbībā:

Tā kā uz maketplates “nav interesanti”, uzzīmēju platīti. Izdomāju taisīt tā, ka gaismas diodes ir uz atsevišķas plates, kas tieši pielodēta pie galvenās plates. Nepieciešamības gadījumā šis audio līmeņa indikators ielien arī 1U biezuma korpusā.
Bildes no izgatavošanas:

Ka vairumā gadījumu, steidzoties var kaut kur nokļūdīties. Šoreiz tā gadījās arī man. Tā kā uz maketplates taisīju bez priekšpastiprinātāja, “aizmirsu”, ka tam nepieciešama divpolāra barošana! Smieklīgi vai ne? Lai izietu no situācijas un netaisītu jaunu plati, nācās uztaisīt mazu platīti (ar ICL7660) un pielodēt to kā papildus moduli galvenajai. PROTAMS publicētajās datnēs raksta beigās tas vis ir IZLABOTS un modificēts. Ja kāds izdomās atkārtot manu “projektu” nevajadzētu būt problēmām.

Video darbībā:

Lejupielādēt VU/PPM stereo audio signāla indikatora shēmu, plates zīmējumu un programmu var ŠEIT.

Kā izgatavot radio vadāmu iekštelpu lidmodeli?

Pilots — Tue, 03 Apr 2012 06:13:26 +0000

Tātad es šeit aprakstīšu ceļu, kā es no lētiem materiāliem izgatavoju radiovadāmu lidmašīnu, ar kuru var piedalīties gan Latvijas, gan Baltijas čempionātos.

Visas nepieciešamās detaļas tika sūtītas no www.hobbyking.com , kas ir viens no populārākajiem RC interneta veikaliem pasaulē.

Pielikumā varēsiet atrast visu, kas ir nepieciešams, lai pats varētu uzbūvēt tādu lidmodeli. F3P

Man personīgi bija interesanti pašam uzbūvēt lidmašīnu. Tas man aizņēma aptuveni 4 darba dienas, kuru laikā es pilnveidoju savas zināšanas tehniskajā izpildījumā.

Zemāk ir redzamas pāris bildes, no mana modeļa tapšanas un beigās ir vizuāls piemērs, kādu var nokrāsot savu lidmdoelis. Piebildst varu to ka krāsot tika ar parasto flakona krāsu.

Darbība ir vienkārša:

1. Izgriež no deprona lidmašīnas formu, skatīt pielikumā.EPPYak55_tiled_chg_d EPPYak55_full_chg_d EPPYak55_EZ_tiled_fuselage_chg_d EPPYak55_EZ_tiled_A4_wing_chg_d

2.Visu salīmē kopā un ievēro ka līmēšana notiek ar UHUpor 90 grādu leņķī

3. Iestrādā ogļšķiedras stieņus

4. Uzstāda elektroniku

Mans mīļākais video:

F3P

Ja ir kādas neskaidrības saistībā ar jebko, par šo lidmodeli, droši rakstiet bmx58@inbox.lv

Papildus varu minēt ka šī modeļa klases oficiālais nosaukums ir F3P.

!Cenšamies modeli taisīt pēc iespējas vieglāku!

Noderīgi faili:Yak Build Guide 002

Ģitāras effekta pedāļa Fulltone OCD klons

ibot — Mon, 12 Mar 2012 08:05:30 +0000

Sveicināti visi elektronikas entuziasti, kas interesējas arī par ģitārspēli. Šodien vēlējos Jums izrādīt kādu no saviem nesenajiem veikumiem – paštaisītu ģitāras efekta pedāli (overdrive).Tiem kas nezin, kas ir overdrive, tad tā ir tā signāla kropļošana, kas var būt gan kā kaucoša motorzāģa skaņa, kas liek asinīm vārīties,gan viegla nots sīkstēšana, kas varētu būt laba priekš blūza. Vēsturiski ir sanācis tā, ka overdrive ir radies pilnīgi nejauši, laikā kad visi lietoja lampu pastiprinātājus (ak šie vecie labie laiki) un daži cilvēki pamanīja, ka šat tad pastūžiem pastiprinātais izejas signāls, pie lieliem līmeņiem, bija mazliet kropļots. Par laimi rokmūzikas cienītājiem, šādu defektu ātri lika lietā un radās pirmie rokenrola gabali, kas pakāpeniski pārauga rokā. Kā pirmo ģitāras efektu pedāli izlaida Fuzz Face, ko pirmo reizi pielietoja Roling Stones dziesmā Satisfaction un tieši tas aizsāka lielo rokmūzikas bumu, kā arī to vēlāk pārņēma lietošanā lielākais rokmūzikas virtuozs Jimmy Hendrix.

Kā jau visiem ģitāristiem ir zināms, tad normāla „draiva” iegūšanai nepieciešams izmest bezjēgā diezgan palielu naudas summu uz efektu pedāli, kaut gan tajā pašā laikā iekšā esošās detaļas maksā ļoti maz. Pētot internetā pedāļus nejauši uzdūros kādam video, kur čaļi izrādīja paštaisītu pedāli un tad man beidzot radās ideja, ka vajag izveidot ko tamlīdzīgu. Uzreiz sapratu,ka klonēt kaut kādu Boss Metal Zone2 (MT-2) nav jēgas,jo tas ir reāls ****, bet jāpiemeklē kaut kas dižciltīgs un ķēpāšanās vērts.Par cik tajā laikā biju metis aci uz Xotic BBpreamp, tad izvēlējos klonēt tieši šo. Bet par nelaimi internetā šim brīnumam nebija shēmas.Kādu laiku skatoties gearmanndude kanālu (kas starp citu ir Jack Black kanāls), kur salīdzina visādus ar ģitāru saistītus aprīkojumus sapratu,ka vajag taisīt Fulltone OCD pedāli ,kas pieder pie tubescreamer tipa overdrive efektiem.

http://www.youtube.com/watch?v=TaeI-9rcB9c

Attēlā zemāk oriģinālais OCD un mans klons:

Atrast shēmu bija diezgan ķēpīgi, jo piemēram šī ir OCD v4 shēma, taču internetā klīst visas iepriekšējās + dažās ir ieviestas izmaiņas. Kā es to varēju noteikt: elementāra statistika- ja viena un tā pati shēma dažādos noformējumos(nav identisks fails) klīst pa internetu, tasd droši vien tā ir īstā + arī atsauksmes forumos, kā piemēram: http://www.diystompboxes.com/smfforum/

Tad nu es ķēros pie darba un meklēju rokā detaļas. Apakšā ir shēm

Kā jau iepriekš minēju, tad shēmas izmaksas ir šausmīgi mazas: manējā shēma iekļāvās ap 5Ls, bet kopīgās projekta izmaksas ir ap 15Ls, kas pret aptuveno 180Ls vērto oriģinālu liekas ļoti labi. Tas nu viss vajadzīgais ir dabūjams veikalā Argus.

Shēma tika salodzēta šādi uz maketplates un iebāzta korpusā:

Labākai aizsardzībai es ievietoju shēmu un barošanu maisiņos, lai shēmā nesanāk īssavienojums:

Korpusam es izvēlējos šādu alumīnija kasti: http://web.argus.lv/shop/productinfo/ZA.G106/hwindex.htm

Jāsaka, ka diezgan grūti bija sabāzt visu šajā mazajā kastītē, tapēc ir jārēķinās, ka normālu 3pdt vai dpdt footswitch’u (ar kāju spiežamu spiedpogu) ieliekot potentiometri ir jāizkārto ļoti apdomīgi.

Veicot šo projektu es atradu un uzzināju daudz dažādu knifiņu. Piemēram 3pdt vai dpdt spiedpogu var dabūt tikai ebay,jo latvijā neesmu nekur manījis (ja kāds atrod,tad droši ierakstat komentāros kur var nopirkt tās), toties ebay piedāvā veselu lērumu no ķīnas par labām cenām. Vispār ja kāds sāk nodarboties ar šo lietu nopietnāk, tad daudzas lietas būs jāmeklē ebay,jo piemēram ģermānija tranzistorus un diodes ir ļoti grūti atrast veikalos.

Savā „pedālī” es lietoju dpdt tumbler slēdžus, kas būtībā ir pats lētākais analogs, ko var pielietot shēmas pieslēgšanai.

Galvenais mērķis ir nodrošināt tā saucamo true bypass ,kas ļauj ģitāras signāla palikt nemainīgam,kad pedālis ir izslēgts. Priekš sīkākas informācijas meklējiet googlā „true bypass dpdt wiring”. Var arī pielietot šādu slēgumu,kā paraugu(skatīt sarkanos vadus):

Tā nu beigās kad korpuss tika samontēts es izdomāju to nokrāsot oriģinālā baltā krāsā un uzpūst ar stencil trafaretu mākslinieka Banksy žurkas- šveicarus, kas uzņem viesus pie žurku alas.

Kopumā es esmu ļoti apmierināts ar rezultātu, šis pedālis skan godam un ir jau saņēmis labas atsauksmes no citiem. Iesaku katram ģitāristam izveidot savu pedāli,jo pēc tam ir neaprakstāms gandarījums par paveiktu un apziņa,ka esi radījis kaut ko īpašu tikai sev - savu īpašo pedāli. Domāju daudzi citi ģitāristi to novērtētu.

Atmega8 gaismas diožu vadība 2. daļa – nobīdes reģistri

KasparsL — Mon, 12 Mar 2012 07:52:50 +0000

Tā kā bija interesenti, nolēmu paturpināt iepriekšējo rakstu Atmega8 gaismas diožu vadība + pārtraukumi. Turpināšu “C” valodā ar AVRStudio4 un ATMEGA8 (var arī 48/88/168/328 ar nelielām koda izmaiņām), (neaizmirstam projekta iestatījumos izvēlēties pareizo MCU un tā takts frekvenci!).

Ne vienmēr, mikro kontrolierim ir pietiekami daudz izvadu, lai pieslēgtu visas ierīces, kurām nepieciešams salīdzinoši daudz izvadu, piemēram, vizuālas informācijas attēlošanai – gaismas diodes. Ne vienmēr ir iespējams, vai izdevīgi, izvēlēties mikro kontrolieri ar lielāku izvadu skaitu. Šādā situācijā palīdz datu sūtīšanas nevis paralēli (visus vienlaicīgi), bet seriāli (pēc kārtas). Šos seriāli sūtītos datus spēj “atkodēt” atpakaļ uz paralēlajiem datiem, speciāli šim nolūkam paredzētas mikroshēmas. Tādas ir ļoti daudz un dažādas (visas tās strādā līdzīgi), bet mēs apskatīsim vienkāršu, lētu un ātru mikroshēmu – 74HC595.

Šī mikroshēmai (74HC595) ir 8 paralēlo datu izvadi. Tā saprot seriālos datus, kas sūtīti ar SPI (Serial Peripheral Interface) interfeisa palīdzību. Šis interfeis izmantos tikai 3 mikro kontroliera izvadus, neatkarīgi no paralēlo datu izvadu skaita (piem: vajag ārā dabūt 8, iekšā 3. vajag dabūt ārā 512, iekšā 3). Daudzi mikro kontrolieri ir aprīkoti ar “hardware” (jeb iebūvētu agregāta) SPI interfeisu – ATMEGA8/48/88/168/328 arī. Mēs apkskatīsim gan hardware SPI, gan software SPI (softiski rakstīto). Atšķirība starp tiem abiem ir ātrdarbībā – softiskais ir lēnāks, bet, toties, to var izveidot pat uz ATTINY11 vai PIC10F200.

Kas šoreiz būs nepieciešams:
- ATMEGA8/8A mikro kontrolieris (ar nelielām programmas izmaiņām Atmega48/88/168/328)
- 3x 74HC595 seriālie nobīdes reģistri
- 24x gaismas diodes
- 24x rezistori (gaismas diožu strāvas ierobežošanai)
- kondensators 100n jebkāds
- barošanas bloks vai baterijas, vai cits barošanas avots 3-5V
- spiedpoga (“tact switch”)
- maketplate (nelodējamā, bet protams, var arī uztaisīt iespiedplati)
- savienotājvadiņi
- AVR programmators (piem. AVRISP vai cits, vai paštaisīts)
- un atkal nedaudz brīva laika ;)

Tad, tāpat kā iepriekš – Pārliecinieties, ka protat programmu kompilēt un ielādēt mikro kontrolierī!

Principiālā shēma (lejupielādēt varat šeit):

Kā redzat, shēma ir nosacīti sadalīta blokos: uC – mikro kontroliera daļa un ’1′, ’2′, ’3′ – seriāli/ paralēlo datu pārveidotāju moduļi, pa 8 izejām katram. ‘n’ – nozīmē, ka iespējams galā pievienot vēl papildus (20 gab. droši) moduļus.

Sākumā “saspraudīsim” (izveidosim) tikai daļu no shēmas. Saliksim tikai daļas “uC” un “1“. Mans “veidojums” uz maketplates izskatās šādi.

SPI interfeis tiek nodrošināts ar 3 datu izvadiem. Šie izvadi ir DATA (seriālie dati), CLOCK (strobēšana, takts impulsi jeb “pulkstenis”) un LATCH (aizture, dati tiek aizturēti 74HC595 aiztures reģistrā – tiek parādīti).

Sāksim ar “softisko SPI”
Sākumā, lai būtu ērtāk, definējam (pārsaucam) mūsu izvadus saprotamāk:

//definējam (aizstājam) mainīgos saprotamāk
#define SPIPORT PORTB
#define DATA   3
#define CLOCK  5
#define LATCH  2

Tagad “PORTB” vietā varam rakstīt “SPIPORT”, “3″ vietā – “DATA” utt. Vēl mikro kontrolierim jāpasaka, ka šie izvadi būs izejas nevis ieejas. Es pasaku vienkārši – visi PORTB izvadi būs izejas.

DDRB = 0b11111111;     // PORTB visas izejas

Vēl mums vajadzēs interesantu funkciju, kas “neko nedara” vienu mikro kontroliera takti. Aizstājam, lai būtu ērtāk un saprotamāk:

#define NOP asm("nop"); // definējam īsāk 1 takti "nekā nedarīšanas" funkciju

Sakam “NOP” – mikrokontrolieris neko nedara, sakam 100 reizes “NOP” – mikro kontrolieris neko nedara (“strādā pa tukšo”) 100 cpu taktis.

Un beidzot, datu izvades funkcija, nosaucu to ‘softSpiTransfer(uint8_t spiData);’ :

void softSpiTransfer(uint8_t spi_data){ // nosutam 8 bitus (spi_data) sakot ar jaunako bitu
  for(uint8_t bitNumber=0; bitNumber<8; bitNumber++){
    SPIPORT &= ~_BV(DATA);  // datu izvads '0'
    if(((spi_data >> bitNumber) & 1) == 1){
      SPIPORT |= _BV(DATA);  // datu izvads '1'
    }
    SPIPORT |= _BV(CLOCK);  // clock izvads '1'
    NOP;  //nedaram neko 1 takti
    SPIPORT &= ~_BV(CLOCK);  // clock izvads '0'
  }
}

Pēc šīs funkcijas izpildes, dati tiek “nobīdīti” par 8 bitiem ārā uz mūsu 74HC595 mikroshēmu. Bet pagaidiet! Mūsu dati tur ir (iekš 74HC595 mikroshēmas), bet nav redzami uz gaismas diodēm! Kad visi dati “nobīdīti kā vajag”, tos vajag ierakstīt 74HC595 nobīdes reģistra aiztures buferī. To var izdarīt, padodod īsu pozitīvu impulsu uz “LATCH” izvadu. Daram to šādi:

 //...
  SPIPORT |= _BV(LATCH);  // latch izvads '1'
  NOP;
  SPIPORT &= ~_BV(LATCH);  // latch izvads '0'
 //...

Nu tad saliekam visu kopā, tādā pašā “stilā” kā iepriekšējajā rakstā (piemērā “1″), sanāk šis - “piemērs1″ ar softisko SPI:

// Piemers 1 software SPI - 1x 74HC595 - 8x LEDs

#include   // ieejas-izejas biblioteka
#include  // aiztures biblioteka

// definejam (nosaucam) izvadu numurus saprotamak
#define SPIPORT PORTB
#define DATA   3
#define CLOCK  5
#define LATCH  2

// definejam "neko nedarishanas instrukciju" (neko nedara vienu uC takti), lai nebutu gari jaraksta
#define NOP asm("nop");

void softSpiTransfer(uint8_t spi_data){ // nosutam 8 bitus (spi_data) sakot ar jaunako bitu
  for(uint8_t bitNumber=0; bitNumber<8; bitNumber++){
    SPIPORT &= ~_BV(DATA);  // datu izvads '0'
    if(((spi_data >> bitNumber) & 1) == 1){
      PORTB |= _BV(DATA);  // datu izvads '1'
    }
    SPIPORT |= _BV(CLOCK);  // clock izvads '1'
    NOP;  //nedaram neko 1 takti
    SPIPORT &= ~_BV(CLOCK);  // clock izvads '0'
  }
}

void showSpiData(){  // paradam aizsutito informaciju
  SPIPORT |= _BV(LATCH);  // latch izvads '1'
  NOP;
  SPIPORT &= ~_BV(LATCH);  // latch izvads '0'
}

void ioinit(){
  DDRB = 0b11111111; // PORTB visas izejas
}

void showSequence1(){ // paradam pirmo sablonu un atgriezamies atpakal
  softSpiTransfer(0b00000001);
  showSpiData();
  _delay_ms(300);
  softSpiTransfer(0b00000011);
  showSpiData();
  _delay_ms(300);
  softSpiTransfer(0b00000111);
  showSpiData();
  _delay_ms(300);
  softSpiTransfer(0b00001111);
  showSpiData();
  _delay_ms(300);
  softSpiTransfer(0b00011111);
  showSpiData();
  _delay_ms(300);
  softSpiTransfer(0b00111111);
  showSpiData();
  _delay_ms(300);
  softSpiTransfer(0b01111111);
  showSpiData();
  _delay_ms(300);
  softSpiTransfer(0b11111111);
  showSpiData();
  _delay_ms(300);
}

int main(void){
  ioinit(); // sagatavojam mikroprocesoru
  while(1){ // izpildit vienmer (bezgaliga cilpa)
    showSequence1();
  }
  return 0;
}

“Hardware SPI”

Kā jau sapratāt, Atmega8 (u.c.) satur iebūvētu SPI moduli. Ja Jūsu programmā tas jau nav aizņemts ar citu darbu, labāk izmatot to, nevis “softisko” SPI. Atšķirībā no “softiskā” risinājuma, kuram var tikt izmatotas jebkuras digitālās izejas pieslēgvietas, “dzelziskajam” jāizmanto konkrētas “DATA” un “CLOCK” pieslēgvietas (“LATCH” var būt jebkura). “DATA” izvadam jābūt “PB3″ jeb “MOSI” (master out slave in), “CLOCK” izvadam jābūt “PB5″ jeb “SCK”. Tā pat kā softiskajam, dzelziskajam SPI, izvadi jādefine kā “izejas”. Es pasaku vienkārši – visi PORTB izvadi būs izejas.

DDRB = 0b11111111;     // PORTB visas izejas

Lai iebūvēto SPI moduli izmantotu, tas sākumā ir jāieslēdz.

// Iesledzam iebuveto SPI, Master rezima, jaunakais bits pirmais, ar atrumu taktsFrekvence/2 (lielako)
SPCR = (1<
Palasīt smalkāk par iebūvēto SPI moduli, varam mikrokontroliera dokumentācijā.

Ieslēdzot, pasakam mikro kontrolierim arī cik ātri un ar kādiem parametriem SPI modulim jāstrādā. Pēc tam tas ir gatavs lietošanai.

Lai nosūtītu 8 bitus datu, dati jāiekopē ‘SPDR’ reģistrā (ar to automātiski sākas sūtīšana), pēc tam jāsagaida tās beigas, pārbaudot ‘SPIF’ bitu ‘SPSR’ reģistrā.
 SPDR = spi_data; // sakam sutishanu
 while(!(SPSR & (1<
Datu izsūtīšanai uzrakstīju funkciju “hardSpiTransfer(uint8_t spiData);, kas ietver sevī iepriekšējās rindiņas” .

Pēc šīm rindiņām, dati tiek “nobīdīti” par 8 bitiem ārā uz mūsu 74HC595 mikroshēmu. Tā pat kā ar softisko SPI, dati tur ir, bet nav redzami uz gaismas diodēm, tos vajag ierakstīt 74HC595 nobīdes reģistra aiztures buferī. To var izdarīt, padodod īsu pozitīvu impulsu uz “LATCH” izvadu.
 //...
  LATCHPORT |= _BV(LATCH);  // latch izvads '1'
  NOP;
  LATCHPORT = ~_BV(LATCH);  // latch izvads '0'
 //...
Tad nu “piemērs1″ ar iebūvēto SPI :
// Piemers 1 hardware SPI - 1x 74HC595 - 8x LEDs

#include   // ieejas-izejas biblioteka
#include  // aiztures biblioteka

// definejam (nosaucam) izvadu numurus saprotamak
#define SPIPORT PORTB
#define LATCH  2

// definejam "neko nedarishanas instrukciju" (neko nedara vienu uC takti), lai nebutu gari jaraksta
#define NOP asm("nop");

void hardSpiTransfer(uint8_t spi_data){ // nosutam 8 bitus (spi_data) sakot ar jaunako bitu
  SPDR = spi_data; // sakam sutishanu
  while(!(SPSR & (1<
Tā, ka tagad protam izvadīt datus uz nobīdes reģistru, varam eskperimentēt tālāk. Piemēram, paņemam kodu (piemērs5) no iepriekšējā raksta, un pārveidojam priekš mūsu shēmas (“dzelžiem”) software SPI režīmā:
// piemers5 software SPI 1x 74HC595, 8x LEDs

#include       // ieejas-izejas biblioteka
#include       // partraukumu biblioteka
#include      // aiztures biblioteka
#include   // biblioteka tiesai datu piekluve "program memory"

volatile uint8_t  flag = 0;
volatile uint8_t  buttonInterruptFlag = 0;
volatile uint8_t  _index = 0;

// definejam (nosaucam) izvadu numurus saprotamak
#define SPIPORT PORTB
#define DATA   3
#define CLOCK  5
#define LATCH  2

#define BUTTONPIN PIND
#define BUTTON 2

// definejam "neko nedarishanas instrukciju" (neko nedara vienu uC takti), lai nebutu gari jaraksta
#define NOP asm("nop");

void softSpiTransfer(uint8_t spi_data){ // nosutam 8 bitus (spi_data) sakot ar jaunako bitu
 for(uint8_t bitNumber=0; bitNumber<8; bitNumber++){
 SPIPORT &= ~_BV(DATA);  // datu izvads '0'
 if(((spi_data >> bitNumber) & 1) == 1){
  PORTB |= _BV(DATA);  // datu izvads '1'
 }
 SPIPORT |= _BV(CLOCK);  // clock izvads '1'
 NOP;  //nedaram neko 1 takti
 SPIPORT &= ~_BV(CLOCK);  // clock izvads '0'
 }
}

void showSpiData(){  // paradam aizsutito informaciju
 SPIPORT |= _BV(LATCH);  // latch izvads '1'
 NOP;
 SPIPORT &= ~_BV(LATCH);  // latch izvads '0'
}

uint8_t sequence1data[8] PROGMEM = {
 0b10000000,      //pirma sablona datu kopa PROGMEM atmina
 0b01000000,
 0b00100000,
 0b00010000,
 0b00001000,
 0b00000100,
 0b00000010,
 0b00000001    };

uint8_t sequence2data[2] PROGMEM = {
 0b11110000,      //otra sablona datu kopa PROGMEM atmina
 0b00001111    };

uint8_t sequence3data[16] PROGMEM = {
 0b00000001,      //tresa sablona datu kopa PROGMEM atmina
 0b00000011,
 0b00000111,
 0b00001111,
 0b00011111,
 0b00111111,
 0b01111111,
 0b11111111,
 0b11111110,
 0b11111100,
 0b11111000,
 0b11110000,
 0b11100000,
 0b11000000,
 0b10000000,
 0b00000000    };

uint8_t sequence4data[8] PROGMEM = {
 0b00011000,      //ceturta sablona datu kopa PROGMEM atmina
 0b00111100,
 0b01111110,
 0b11111111,
 0b11100111,
 0b11000011,
 0b10000001,
 0b00000000    };

ISR(INT0_vect) {  //leksim seit, ja konstatets partraukums uz PD2 (INT0)
 cli();    // izsledzam partraukumus, lai seit mus neviens nepartrauktu
 PORTB = 0b00000000;   // nodzesam visas diodes, pogas spiediena laika
 while(!(BUTTONPIN & _BV(BUTTON))){    // gaidam, kamer poga tiks atlaista
  _delay_ms(30);   // 'debounce' pauzite
 }
 buttonInterruptFlag = 1;  // atzimejam, ka ir noticis partraukums, un ir japarsledz rezims
 flag++;        //palielinam mainigo par 1
 if(flag > 3){
  flag = 0;    // ja mainigais lielaks par 3 pieskiram tam veribu 0
 }    // mainiga veriba pec partraukumiem 1-0-1-0-utt.
 sei();    // iesledam partraukumus atpakal
} // pec izpildisanas lecam atpakal, kur partraucamies

void special_delay(uint16_t time_ms){// speciala pauze, kura tiek partraukta, ja noticis partraukums
 while((time_ms > 0) && (buttonInterruptFlag == 0)){  // kamer nav noticis partraukums un nav veikts 'time_ms'
  _delay_ms(1);                                    // rezes partraukums, turpinam 'cilpot' !
  time_ms--;   // pec katras cilpas samazinam cilpu skaititaju par 1
 }
}

void showSequence1(){
 _index = 8;  // cik efektam ir ierakstu
 while((_index > 0) && (buttonInterruptFlag == 0)){ // ja nav paradits viss efekts un nav noticis partraukums, turpinam
  softSpiTransfer(pgm_read_byte(sequence1data + (8-_index)));    // nolsam datus, kura adrese ir datuKopa + ierakstaNumurs
  showSpiData();
  special_delay(200);  // speciala pauze, kura tiek partraukta, ja mainiga noticis partraukums
  _index--;
 }
}

void showSequence2(){
 _index = 2;  // cik efektam ir ierakstu
 while((_index > 0) && (buttonInterruptFlag == 0)){ // ja nav paradits viss efekts un nav noticis partraukums, turpinam
  softSpiTransfer(pgm_read_byte(sequence2data + (2-_index)));    // nolsam datus, kura adrese ir datuKopa + ierakstaNumurs
  showSpiData();
  special_delay(700);  // speciala pauze, kura tiek partraukta, ja mainiga noticis partraukums
  _index--;
 }
}

void showSequence3(){
 _index = 16;  // cik efektam ir ierakstu
 while((_index > 0) && (buttonInterruptFlag == 0)){ // ja nav paradits viss efekts un nav noticis partraukums, turpinam
  softSpiTransfer(pgm_read_byte(sequence3data + (16-_index)));    // nolsam datus, kura adrese ir datuKopa + ierakstaNumurs
  showSpiData();
  special_delay(100);  // speciala pauze, kura tiek partraukta, ja mainiga noticis partraukums
  _index--;
 }
}

void showSequence4(){
 _index = 8;  // cik efektam ir ierakstu
 while((_index > 0) && (buttonInterruptFlag == 0)){ // ja nav paradits viss efekts un nav noticis partraukums, turpinam
  softSpiTransfer(pgm_read_byte(sequence4data + (8-_index)));    // nolsam datus, kura adrese ir datuKopa + ierakstaNumurs
  showSpiData();
  special_delay(500);  // speciala pauze, kura tiek partraukta, ja mainiga noticis partraukums
  _index--;
 }
}

void ioinit(){
 DDRB = 0b11111111;     // PORTB visas izejas
 DDRD = 0b11111011;    // PD2 ieeja (pogai)
 PORTD |= _BV(BUTTON);  // iesledzam "pullup" pogai

 //  Ja lietojat Atmega8, tad INT0 partraukumu konfigurejam sadi
 MCUCR = 0;    // partraukums uz INT0 un INT1 kajam pie nulles limena, un mes negulam
 GICR |= _BV(INT0);    // aktivizejam INT0 partraukumu

 //  Ja lietojat Atmega48/88/168/328, tad INT0 partraukumu konfigurejam sadi
//     EICRA = 0;    // partraukums uz INT0 un INT1 kajam pie nulles limena
//     EIMSK |= _BV(INT0);    // aktivizejam INT0 partraukumu
 sei();    // iesledzam partraukumus
}

int main(void){
 ioinit();     // sagatavojam mikroprocesoru
 while(1){     // izpildit vienmer (bezgaliga cilpa)
  buttonInterruptFlag = 0;  // atzimejam, ka esam jau 'izlekusi' ara noefekta, lai tagad tur paliktu
  switch(flag){
   case 0: showSequence1(); break;
   case 1: showSequence2(); break;
   case 2: showSequence3(); break;
   case 3: showSequence4(); break;
   default: break;
  }
 }
 return 0;
}
.
Paskatīsimies video, kā rezultāts izskatās dzīvē:



Piemērs1 – ATMEGA8, 1x74HC595, 8xLED


Piemērs5 – ATMEGA8, 1x74HC595, 8xLED





.
Ar vienu nobīdes reģistru esam tikuši skaidrībā! Kabinam (pievienojam) vēl divus moduļus – ’2′ un ’3′.

Manis ‘saspraustais’ uz maketplates izskatās šādi:


Tātad: ar funkcijas “softSpiTransfer(uint8_t spiData);” un “hardSpiTransfer(uint8_t spiData);” mēs datus ‘izbīdam’ (pārvietojam) par astoņiem bitiem (8bit) uz tuvāko nobīdes reģistru (74HC595 modulī ’1′). Tātad, lai nosūtītu (nobīdītu) datus priekš visiem trīs moduļiem, tas jādara 3 reizes. Sākumā ‘bīdam’ datus tālākajam modulim ’3′, tad modulim ’2′, un beigās tuvākajam modulim ’1′. Pēc tam kad dati ‘sabīdīti’ kā vajag, tā pat kā iepriekš, lai parādītu, tos vajag ierakstīt nobīdes reģistru buferī.
Kā tas izskatās, izmantojot softisko SPI:
//izmantojam iepriekš uzrakstīto funkciju
softSpiTransfer(0b00000001); // dati modulim '3'
softSpiTransfer(0b01111111); // dati modulim '2'
softSpiTransfer(0b10000000); // dati modulim '1'
showSpiData(); // parādam datus
Piemērs 1, izmantojot softisko SPI, ar 3 nobīdes reģistriem un 24 gaismas diodēm:
// Piemers 1 software SPI - 3x 74HC595 - 24x LEDs

#include   // ieejas-izejas biblioteka
#include  // aiztures biblioteka

// definejam (nosaucam) izvadu numurus saprotamak
#define SPIPORT PORTB
#define DATA   3
#define CLOCK  5
#define LATCH  2

// definejam "neko nedarishanas instrukciju" (neko nedara vienu uC takti), lai nebutu gari jaraksta
#define NOP asm("nop");

void softSpiTransfer(uint8_t spi_data){ // nosutam 8 bitus (spi_data) sakot ar jaunako bitu
 for(uint8_t bitNumber=0; bitNumber<8; bitNumber++){
  SPIPORT &= ~_BV(DATA);  // datu izvads '0'
  if(((spi_data >> bitNumber) & 1) == 1){
   PORTB |= _BV(DATA);  // datu izvads '1'
  }
  SPIPORT |= _BV(CLOCK);  // clock izvads '1'
  NOP;  //nedaram neko 1 takti
  SPIPORT &= ~_BV(CLOCK);  // clock izvads '0'
 }
}

void showSpiData(){  // paradam aizsutito informaciju
 SPIPORT |= _BV(LATCH);  // latch izvads '1'
 NOP;
 SPIPORT &= ~_BV(LATCH);  // latch izvads '0'
}

void ioinit(){
 DDRB = 0b11111111; // PORTB visas izejas
}

void showSequence1(){ // paradam pirmo sablonu un atgriezamies atpakal
 softSpiTransfer(0b00000001);
 softSpiTransfer(0b01111111);
 softSpiTransfer(0b10000000);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00000011);
 softSpiTransfer(0b01111110);
 softSpiTransfer(0b11000000);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00000111);
 softSpiTransfer(0b00111110);
 softSpiTransfer(0b11100000);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00001111);
 softSpiTransfer(0b00111100);
 softSpiTransfer(0b11110000);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00011111);
 softSpiTransfer(0b00011100);
 softSpiTransfer(0b11111000);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00111111);
 softSpiTransfer(0b00011000);
 softSpiTransfer(0b11111100);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b01111111);
 softSpiTransfer(0b00001000);
 softSpiTransfer(0b11111110);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b11111111);
 softSpiTransfer(0b00000000);
 softSpiTransfer(0b11111111);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b01111111);
 softSpiTransfer(0b00010000);
 softSpiTransfer(0b11111110);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00111111);
 softSpiTransfer(0b00011000);
 softSpiTransfer(0b11111100);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00011111);
 softSpiTransfer(0b00111000);
 softSpiTransfer(0b11111000);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00001111);
 softSpiTransfer(0b00111100);
 softSpiTransfer(0b11110000);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00000111);
 softSpiTransfer(0b01111100);
 softSpiTransfer(0b11100000);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00000011);
 softSpiTransfer(0b01111110);
 softSpiTransfer(0b11000000);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00000001);
 softSpiTransfer(0b11111110);
 softSpiTransfer(0b10000000);
 showSpiData();
 _delay_ms(150);
 softSpiTransfer(0b00000000);
 softSpiTransfer(0b11111111);
 softSpiTransfer(0b00000000);
 showSpiData();
 _delay_ms(150);
}

int main(void){
 ioinit(); // sagatavojam mikroprocesoru
 while(1){ // izpildit vienmer (bezgaliga cilpa)
  showSequence1();
 }
 return 0;
}
Ne vienmēr parādāmie dati atrodas atsevišķos 8bit ‘gabalos’.  Gadījumā, ja dati atrodas 32bit mainīgajā? Viens no risinājumiem ir darīt šādi (sūtīt daļu bitu trīs reizes):
softSpiTransfer(outputData & 0xFF); // nosutam mainigaa "outputData" 1...8 bitus
softSpiTransfer((outputData >> 8) & 0xFF); // nosutam mainigaa "outputData" 8...16 bitus
softSpiTransfer((outputData >> 16) & 0xFF); // nosutam mainigaa "outputData" 16...24 bitus
showSpiData();
Un piemērs 2 izmantojot šo ‘tehniku’:
// Piemers 2 software SPI - 3x 74HC595 - 24x LEDs

#include   // ieejas-izejas biblioteka
#include  // aiztures biblioteka

// definejam (nosaucam) izvadu numurus saprotamak
#define SPIPORT PORTB
#define DATA   3
#define CLOCK  5
#define LATCH  2

// definejam "neko nedarishanas instrukciju" (neko nedara vienu uC takti), lai nebutu gari jaraksta
#define NOP asm("nop");

void softSpiTransfer(uint8_t spi_data){ // nosutam 8 bitus (spi_data) sakot ar jaunako bitu
 for(uint8_t bitNumber=0; bitNumber<8; bitNumber++){
  SPIPORT &= ~_BV(DATA);  // datu izvads '0'
  if(((spi_data >> bitNumber) & 1) == 1){
   PORTB |= _BV(DATA);  // datu izvads '1'
  }
  SPIPORT |= _BV(CLOCK);  // clock izvads '1'
  NOP;  //nedaram neko 1 takti
  SPIPORT &= ~_BV(CLOCK);  // clock izvads '0'
 }
}

void showSpiData(){  // paradam aizsutito informaciju
 SPIPORT |= _BV(LATCH);  // latch izvads '1'
 NOP;
 SPIPORT &= ~_BV(LATCH);  // latch izvads '0'
}

void ioinit(){
 DDRB = 0b11111111; // PORTB visas izejas
}

void showSequence1(){ // paradam pirmo sablonu un atgriezamies atpakal
 uint32_t outputData;
 for(uint8_t count=1; count<25; count++){ // pirmaa efekta cilpa
  outputData = (1UL << count) - 1; // izveidojam paradishanai vajadzigos datus
  softSpiTransfer(outputData & 0xFF); // nosutam mainigaa "outputData" 1...8 bitus
  softSpiTransfer((outputData >> 8) & 0xFF); // nosutam mainigaa "outputData" 8...16 bitus
  softSpiTransfer((outputData >> 16) & 0xFF); // nosutam mainigaa "outputData" 16...24 bitus
  showSpiData();
  _delay_ms(150);
 }
 for(uint8_t count=1; count<25; count++){ // otraa efekta cilpa
  outputData = ((1UL << (25-count)) - 1) << count; // izveidojam paradishanai vajadzigos datus
  softSpiTransfer(outputData & 0xFF); // nosutam mainigaa "outputData" 1...8 bitus
  softSpiTransfer((outputData >> 8) & 0xFF); // nosutam mainigaa "outputData" 8...16 bitus
  softSpiTransfer((outputData >> 16) & 0xFF); // nosutam mainigaa "outputData" 16...24 bitus
  showSpiData();
  _delay_ms(150);
 }
}

int main(void){
 ioinit(); // sagatavojam mikroprocesoru
 while(1){ // izpildit vienmer (bezgaliga cilpa)
  showSequence1();
 }
 return 0;
}
Un tad nobeigumam publicēšu vēl vienu piemēru iedvesmai, piemērs 3:
// piemers3 hardware SPI 3x 74HC595, 24x LEDs

#include       // ieejas-izejas biblioteka
#include       // partraukumu biblioteka
#include      // aiztures biblioteka
#include   // biblioteka tiesai datu piekluve "program memory"

volatile uint8_t  flag = 0;
volatile uint8_t  buttonInterruptFlag = 0;
volatile uint8_t  _index = 0;

// definejam (nosaucam) izvadu numurus saprotamak
#define SPIPORT PORTB
#define DATA   3
#define CLOCK  5
#define LATCH  2

#define BUTTONPIN PIND
#define BUTTON 2

// definejam "neko nedarishanas instrukciju" (neko nedara vienu uC takti), lai nebutu gari jaraksta
#define NOP asm("nop");

void softSpiTransfer(uint8_t spi_data){ // nosutam 8 bitus (spi_data) sakot ar jaunako bitu
 for(uint8_t bitNumber=0; bitNumber<8; bitNumber++){
  SPIPORT &= ~_BV(DATA);  // datu izvads '0'
  if(((spi_data >> bitNumber) & 1) == 1){
   PORTB |= _BV(DATA);  // datu izvads '1'
  }
  SPIPORT |= _BV(CLOCK);  // clock izvads '1'
  NOP;  //nedaram neko 1 takti
  SPIPORT &= ~_BV(CLOCK);  // clock izvads '0'
 }
}

void showSpiData(){  // paradam aizsutito informaciju
 SPIPORT |= _BV(LATCH);  // latch izvads '1'
 NOP;
 SPIPORT &= ~_BV(LATCH);  // latch izvads '0'
}

uint8_t sequence1data[3*4] PROGMEM = {  // pirma sablona datu kopa PROGMEM atmina
 0b11111111, 0b00000000, 0b00000000,
 0b00000000, 0b11111111, 0b00000000,
 0b00000000, 0b00000000, 0b11111111,
 0b00000000, 0b11111111, 0b00000000 };

uint8_t sequence2data[3*27] PROGMEM = {  // otra sablona datu kopa PROGMEM atmina
 0b00000000, 0b00011000, 0b00000000,
 0b00000000, 0b00111100, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b11111111, 0b01111110, 0b11111111,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b11111111, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b11111111, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b11111111,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b11111111,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b01111110, 0b00000000,
 0b00000000, 0b00111100, 0b00000000,
 0b00000000, 0b00011000, 0b00000000,
 0b00000000, 0b00000000, 0b00000000,
 0b00000000, 0b00000000, 0b00000000,
 0b00000000, 0b00000000, 0b00000000 };

uint8_t sequence3data[16] PROGMEM = {  // tresa sablona datu kopa PROGMEM atmina
 0b00000001,
 0b00000011,
 0b00000111,
 0b00001111,
 0b00011111,
 0b00111111,
 0b01111111,
 0b11111111,
 0b11111110,
 0b11111100,
 0b11111000,
 0b11110000,
 0b11100000,
 0b11000000,
 0b10000000,
 0b00000000    };

ISR(INT0_vect) {  //leksim seit, ja konstatets partraukums uz PD2 (INT0)
 cli();    // izsledzam partraukumus, lai seit mus neviens nepartrauktu
 PORTB = 0b00000000;   // nodzesam visas diodes, pogas spiediena laika
 while(!(BUTTONPIN & _BV(BUTTON))){    // gaidam, kamer poga tiks atlaista
  _delay_ms(30);   // 'debounce' pauzite
 }
 buttonInterruptFlag = 1;  // atzimejam, ka ir noticis partraukums, un ir japarsledz rezims
 flag++;        //palielinam mainigo par 1
 if(flag > 3){
  flag = 0;    // ja mainigais lielaks par 3 pieskiram tam veribu 0
 }    // mainiga veriba pec partraukumiem 1-0-1-0-utt.
 sei();    // iesledam partraukumus atpakal
} // pec izpildisanas lecam atpakal, kur partraucamies

void special_delay(uint16_t time_ms){// speciala pauze, kura tiek partraukta, ja noticis partraukums
 while((time_ms > 0) && (buttonInterruptFlag == 0)){  // kamer nav noticis partraukums un nav veikts 'time_ms'
_delay_ms(1);                                    // rezes partraukums, turpinam 'cilpot' !
time_ms--;   // pec katras cilpas samazinam cilpu skaititaju par 1
}
}

void special_short_delay(uint16_t time_us){// speciala pauze, kura tiek partraukta, ja noticis partraukums
 while((time_us > 0) && (buttonInterruptFlag == 0)){  // kamer nav noticis partraukums un nav veikts 'time_ms'
  _delay_us(1);                                    // rezes partraukums, turpinam 'cilpot' !
  time_us--;   // pec katras cilpas samazinam cilpu skaititaju par 1
 }
}

void showSequence1(){ // paradam pirmo sablonu un atgriezamies atpakal
 uint8_t count = 0;
 while((count < (3*4)) && (buttonInterruptFlag == 0)){ // ja nav paradits viss efekts un nav noticis partraukums, turpinam
  softSpiTransfer(pgm_read_byte(sequence1data + count+2)); // sutam 3 registra datus ("3")
  softSpiTransfer(pgm_read_byte(sequence1data + count+1)); // sutam 2 registra datus ("2")
  softSpiTransfer(pgm_read_byte(sequence1data + count)); // sutam 1 registra datus ("1")
  count+=3;
  showSpiData();
  special_delay(250);
 }
}

void showSequence2(){ // paradam otro sablonu un atgriezamies atpakal
 uint8_t count2 = 0;
 while((count2 < (3*27)) && (buttonInterruptFlag == 0)){ // ja nav paradits viss efekts un nav noticis partraukums, turpinam
  softSpiTransfer(pgm_read_byte(sequence2data + count2+2)); // sutam 3 registra datus ("3")
  softSpiTransfer(pgm_read_byte(sequence2data + count2+1)); // sutam 2 registra datus ("2")
  softSpiTransfer(pgm_read_byte(sequence2data + count2)); // sutam 1 registra datus ("1")
  count2+=3;
  showSpiData();
  special_delay(70);
 }
}

void showSequence3(){ // paradam tresho sablonu un atgriezamies atpakal
 uint8_t count3 = 0;
 while((count3 < 16) && (buttonInterruptFlag == 0)){ // ja nav paradits viss efekts un nav noticis partraukums, turpinam
  softSpiTransfer(pgm_read_byte(sequence3data + count3)); // sutam 3 registra datus ("3")
  softSpiTransfer(pgm_read_byte(sequence3data + count3)); // sutam 2 registra datus ("2")
  softSpiTransfer(pgm_read_byte(sequence3data + count3)); // sutam 1 registra datus ("1")
  count3++;
  showSpiData();
  special_delay(100);
 }
}

void showSequence4(){  // paradam ceturto sablonu un atgriezamies atpakal
 uint8_t count4 = 0, count4_1 = 0;
 while((count4 < 150) && (buttonInterruptFlag == 0)){ // ja nav paradits viss efekts un nav noticis partraukums, turpinam
  count4_1 = 0;
  while((count4_1 < 10) && (buttonInterruptFlag == 0)){
   softSpiTransfer(0b11111111);
   softSpiTransfer(0b11111111);
   softSpiTransfer(0b11111111);
   showSpiData();
   special_short_delay(count4);  // speciala pauze, kura tiek partraukta, ja mainiga noticis partraukums
   softSpiTransfer(0b00000000);
   softSpiTransfer(0b00000000);
   softSpiTransfer(0b00000000);
   showSpiData();
   special_short_delay(150-count4);  // speciala pauze, kura tiek partraukta, ja mainiga noticis partraukums
   count4_1++;
  }
  count4++;
 }
 count4 = 0;
 while((count4 < 150) && (buttonInterruptFlag == 0)){ // ja nav paradits viss efekts un nav noticis partraukums, turpinam
  count4_1 = 0;
  while((count4_1 < 10) && (buttonInterruptFlag == 0)){
   softSpiTransfer(0b11111111);
   softSpiTransfer(0b11111111);
   softSpiTransfer(0b11111111);
   showSpiData();
   special_short_delay(150-count4);  // speciala iisa pauze, kura tiek partraukta, ja mainiga noticis partraukums
   softSpiTransfer(0b00000000);
   softSpiTransfer(0b00000000);
   softSpiTransfer(0b00000000);
   showSpiData();
   special_short_delay(count4);  // speciala iisa pauze, kura tiek partraukta, ja mainiga noticis partraukums
   count4_1++;
  }
  count4++;
 }
}

void ioinit(){
 DDRB = 0b11111111;     // PORTB visas izejas
 DDRD = 0b11111011;    // PD2 ieeja (pogai)
 PORTD |= _BV(BUTTON);  // iesledzam "pullup" pogai

//  Ja lietojat Atmega8, tad INT0 partraukumu konfigurejam sadi
 MCUCR = 0;    // partraukums uz INT0 un INT1 kajam pie nulles limena, un mes negulam
 GICR |= _BV(INT0);    // aktivizejam INT0 partraukumu

//  Ja lietojat Atmega48/88/168/328, tad INT0 partraukumu konfigurejam sadi
//  EICRA = 0;    // partraukums uz INT0 un INT1 kajam pie nulles limena
//  EIMSK |= _BV(INT0);    // aktivizejam INT0 partraukumu
 sei();    // iesledzam partraukumus
}

int main(void){
 ioinit();     // sagatavojam mikroprocesoru
 while(1){     // izpildit vienmer (bezgaliga cilpa)
  buttonInterruptFlag = 0;  // atzimejam, ka esam jau 'izlekusi' ara noefekta, lai tagad tur paliktu
  switch(flag){
   case 0: showSequence1(); break;
   case 1: showSequence2(); break;
   case 2: showSequence3(); break;
   case 3: showSequence4(); break;
   default: break;
  }
 }
 return 0;
}
.
Paskatamies video, kā izskatās šie 24 gaismas diožu piemēri dzīvē:



Piemērs1 – ATMEGA8, 3x74HC595, 24xLED


Piemērs2 – ATMEGA8, 3x74HC595, 24xLED




Piemērs3 – ATMEGA8, 3x74HC595, 24xLED






.
Un šeit lejupielādei pieejami visu piemēru kodi un *.hex datnes mikro kontrolieriem ATMEGA8/8A un ATMEGA328: PIEMĒRI. Bet te pieejama SHĒMA atsevišķi.

.

Edgars — Fri, 17 Feb 2012 09:20:30 +0000

Janvāra labākā raksta autors ir ibot ar rakstu Quadropod, jeb četrkājainais robots, balvā saņemot dāvanu karti 20 Ls vērtībā no SIA Argus Radiodetaļu Tirdzniecība.

Arī Februāra labākā raksta autors savā īpašumā iegūs dāvanu karti 20 Ls vērtībā.

Atceramies, ka tikai Jūsu balsojums noteiks laimētāju!

Pamācība raksta veidošanā atrodama šeit, un informācija par balsošanu – šeit.

Un vēl joprojām rakstu autoriem tiek piešķirta 15% atlaide vienam pirkumam no argus.lv

Informācija par balvu un atlaižu saņemšanu tiek sūtīta uz jūsu e-pastu, kas norādīts Jūsu transformators.lv profilā. Ja gadījumā kāds šo informāciju nav saņēmis – dodiet ziņu.

DIY Tranzistoru/Integrēto shēmu zemfrekvences jaudas pastiprinātāja būve : vispārīgi norādījumi.

Quadropod, jeb četrkājainais robots

ibot — Wed, 25 Jan 2012 10:31:02 +0000

Vēlējos pastāstīt par diezgan sen sākto projektu: uz četrām kājām staigājošo robotiņu. Protams šādam mošķim reālā dzīvē ir ļoti maz (gandrīz vispār nav) praktiska pielietojuma, tāpēc var teikt, ka šis robots ir domāts kā izklaides projekts. Robota izveide aizņēma vairāk laika, nekā bija plānots un turpinās jaunu ideju realizācija šajā robotā, jaunu programmu ieviešana, utt.

Galvenā sākuma doma bija radīt staigājošu robotu, kas varētu pārvietoties uz 4 kājām izmantojot tiešo kinemātisko uzdevumu (forward kinematics, sīkāk skatīt http://en.wikipedia.org/wiki/Forward_kinematics), jeb pārvietoties ,kustinot un pārvietojot servo iepriekš definētos stāvokļos, ko varētu izrēķināt ar elementāras ģeometrijas palīdzību un piekoriģēt uz aci. Robotiņam ir pielikti dažādi sensori (infrasarkanais SHARP attāluma mērītājs, fototranzistori, galaslēdži, trokšņa līmeņa indikators) lai tas spētu autonomi pārvietoties pa telpu un ,piemēram, apiet šķēršļus, un platīte attālinātai vadībai cauri infrasarkano TV pulti (ar RC5 un SIRC protokoliem).Kādreiz arī fantazēju par iespēju pamēģināt realizēt gaitu ar inverso kinemātiku (inverse kinematics), izmantojot PC, taču sapratu, ka līdz tam vēl tālu J . Robota mehānika un elektriskās shēmas ir pabeigtas un samontētas, priekšā palika pats laikietilpīgākais un interesantākais posms – programmēšana. Līdz šim esmu realizējis ļoti elementāru pārvietošanās kodiņu, bet laika trūkuma dēļ programmēšana ir ievilkusies.

Tehniskais apraksts: Mehānika

Patreiz neesmu sastādījis sīku tehnisko aprakstu un shēmas/ rasējumus, taču ir doma to darīt pēc programmēšanas darbu beigšanas (ja publikai būs interese). Tātat robotam ir 4 kājas ar 3 brīvības pakāpēm (degree of freedom) un kopā robotā ir izmantoti 13 servo , jeb 12 servo priekš kājām un 1 priekš SHARP infrasarkanā sensora. Servo motori tika pasūtīti no šīs mājaslapas: http://www.mindsetsonline.co.uk/index.php?cPath=13_530 , kurā starp citu ir daudz dažādu, interesantu sīkumu.

Dynam firmas servo motors ar parametriem:

Weight: 34g
Torque: 56.9 oz-in (at 6V) (aptuveni 4.8 kg/cm ja nemaldos)
Speed: 0.16 sec/60 degrees (at 6V)
Size: 55 x 20 x 45mm

Par šiem servo neko sliktu nevaru teikt, tiem ir labs griezes moments un pieņemama cena, vienīgais gabarītos šie ir par pārs milimetriem lielāki, nekā tie, kurus lietoju līdz šim.

Attēlā augstāk var redzēt mana robota karkasu, kas ir diezgan masīvs salīdzinot ar tirgū pieejamajiem robotiem Phantom X. Kā redzams, es speciāli uztaisīju īsākus posmus kājām( spēka plecus), vai nezaudētu dārgo spēka momentu no motoriem, jo korpusu taisīju no PLEXIGLASS plāksnes un alumīnija . Kā arī tas palīdzēja samazināt strāvu, ko patērē servo.

*Phantom X quadropod robots

Visa šasija robotam tika izgriezta ar rokas instrumentu palidzību. Pašam man ir pieeja pie CNC darbagaldiem un CAD programmatūru arī pārzinu un lietoju, taču būvējot robotu idejas nāk galvā uz vietas un visa mehānika ir improvizēta, taču darbojas viss labi. Masa robotam bez baterijām sanāca liela, aptuveni 1,1 kg, bet pateicoties īsajiem spēka pleciem motori tiek galā ar šo smagumu. Šī mošķa barošanai pagaidām lietoju 2 atsevišķus akumulatoru blokus – logikas barošanai un motoriem. Iepriekš centos iztikt ar vienu bloku, taču vidējā strāva kas plūst caur servo parasti ir ap 1,1 A (daudz gan) un ar pīķiem līdz 1.6 A pie slodzēm( ja piemēram uzspiež uz robota), kas nomet spriegumu tik zemu, ka elektronika izslēdzas ārā.

Tehniskais apraksts: Elektronika

Kā smadzenes robotrā kalpo Arduino Duemilonove mikrokontroliera platforma.

Kaut gan ir nācies darboties arī tīri ar Atmegām, man iepatikās Arduino vidē pieejamās bibliotēkas, kā arī manā skapī tāpat mētājās lieka platīte, ko iepriekš lietoju tikai izmēģinājumiem. Galvenais ir arī tas , ka “servo.h” bibliotēka ļauj reāli pie visām digitālajiem piniem pieslēgt servo. Interesanti ir tas, ka bibliotēka it kā oficiāli ļauj līdz 12 servo pieslēgšanu, taču es biju definējis joka pēc 14 servo (visus digitalos pinus lietoju priekš servo). Tad nu 13 servo motori tika pieslēgti pie arduino digitālajām kājiņām. Secību var apskatīt zemāk:

Klāt pie Arduino tika pieslēgts arī infrasarkanās vadības relejs, ko var slēgt iekšā/ ārā ar TV pultīm, kuras lieto RC5 un SIRC protokolus. Šāds 8 kanālu programmējamais relejs ir pieejams Argusā http://web.argus.lv/shop/productinfo/AVT390B%2B/hwindex.htm un cenas ziņā ir ļoti labs.

Līdz šim es biju domājis izveidot šim robotam 3 vadības režīmus, kuros robots lietoju tikai daļu savu funkciju:

1. vadības režīms – autonomais šķēršļu pārvarētājs. Šādā režīmā robots lietotu tikai SHARP attāluma sensoru, un galaslēdžus kāju galos, vai varētu mēģināt šķērsot istabu taisni, ja tam priekšā būtu dažāda augstuma šķēršļi.

2. rotaļu dzīvnieciņa simulācija – bija doma robotu padarīt interaktīvu un izmantojot trokšņu līmeņa indikatoru un fototranzistorus, lai to varētu piemēram pastaigas vidū “nobiedēt”ar plaukšķi un tas mestos meklēt tumšāko stūri.

3. tālvadības režīms – vadīt ar pults palīdzību robotu, kurš sekotu uzdotajām komandām.

Attāluma sensors ir šāds http://web.argus.lv/shop/productinfo/GP2D120/hwindex.htm

Un to pieslēdzu pie analogās ieejas.

Interesantāks ir manis paša veidots trokšņu līmeņa indikators, kas sastāv no elektret mikrofona pastiprinātāja, kas apvienots ar komparatoru un komporatora izeja pieslēgta pie kondensatora, kas savukārt paralēli pieslēgts analogajai kājai. Tas tika darīta ar mērķī, lai varētu noķert laikā īso signālu no komparatora. Varbūt kādam tas šķitīts diezgan murgains risinājums, bet tas ir tāpēc, ka man bija doma ielikts RS trigeri pēc komparatora, taču, nejauši to sabeigdams es izvēlējos primītīvāku risinājumu – kondensatoru, kas neļauj spriegumam uzreiz pazust. Zemāk ir redzamas ne pārāk kvalitatīvi attēlota shēma:

Tehniskais apraksts: Programma

Šajā sadaļā es neko vērtīgu nevaru vēl ievietot, taču pacentīšos to drīz labot.Vienīgais varu Jūsu uzmanībai piedāvāt video (sliktas kvalitātes) ar gaitas izmēģinājumu:

Ja kādam interesē šis ir kods elementārakajai gaitai.

#include 

Servo myservo0; Servo myservo1; Servo myservo2; Servo myservo3; Servo myservo4; Servo myservo5;// create servo object to control a servo

Servo myservo6; Servo myservo7; Servo myservo8; Servo myservo9; Servo myservo10; Servo myservo11;

int lenkis1 = 55;

int lenkis2 = 135;

int lenkis3 = 50;

int lenkis4 = 130;

int lenkis5 = 22;

int lenkis6 = 158;

int lenkis7 = 60;

int lenkis8 = 140;

int lenkis71= 61; //korekcijas lenkis 7

int lenkis9 = 50;

int lenkis10 = 130;

void setup()

{

myservo0.attach(0);

myservo1.attach(1);

myservo2.attach(2);

myservo3.attach(3);

myservo4.attach(4);

myservo5.attach(5);

myservo6.attach(6);

myservo7.attach(7);

myservo8.attach(8);

myservo9.attach(9);

myservo10.attach(10);

myservo11.attach(11);

myservo0.write(lenkis1);  // nostadam robota kajas izejas pozicija

myservo1.write(lenkis2);

myservo2.write(lenkis1);

myservo3.write(lenkis2);

delay (1000); // pacelam robotu

myservo8.write(lenkis3);

myservo9.write(lenkis4);

myservo10.write(lenkis4);

myservo11.write(lenkis3);

delay (400);

myservo4.write(lenkis3);

myservo5.write(lenkis4);

myservo6.write(lenkis4);

myservo7.write(lenkis3);

delay (3000);

}

void loop() // trot gaita

{

myservo7.write(lenkis5);     // pacelt 4 kaju

myservo11.write(lenkis5);

myservo5.write(lenkis6);     // pacelt 2 kaju

myservo9.write(lenkis6);

delay (80);

myservo0.write(lenkis9);  // pagriezt  nolaisto 1 kaju

myservo2.write(lenkis71);  // pagriezt  nolaisto 3 kaju

myservo3.write(lenkis8);  // pagriezt pacelto 4 kaju

myservo1.write(lenkis10);  // pagriezt pacelto 2 kaju

delay (100);

myservo5.write(lenkis4); // nolaist 2 kaju

myservo9.write(lenkis4);

myservo7.write(lenkis3);    // nolaist 4 kaju

myservo11.write(lenkis3);

delay (180);

myservo6.write(lenkis6);   // pacelt 3 kaju

myservo10.write(lenkis6);

myservo4.write(lenkis5); // pacelt  1 kaju

myservo8.write(lenkis5);

delay (80);

myservo1.write(lenkis8);  // pagriezt  nolaisto 2 kaju

myservo3.write(lenkis10);  // pagriezt  nolaisto 4 kaju

myservo2.write(lenkis9);  // pagriezt pacelto 3 kaju

myservo0.write(lenkis7);  // pagriezt pacelto 1 kaju

delay (100);

myservo4.write(lenkis3); // nolaist 1 kaju

myservo8.write(lenkis3);

myservo6.write(lenkis4);    // nolaist 3 kaju

myservo10.write(lenkis4);

delay (180);

}

Li-Ion akumulatoru “gudrs” lādētājs ar MCP73843

KasparsL — Wed, 25 Jan 2012 10:19:28 +0000

Es ļoti bieži savos projektos izmantoju Litija jonu akumulatorus (Li-Ion), kuru, ilga mūža saglabāšanai, lādēšanai jāizmanto “gudrs” lādētājs. Tam jābūt constantas strāvas un konstanta sprieguma, un ar lādēšanas pārtraukšanu cikla beigās.
Šiem kritērijiem atbilst arī rūpnieciski Li-Ion lādētāji, bet bieži vien tie maksā dārgi, vai lādēšanas strāva ir pārāk zema (1Amp, 500mA, 350mA, un mazāk).
Li-Ion akumulatoriem, maksimālā lādēšanas strāva ir 1C – tas nozīmē, cik ietilpīgs akumulātors, tik ātri var to lādēt (piem: 2400mAh akumulātoru var lādēt ar, maksimums, 2.4 Amp lielu strāvu). Pie 1C lādēšanas uzlādes laiks ir ~ 2 stundas (parasti mazāk).

Tad nolēmu uzbūvēt 2 Ampēru lādētāju priekš 4.2V Li-Ion akumulātoriem un pakām. Es izvēlējos Microchip lādēšanas kontrolieri – MCP73843 . Lādētāja barošanai nepieciešams 5V barošanas avots.

MCP73843 lādētāja shēma:

MCP73843 uzlādes kontrolierim in nepieciešams ārējs lauku tranzistors (T1), manā gadījumā 2 ampēru uzlādes strāvai pietiek ar IRF7416 (smd SO8 korpusā). Uzlādes strāvu nosaka R4 rezistors (0.05R = 2A, 0.1R = 1A, 0.025R = 4A). D1 ir aizsardzības shotkija diode, tai ir jāiztur ilglaicīgi izvēlētā uzlādes strāva. Rezistoru dalītājs R1/R2 nosaka ieslēgšanās spriegumu, praktiski var R2 nelikt, jo pats kontrolieris ir pietiekami gudrs, lai pārtrauktu lādēšanas ciklu, ja ieejas spriegums ir mazāks par izejas spriegumu. C3 nosaka drošības taimera laikus (skatīt kontroliera datasheet).
Kontrolierim ir statusa indikācijas izvads, kur pieslēdzot gaismas diodi, var redzēt, vai notiek uzlāde, vai bijusi uzlādes kļūda, piem taimera laiks beidzies.

Šeit varam aplūkot uzlādes grafiku.

Tad uzzīmēju platīti. Lejuplādēt var šeit . Tā kā mikroshēma MCP73843 ir pieejama tikai MSOP-8 korpusā, iesaku plati veidot ar foto metodi. Viena lādētāja platītes izmērs ir 50mm x 19mm.

Pēc kodināšanas:

Lādētājs salodēts, noalvoju celiņu no T1 uz izeju labākai siltuma vadītspējai. Gaismas diode ir RGB, no kuras izmantotas tikai sarkanā un zaļā.

Visvairāk silstošās detaļas ir tranzistors T1 un diode D1. Lai T1 nepārkarstu, izveidoju garāku plati, kur celiņš izmantots kā radiators.

Visas detaļas salodētas (5 lādētāji)

Gatavs un “iepakots”

Zaļš – ja ieslēgts vai lādēšana pabeigta, oranžs – lādējas, zaļš/oranžs mirgo – kļūda (piem. taimera laiks iztecējis)

Šeit starp tukšu akumulatoru paku un lādētāju pieslēgts analizators, kurā redzams pašreizējais pakas spriegums, uzlādes strāva u.c.

Teorētiski, izmainot R4 pretestību un attiecīgi D1 un T1, var izveidot jebkādu vēlamo uzlādes strāvu. (strāvām, kas lielākas par 2 ampēriem, visticamāk, ka būs nepieciešams D1 un T1 izvietot uz neliela radiatora)

Ja gribēsiet izveidot tādu pašu lādētāju, vai pasmelties idejas šeit var lejupielādēt EagleCad datnes.

Edgars — Thu, 19 Jan 2012 08:14:22 +0000

Sveiciens Jaunajā gadā!

Pagājušā gada decembra labākā raksta autors ir TomToms ar rakstu Barošanas bloks 13.8V 2.5A / 12V 1.5A, balvā saņemot dāvanu karti 20 Ls vērtībā no SIA Argus Radiodetaļu Tirdzniecība.

Novēlam šogad vēl sparīgāk dalīties ar idejām/pamācībām. Un kā vienmēr – labākajiem dāvanas no SIA Argus Radiodetaļu Tirdzniecība. Arī šoreiz, dāvanu karte 20 Ls vērtībā.

Atceramies, ka tikai Jūsu balsojums noteiks laimētāju!

Pamācība raksta veidošanā atrodama šeit, un informācija par balsošanu – šeit.

Un vēl joprojām rakstu autoriem tiek piešķirta 15% atlaide vienam pirkumam no argus.lv

Informācija par balvu un atlaižu saņemšanu tiek sūtīta uz jūsu e-pastu, kas norādīts Jūsu transformators.lv profilā. Ja gadījumā kāds šo informāciju nav saņēmis – dodiet ziņu.

Piemērs1 – ATMEGA8, 3x74HC595, 24xLED	Piemērs2 – ATMEGA8, 3x74HC595, 24xLED
Piemērs3 – ATMEGA8, 3x74HC595, 24xLED