Programozható elektronikák - Melléklet

v: 2014-07-22

Szándékosan üresen hagyot oldal

Szándékosan üresen hagyot oldal

Tartalom

0. Dokumentum információk............................6Licenc............................................................................................ 6

Bit és byte műveletek...........................................8Adot bit 1-es értékre állítása...................................................8

Adot bit 0-s értékre állítása.....................................................8

Adot bit értékének invertálása................................................8

Adot bit értékének kiolvasása..................................................8

2 byte-os egész szám felbontása 2db egy byte-os karakterre

....................................................................................................... 8

2db egy byte-os karakterből egy 2 byte-os egész

létrehozása...................................................................................8

8 bites egész szám felső 4 bitjének kinyerése.........................8

8 bites egész szám alsó 4 bitjének kinyerése..........................9

8 bites bináris szám BCD kódolása.........................................9

8 bites BCD kódolt szám binárissá alakítása.........................9

Kódszó paritásának meghatározása........................................9

Matematikai függvények..................................10Kető adot hatványának előállítása gyorsan......................10

Tömb legkisebb elemének kikeresése....................................10

Tömb legnagyobb elemének kikeresése................................10

Tömb átlagának kiszámítása..................................................10

Adot halmaz értékének a leképezése egy másik halmazban

..................................................................................................... 11

16 bites hash kód meghatározása egy byte sorozathoz.....11

Tömbökkel kapcsolatos függvények.............12Tömb összes elemének beállítása adot kezdőértékre........12

Tömb tartalmának másolása másik tömbbe........................12

Rendezési algoritmusok....................................13Egyszerű cserés rendezés.........................................................13

Minimumkiválasztásos rendezés............................................13

Buborék rendezés......................................................................14

Kétirányú buborék rendezés...................................................14

Shell rendezés............................................................................15

Gyorsrendezés...........................................................................15

Forrasztani egyszerű..........................................17

Programozható elektronikák melléklet 4. oldal

0. Dokumentum információk

Licenc

Nevezd meg! – Ne add el! – Így add tovább! 4.0

Nemzetközi

Ruszinszki Gábor Programozható Elektronikák melléklet című műve Creative Commons Nevezd

meg! - Így add tovább! 4.0 Nemzetközi Licenc alat van. A licenc teljes szövege a

htp://creativecommons.org/licenses/by-nc-sa/4.0/legalcode címen érhető el.

Emberek által is érthető formában a licenc szerződés fontosabb feltételei :

Nevezd meg!

A mű felhasználása, átdolgozása esetén meg kell

jelölnöd az eredeti szerzőt és a művet.

Így add tovább!

A származékos műveket az eredetivel megegyező

féltelek mellet adhatod tovább.


http://webmaster442.hu/

http://creativecommons.org/licenses/by-nc-sa/4.0/legalcode

http://creativecommons.org/licenses/by-nc-sa/4.0/

http://creativecommons.org/licenses/by-nc-sa/4.0/

A könyvben szereplő kódrészletekre a BSD Public Licence vonatkozik:

Copyright (c) 2013, Ruzsinszki Gábor

Minden jog fenntartva.

Engedélyezet a forráskód és bináris formában történő felhasználás és terjesztés, módosítással vagy

anélkül, amennyiben a következő feltételek teljesülnek:

• A forráskód terjesztésekor meg kell őrizni a fenti szerzői jogi megjegyzést, ezt a feltétellistát és a

következő nyilatkozatot.

• Bináris formában történő terjesztéskor tovább kell adni a fenti szerzői jogi megjegyzést, ezt a

feltétellistát és a következő nyilatkozatot a dokumentációban, illetve a csomaggal részét képező

egyéb anyagokban.

• Sem Ruzsinszki Gábor neve, sem pedig a hozzájárulók neve nem használható fel előzetes írásbeli

engedély nélkül a szofverből származtatot termékek hitelesítésére vagy reklámozására.

EZT A SZOFTVERT A SZERZŐI JOG TULAJDONOSAI ÉS A HOZZÁJÁRULÓK ÚGY BIZTOSÍTJÁK,

„AHOGY VAN”, ÉS SEMMILYEN NYÍLT VAGY BURKOLT GARANCIA – BELEÉRTVE, DE NEM ERRE

KORLÁTOZVA AZ ELADHATÓSÁGOT VAGY EGY ADOTT CÉLRA VALÓ ALKALMATOSSÁGOT – NEM

ÉRVÉNYESÍTHETŐ. A SZERZŐI JOG TULAJDONOSAI ÉS A HOZZÁJÁRULÓK SEMMILYEN ESETBEN

SEM VONHATÓK FELELŐSSÉGRE A SZOFTVER HASZNÁLATÁBÓL EREDŐ SEMMILYEN

KÖZVETLEN, KÖZVETETT, VÉLETLENSZERŰ, KÜLÖNLEGES, PÉLDAADÓ VAGY SZÜKSÉGSZERŰ

KÁROKÉRT (BELEÉRTVE, DE NEM ERRE KORLÁTOZVA A HELYETTESÍTŐ TERMÉKEK VAGY

SZOLGÁLTATÁSOK BESZERZÉSÉT, ÜZEMKIESÉST, ADATVESZTÉST, ELMARADT HASZNOT VAGY

ÜZLETMENET MEGSZAKADÁSÁT), BÁRHOGY IS KÖVETKEZETT BE, VALAMINT A FELELŐSSÉG

BÁRMILYEN ELMÉLETÉVEL – AKÁR SZERZŐDÉSBEN, AKÁR OKOZOTT KÁRBAN (BELEÉRTVE A

HANYAGSÁGOT ÉS EGYEBET), AKKOR IS, HA AZ ILYEN KÁR LEHETŐSÉGÉRE FELHÍVTÁK A

FIGYELMET.


http://hu.wikipedia.org/wiki/Kettes_sz%C3%A1mrendszer

http://hu.wikipedia.org/wiki/Forr%C3%A1sk%C3%B3d_(programoz%C3%A1s)

Bit és byte műveletek

Az alábbi példákban a szám változó egy egész szám típus, míg a bit a műveletre kijelölt bit

sorszáma. A kód értékelhetetlen eredményt fog eredményezni, ha a műveletre kijelölt bit értéke nagyobb,

mint N-1, ahol N a típus bitjeinek számát jelöli.

Adott bit 1-es értékre állítása

szam |= 1 << bit;

Adott bit 0-s értékre állítása

szam &= ~(1 << bit);

Adott bit értékének invertálása

szam ^= 1 << bit;

Adott bit értékének kiolvasása

bitertek = szam & (1 << bit);

2 byte-os egész szám felbontása 2db egy byte-os karakterre

void bont(int szam){

char also = szam & 0x00FF;char felso = (szam & 0xFF00) >> 8;

}

2db egy byte-os karakterből egy 2 byte-os egész létrehozása

int osszerak(char also, char felso){

int eredmeny = also;eredmeny += (felso << 8);return eredmeny;

}

8 bites egész szám felső 4 bitjének kinyerése

inline char Higher(char value){

return (value & 0xF0) >> 4;}


8 bites egész szám alsó 4 bitjének kinyerése

inline char Lower(char value){

return value & 0x0F;}

8 bites bináris szám BCD kódolása

char BCDEncode(char binary){

if (binary > 99) binary = 99;if (binary < 0) binary = 0;char target = (binary % 10) << 4;return target += (binary / 10);

}

8 bites BCD kódolt szám binárissá alakítása

char BCDDecode(char bcd){

char ret = (bcd & 0xF0) >> 4;return (ret * 10) + (bcd & 0x0F);

}

Kódszó paritásának meghatározása

unsigned short int getParity(unsigned int n){

unsigned short int parity = 0;while (n){

parity = !parity;n = n & (n – 1);

}return parity;

}


Matematikai függvények

Kettő adott hatványának előállítása gyorsan

inline int KettoHatvanya(int kitevo){

return 1 << kitevo;}

Tömb legkisebb elemének kikeresése

int TombMinimum(int tomb[], int elemszam){

int Minimum = tomb[0];for (int i=0; i<elemszam; i++){

if (tomb[i] < Minimum) Minimum = tomb[i];}return Minimum;

}

Tömb legnagyobb elemének kikeresése

int TombMaximum(int tomb[], int elemszam){

int Maximum = tomb[0];for (int i=0; i<elemszam; i++){

if (tomb[i] < Maximum) Maximum = tomb[i];}return Maximum;

}

Tömb átlagának kiszámítása

int TombAtlag(int tomb[], int elemszam){

long int osszeg = 0;for (int i=0; i<elemszam; i++){

osszeg += tomb[i];}return osszeg / elemszam;

}


Adott halmaz értékének a leképezése egy másik halmazban

long Map(long Value, long InMinimum, long InMaximum, long → OutMinimum, long OutMaximum){

return (Value - InMinimum) * (OutMaximum - OutMinimum) / → (InMaximum - InMinimum) + OutMinimum;}

16 bites hash kód meghatározása egy byte sorozathoz

//eredeti forrása: http://www8.cs.umu.se/~isak/snippets/crc-16.c

#define POLY 0x8408

unsigned short crc16(char *data_p, unsigned short length){

unsigned char i;unsigned int data;unsigned int crc = 0xffff;

if (length == 0) return (~crc);do{

for (i=0, data=(unsigned int)0xff & *data_p++;i < 8; →i++, data >>= 1)

{if ((crc & 0x0001) ^ (data & 0x0001))

crc = (crc >> 1) ^ POLY;else crc >>= 1;

}} while (--length);crc = ~crc;data = crc;return crc;

}


http://www8.cs.umu.se/~isak/snippets/crc-16.c

Tömbökkel kapcsolatos függvények

Tömb összes elemének beállítása adott kezdőértékre

#include <string.h>

int tomb[20]; //tömb amit nullázunk

//a második paraméter az érték amit a tömbbe írunk//a tömbb típusával megegyező típus lehet.memset(tomb, 0, sizeof(tomb));

Tömb tartalmának másolása másik tömbbe

#include <string.h>

int forras[] = {0, 3, 5, 2, -1}; //ezt másoljukint cel[5]; //ebbe másolunk

memmove(cel, forras, sizeof(forras));


Rendezési algoritmusok

Egyszerű cserés rendezés

void CsereRendez(int tomb[], int elemszam){

for (int i = 0; i<elemszam - 1; i++ ){

for (int j = i + 1; j<elemszam; j++){

if (tomb[i] > tomb[j]){

int tmp = tomb[i];tomb[i] = tomb[j];tomb[j] = tmp;

}}

}}

Minimumkiválasztásos rendezés

void RendezMinimum(int tomb[], int elemszam){

for (int i = 0; i<elemszam - 1; i++){

int min = i;for (int j = i+1; j<elemszam; j++){

if (tomb[j] < tomb[min]) min = j;}if( i != min){

int tmp = tomb[i];tomb[i] = tomb[min];tomb[min] = tmp;

}}

}


Buborék rendezés

void RendezBuborek(int tomb[], int elemszam){

for (int i = elemszam; --i>=0; ){

int cserelt = 0;for (int j = 0; j<i; j++){

if (tomb[j] > tomb[j+1]){

int tmp = tomb[j];tomb[j] = tomb[j+1];tomb[j+1] = tmp;cserelt = 1;

}}if (!cserelt) return;

}}

Kétirányú buborék rendezés

void RendezKetiranyuBuborek(int tomb[], int elemszam){

int j;int limit = elemszam;int st = -1;while (st < limit){

st++;limit--;int cserelt = 0;for (j = st; j < limit; j++){

if (tomb[j] > tomb[j + 1]){

int tmp = tomb[j];tomb[j] = tomb[j + 1];tomb[j + 1] = tmp;cserelt = 1;

}}if (!cserelt) return;else cserelt = 0;for (j = limit; --j >= st;){

if (tomb[j] > tomb[j + 1]){

int tmp = tomb[j];tomb[j] = tomb[j + 1];tomb[j + 1] = tmp;


cserelt = 1;}

}if (!cserelt) return;

}}

Shell rendezés

void RendezShell(int tomb[], int elemszam){

int h[] = {1,4,13,40,121}; /** TAOCP 3. */int s,lep,x,i,j;

for (s = 4; s >=0; s--){

lep = h[s];for(j = lep; j < elemszam; j++){

i = j - lep;x = tomb[j];while(i >=0 && tomb[i]>x ){

tomb[i+lep] = tomb[i];i = i - lep;

}tomb[i+lep] = x;

}}

}

Gyorsrendezés

void Gyors(int T[], int lo0, int hi0){

int lo = lo0;int hi = hi0;int mid;

if ( hi0 > lo0){

mid = T[ ( lo0 + hi0 ) / 2 ];while( lo <= hi ){

while( ( lo < hi0 ) && ( T[lo] < mid )) ++lo;while( ( hi > lo0 ) && ( T[hi] > mid )) --hi;if( lo <= hi ){

int tmp= T[lo]; T[lo] = T[hi]; T[hi] = tmp;++lo;


--hi;}

}if( lo0 < hi ) QuickSort( T, lo0, hi );if( lo < hi0 ) QuickSort( T, lo, hi0 );

}}

void RendezGyors(int tomb[], int elemszam){

QuickSort(tomb, 0, elemszam - 1);}


Forrasztani egyszerű









Programozható elektronikák - Melléklet

Documents