Primerament hem de carregar les capçalera per a poder emprar les funcions md5 d'openssl:

#include <openssl/md5.h>

Amb això podem cridar a les funcions MD5_Init, MD5_Update i MD5_Final. Com indica el nom MD5_Init serveix per iniciar el procés de conversió, inicialitzant una variable del tipus MD5_CTX. Per a l'exemple l'anomenarem state:

MD5_CTX state;

MD5_Update requereix 3 paràmetres. Primerament la nostra variable state, per a seguir i actualitzar el context de les dades de les que crear-ne el MD5. Segon li hem de passar una dada de tipus unsigned char, en el nostre cas anomenada buffer. Aquesta variable el que conté són les dades de les que volem que faci el MD5. Com que el buffer és una estructura dinàmica, el tercer paràmetre és un enter indicant el nombre de caràcters que ha de llegir.

unsigned char *buffer;
int comptador;

Cal tenir en compte que MD5_Update es pot cridar tantes vegades com faci falta fins a carregar totes les dades dessitjades.

Per acabar emprem la funció MD5_Final, que de primer paràmetre ens demana una cadena unsigned char, de 16 bytes, que serà el que es coneix com a digest (la variable l'anomenarem així), que és el MD5 en format binari. Com a darrer paràmetre l'hi passem la variable state, que conté el context del que s'ha de generar el MD5.

unsigned char *digest;

Tot aquest procés ens dona el digest, que és un valor binari. Però el problema és que podem voler tractar el md5 de forma visual, en format de cadena, llegible per a una persona. Per fer això ens podem fer una petita funció a mà.

char *digestAMD5(unsigned char *digest)
{
  static const char HEX_DIGITS[] = "0123456789abcdef";
  char *md5;
  int n;
 
  md5=malloc(sizeof(char)*33);
  for (n = 0; n < 16; n++)
  {
    md5[2*n]   = HEX_DIGITS[(digest[n] >> 4) & 0x0f];
    md5[2*n+1] = HEX_DIGITS[digest[n] & 0xf];
  }
  md5[32] = 0;
 
  return (char *) md5;
}

Aquesta funció ens generaria un MD5 legible per a una persona. Un exemple per veure-ho funcionant tot junt:

#include <openssl/md5.h>
int main()
{
  unsigned char *buffer, *digest;
  int comptador;
  char *md5;
  MD5_CTX state;
 
  //Demanem memòria per a les nostres cadenes
  digest=malloc(sizeof(char)*16);
  md5=malloc(sizeof(char)*33); //El md5 és de 32 caràcters, en posem un més per poder-hi afegir el byte de fi de cadena.
 
  //Carreguem el buffer del lloc que necessitem
  //Això ja depen d'on extrequi cadascú la informació de la que vol fer-ne el md5
 
  //Inicialitzem el entorn
  MD5_Init(&state);
 
  //Afegim les dades del buffer. Es pot anar cridant aquesta funció les vegades que faci falta
  MD5_Update(&state, buffer, comptador);
 
  //Genera el digest de les dades enviades. Recordem que no poden ser visualitzades per una persona
  MD5_Final(digest, &state);
 
  //Generem una cadena amb el MD5, ara sí, en format llegible per a una persona
  md5=digestAMD5(digest);
 
  //Afegir caràcter de fi de cadena per a que el printf ens mostri correctament la nostra cadena
  md5[32]='\0';
  printf("El MD5 val: %s", md5);
  return 0;
}

Sembla i és una tonteria, però m'hi he trencat les banyes un parell de dies per a poder-ho fer servir...

Així que m'he posat a remenar per a trobar com dir-li que em completés el codi automàticament. Per fer-ho he anat al menú Projecte->Opcions de Projecte. Allí he anat al Suport de C++ i he marcat la casella Automatic code completion a la pestanya Code completion. Això activa la autocompletació de codi, però encara no en té idea de les llibreries de qt. Per a afegir el suport per a les QT a la mateixa pestanya busquem el quadre Base de dades per al completat de codi i premem el botó afegeix.

En el meu cas he triat Importador de PCS de Qt4 per a KDevelop i llavors he especificat la ruta a les meves llibreries de qt4 ( /usr/include/qt4 , en el meu cas). Ha estat una estona fent la base de dades i ja he tingut la autocompletació de codi activada!!

El problema és que està a ~x86, però és fàcil de solucionar.

Primer és fer que ens deixi compilar aquesta versió. Obrim l'arxiu /etc/portage/package.keywords i afegim el següent:

dev-util/codeblocks

I ara ja podem compilar el code:blocs amb:

emerge codeblocs

També ens farà falta el sdcc:

emerge sdcc

Ara que ja tenim tot el necessari, obrim el code:blocs, no patiu si us diu que no detecta el compilador sdcc, ja ho arreglarem.

Li donem a crear projecte i triem "Empty Project". Triem quin nom li volem donar al projecte i on el volem guardar. Al següent pas hem de triar quin compilador volem emprar, en aquest cas sdcc. Quan creem el projecte es queixarà de que no sap els flags d'optimització del compilador, ni cas.

A anem a "Settings" i triem el submenú "Compiler and Debugger". De la llista triem el sdcc i sel·leccionem la pestanya "Toolchain executables". Veurem que està definida a /usr/local/bin, quan a gentoo s'intal·la a /usr/bin, així que ho canviarem per /usr/bin. A la pestanya "Compiler Settings" buscarem "[CPU] Microchip PIC 14-bit ..." i ho marcarem.

Veurem que a la pestanya "Compiler Settings" hi ha una altre pestanya dintre, "Other options", la marcarem i dintre hi escriurem el xip per al que compilem, per exemple:

-p16f876a

Ja li podrem donar a acceptar. Per a comprovar que tot funciona correctament, creem un arxiu .c al projecte i hi posem el següent:

 
#include
<pic16f876a.h>
 
int main()
{
    return 0;
}
 

I fem un build. Si no dona cap error, ja li podem donar canya a la programació de pics

Tot i així no l'he pogut provar ja que la PIC de proves semblava estar tarada.

El cas és que demanant informació a ARDE sobre el tema dels compiladors existents, sobretot un capaç de suportar codi cpp, em van recomanar fer una ullada a Port de GCC a PIC16 i això vaig fer.Aquí l'autor ha escrit el codi necessari per a que puguem compilar els nostres programes en c per a PICs de la família 16 amb gcc. A la espera de provar algun experiment amb cpp, direm que només suporta c, doncs l'autor m'ha dit que manquen llibreries encara per a que això sigui possible.

Aquí explico el procés que he seguit per a compilar el gcc sense trepitjar-ne la versió que ja en tenia.

Primerament ens descarregarem i instalarem el gputils disponible a la nostra distribució. En gentoo:

emerge gputils

Un cop instal·lat gputils crearem una nova carpeta (suposaré que la carpeta està a Documents). A dintre hi descarregarem la versió de gcc 4.0.2 i la 1.0.0 de csl-pic-gcc i els descomprimirem:

mkdir gccpic
cd gccpic
wget  ftp://ftp.gnu.org/gnu/gcc/gcc-4.0.2/gcc-4.0.2.tar.bz2
wget  https://forja.rediris.es/frs/download.php/324/csl-pic-gcc-16f877-1.0.0.tar.gz
tar xfvj gcc-4.0.2.tar.bz2
tar xfvz csl-pic-gcc-16f877-1.0.0.tar.gz

Ara haurem de configurar el fitxer pic.h per a indicar-li correctament l'ubicació de les eines de gputils (si compilem el paquet 'oficial' en comptes del de la nostra distribució, aquest pas no fa falta).

vim gcc-4.0.2/gcc/config/pic/pic.h

On canviarem les línies

#define DEFAULT_ASSEMBLER "/usr/local/bin/gpasm"
#define DEFAULT_LINKER "/usr/local/bin/gplink"

per

#define DEFAULT_ASSEMBLER "/usr/bin/gpasm"
#define DEFAULT_LINKER "/usr/bin/gplink"

Ara crearem la carpeta on anirà la nostra versió de gcc:

mkdir pic-gcc
cd pic-gcc

I executarem el configure i en compilarem el codi:

../gcc-4.0.2/configure -target=pic -enable-languages=c,c++
make

Ja tenim els binaris creats a la carpeta gcc, però ara volem que sigui més fàcil emprar-los, per això farem un parell d'enllaços simbòlics, com a root s'ha de fer (poso el meu directori de home com a exemple, s'ha de canviar a la ruta correcte al vostre sistema):

su
(introduim la clau)
cd /usr/bin
ln -s  /home/mad93/Documents/gccpic/pic-gcc/gcc/g++ picg++
ln -s /home/mad93/Documents/gccpic/pic-gcc/gcc/xgcc picgcc

I ja podrem compilar els nostres programes amb picgcc i picg++. Vull recordar que cpp encara no es pot emprar per certa mancança de llibreries, però ho deixo aquí així esperant que en un futur pròxim ja sigui possible.

Així doncs he decidit revisar el codi d'un joc força senzill que vaig fer per la gp2x i fer el que s'anomenaria una demo, un programa que no fa res de res ><

En aquest programa només es carrega una imatge i una cançó i es surt amb la tecla "return". Per limitacions de coneixements i per no complicar molt la cosa, la resolució és fixa a 1024x768 (SDL_Image no té una funció per reescalar les imatges o.O).

El programa intenta explicar-se per si mateix, però bé, com que són comentaris per a mi, no sé si explica prou bé que es fa a cada pas, aquí el codi:

#include <stdio.h>
#include <stdlib.h>
 
#include <SDL.h>
#include <SDL_mixer.h>
#include <SDL_image.h>
#include <time.h>
 
int main(int argc, char *argv[])
{
//Definim la variable pantalla
SDL_Surface *pantalla;
int sortir=0;
//Inicialitzem el SDL
if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) &lt; 0)
{
//Entro si peta al inicialitzar el SDL
fprintf(stderr, "Incapaç d'inicialitzar SDL: %s\n", SDL_GetError());
exit(1);
}
//Fixem la mida de la pantalla
pantalla= SDL_SetVideoMode(1024,768,16,SDL_DOUBLEBUF | SDL_FULLSCREEN);
if (!pantalla)
{
//Mostrem l'error
fprintf(stderr, "No s'ha pogut establir el mode de vídeo: %s\n", SDL_GetError());
exit(1);
}
//Ara tenim el mode de vídeo activat i podem començar a fer coses
 
//Carreguem al buffer de pantalla una imatge
SDL_Surface *imatge;
imatge=IMG_Load("prova.jpg");
 
//La passo a pantalla
SDL_BlitSurface(imatge, NULL, pantalla, NULL);
//Mostro per pantalla la variable pantalla
SDL_Flip(pantalla);
 
//Poso música
int audio_rate = 22050;
Uint16 audio_format = AUDIO_S16SYS;
int audio_channels = 2;
int audio_buffers = 4096;
 
if(Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers) != 0) {
fprintf(stderr, "No s'ha pogut inicialitzar l'audio: %s\n", Mix_GetError());
exit(1);
}
 
//Carreguem el ogg
Mix_Music *musica;
musica = Mix_LoadMUS("musica.ogg");
if(musica == NULL)
{
fprintf(stderr, "Incapaç de carregar el ogg: %s\n", Mix_GetError());
exit(1);
}
//Fem el bucle infinit amb -1
if(Mix_PlayMusic(musica, -1) == -1)
{
fprintf(stderr, "Incapaç d'obrir l'arxiu ogg: %s\n", Mix_GetError());
exit(1);
}
 
//Pengem el programa fins que hi hagi un event de teclat
while (!sortir)
{
SDL_Event event;
SDL_WaitEvent(&amp;event);
if(event.key.keysym.sym==SDLK_RETURN)
{
sortir=1;
}
}
//Matem el SDL
SDL_Quit();
}

I ja tenim un programa cutrillo que fa ús de pantalla completa i de música (està en loop).

Aquí en teniu una versió compilada per a x86 i amb els arxius necessaris (imatge i música), així com el codi font (Del Makefile ni cas, que ara no recordo com fer-lo ).

M'explico. En els nostres programes, com a principi, la definició de les variables la farem dintre de la funció on s'empri dita variable, i mai com a variables globals (Una variable global és una variable que pot ser accedida per qualsevol funció a sac, però això no sempre és bo i com a bona pràctica de programació es desaconsella el seu ús). Com hem vist abans els funcions només ens retornen un valor, del tipus que sigui, però només un. Això és una limitació important a quan es vol, o es necessita, que una funció modifiqui diversos canvis de variables.

Com he dit abans els punters són adreces de memòria. Entenem que la memòria a la que el programa accedeix és la de la màquina. Com vaig dir al tema de funcions al passar-se una variable el que realment es fa és copiar-la, pel que l'original no es veu modificada en cap moment. En canvi si emprem un punter el que farem és passar-li l'adreça de memòria on està guardada la variable original, amb el que els canvis que fem a la funció afectaran directament a l'adreça original. Això s'anomena passar una variable per referència i es fa de la següent manera:

resultat=funcio(var1,var2,&var3);


Aquí podem veure que funció retorna un valor que és emmagatzemat a resultat, però var3 té un & estrany davant. Aquest símbol el que fa és incidar que passem l'adreça de memòria on està guardada var3.

Ara mirem com queda la definició de la funció:


int funcio (int var1, int var2, int *var3)
{
*var3 = var1+var2;
return var1-var2;
}

Com podeu veure aquesta funcio, que hem anomenat "funcio", retorna la resta de var1 menys var2, però modifica també el valor de var3, canvi que seguirà present quan sortim de la funció. Davant de var3 ara he posat un * (punter), aquest símbol el que fa és accedir al contingut d'on apunta l'adreça de memòria. És a dir, si fèssim un "printf ("%d",var3);" el que veuríem no seria el valor de var3, sinó l'adreça de memòria on estan guardades les dades, per mostrar les dades de var3 hauríem de fer: "printf ("%d",*var3);

És una mica farregosa la nomenclatura, però molt potent.

A més es pot crear un punter directament, aquí l'empràvem com a 'eina' però podem crear un punter i llavors demanar memòria per al tipus de dada que vulguem que emmagatzemi. Penseu que fins ara només hem vist com treballar amb estructures estàtiques, és a dir, si defineixo int numeros[1000]; vol dir que números té caselles per guardar 1000 números de tipus int, però si ens passem tenim moltes possibilitats de que el programa rebenti o ens agafi 'porqueria' a la memòria que tenim més enllà de les dimensions que hem delimitat per números. En canvi si tenim una llista que volem que sigui d'"infinites" entrades haurem d'emprar punters i anar-els-hi creant la memòria a mesura que els entrem.

Això ho veig un xic més complex així que només posaré un parell d'exemples de demanar memòria però es veurà en més detall quan parli de tipus d'estructures d'emmagatzamament, més endevant.

Declarem un punter d'un tipus:

int *molts;

Ara demanem memòria per a la dada:

molts=(int *)malloc(sizeoff(int));

Amb aquesta crida demanem espai de memòria amb malloc per a un punter de tipus int, el principi, amb la mida, això ho fem amb el sizeoff, d'int. Això ho podem fer amb qualsevol tipus de dada, siguin ja definides o estructures que creem nosaltres.

Tal com la funció main retorna un enter, podem fer una funció que retorni un caràcter, un real, cadena o fins i tot estructures ( recordar typedef struct). Això fa que una funció pugui retornar un valor amb només return <variable>;


float donarreal(float variable)
{
float variable2=0; //Això és un comentari, és ignorat per el compilador, inicialitzem a 0 la variable2
variable2 = variable/40;
return variable2;
}

Com podem veure aquesta funció retorna un real, variable2.  Si us hi fixeu he inicialitzat variable2 amb un valor igual a 0, però realment no feia feina, ja que la primera operació que fem amb ella és assignar-li el valor de variable dividit entre 40. Tot i no ser necessari en aquest cas és una bona costum, doncs quan creem una variable, aquesta rep una posició física a la memòria, que pot tenir ja dades emprades anteriorment, pel que voldrem tenir-hi un valor vàlid per a l'aplicació i no un d'aleatori.

Com ja haureu les funcions tenen una limitació important per si soles, doncs només poden retornar una variable, I els valors que se l'hi passen, com ara "variable", només canvien el seu valor mentre estan dintre de la funció, un cop sortim de la funció, es perden els canvis fets. És a dir, si dintre la funció féssim "variable=0;" , al sortir de la funció aquest canvi es perdria. Perquè? Doncs perquè quan passem una variable a una funció així, el que fem és fer una còpia de la variable original en una nova posició de memòria, el que fa que tots els canvis que hi fem no afectin a la variable de la funció mare, la original. La solució per a que una variable sigui modificada des d'una funció filla és l'ús de punters, que explicaré un altre dia

Fins ara hem vist com fer una funció, però com la cridem? Una crida de funció és el mateix que quan escrius la seva definició però simplificada (doncs al estar definida els paràmetres ja sabem de quin tipus és cadascun). En el cas  de l'anterior funció donarreal:


novavariable=donarreal(variablevella);


"novavariable" i "variablevella" són dues dades de tipus float (real) i el que fem aquí és passar-li la "variablevella" a la funció donarreal (com veiem el nom no té perquè ser igual al que hem posat a la definició de la funció). i llavors la funció ens retorna un valor real (float) que emmagatzemarem dintre de "novavariable".

if

En anglès vol dir "si". És a dir , si la condició és compleix fes....


if(opcio==1)
{
//codi
}

En aquest cas sí opció val 1 s'executarà el codi dintre de la funció. Aquí veiem un parell de coses. Primera, quan es compara s'empra == i no pas =, = és per donar un valor, i == per comparar-lo. Segon, les funcions van delimitades amb { } si tenen més d'una línia de codi. Això ja ho havíem vist quan vàrem fer el programa hola món, on el codi del main també anava entre { }.

Però el if té més possibilitats, el else if, que ve a ser "sino és compleix i si", i finalment else, que és quan no es compleix res de res:


if(opcio==1)
{
printf("Entro al if");
}
else if(opcio==2)
{
printf("Entro al else if");
}
else if(opcio==3)
{
printf("Entro al segon else if");
}
else
{
printf("Com que no puc entrar enlloc més, entro al else");
}

Cal saber que ni el else if ni el else són necessaris, són opcionals.

for

Aquesta funció és una iteració en que es fixa el valor d'una variable, quina condició s'ha de complir i que s'ha de fer cada vegada que s'entri a la funció:


for(i=0;i>1000;i++)
{
printf("Doncs això mil vegades, de 0 a 999");
}

Primer diem que i val 0, llavors que mentre i sigui més petit que 1000 executi el codi que té dintre, en aquest cas el printf. El tercer paràmetre fa que quan acabi d'executar-se el contingut de for s'augmenti i en 1, és a dir i++ és igual que posar i=i+1. Cal també dir que si poséssim ++i, la variable augmentaria de valor abans d'executar-se el contingut del for.

while

Aquesta funció executa un codi mentre la condició es compleixi, tant fa si no entra mai, com si s'executa un milió de vegades:


while(sortir==0)
{
//programa
}

Això pot ser, per exemple, la iteració d'un programa, que s'executa fins que li diem que volem sortir, canviant el valor de sortir per un 1 o algun altre valor.

switch

Aquesta funció és molt útil per a fer un menú, per exemple. És com un if un xic més complex:


switch(variable)
{
case '1':
//codi
break;
case '2':
//codi
break;
case '3':
//codi
break;
}

Veiem que analitzarem la variable "variable", i que aquesta serà un char, d'aquí les cometes entre les que va la variable. És millor fer servir un char que no pas un int, doncs si ens posen un valor que no sigui un enter, el nostre programa segurament petaria...

El break; serveix per a que pari d'executar codi, si per exemple entréssim al case '1' i no poséssim el break; al final, també s'executaria el codi de case '2' i així anar fent. A vegades ens pot interessar per a una determinada funció que això sigui així, però normalment no és el cas.

Ara ja hem vist unes quantes estructures de control bàsiques amb les que es pot fer molta cosa.

Com podeu veure no hi ha definit cap tipus string (cadena) ja que per a C una cadena és un array de chars. El tipus double és un tipus float de més bytes, pel que pot contenir un número més gran que no pas float.

Aquí ja podem veure que aquests tipus tot just cobreixen les necessitats bàsiques, i que de voler fer una cosa més complexa haurem de definir els nostres propis tipus de dades mitjançant aquests tipus explicats a dalt.

Per a fer-ho podem emprar el typedef, aquí un exemple de com es declararia un nou tipus, a mode d'exemple:

typedef char mot[40];

typedef struct{
mot model;
int unitats;
}electro;

Com podeu veure el primer typedef el que fa és definir un nou tipus mot, que es tracta d'un array de 40 chars, una cadena. El segon typedef ens defineix una estructura, d'aquí el struct, on s'hi diu que hi ha un tipus mot anomenat model i un tipus int (enter) anomenat unitats. El nom del nou tipus va al final, que seria electro.

Operadors

Els operadors ens permeten fer operacions de suma, resta, lògica,... per a emprar-los als nostres condicionals i efectuar les operacions matemàtiques necessàries. Aquest només és una breu llista, de fet n'hi ha força més, però per començar aquests seran més que suficents.

Estructures condicionals

Ara que tenim operadors podem llistar les diverses estructures condicionals que podem emprar a C.

If: Aquesta estructura fa que s'executi el codi que conté sí la condició que li donem es compleix.

if(i==1)
{
}
else if (i==2)
{
}
else
{
}


El if sempre ha de ser la primera condició, si i val 1 llavors executaria el codi dintre dels seus {}. Si no ho fós llavors miraria el "else if", que ve a di, si no és compleix el if.... En aquest cas miraríem si i val 2. Si es complís executaríem el codi dintre dels seus claudàtors ({}). Finalment el codi de l'else s'executaria si cap dels dos complissin la codició que s'ha imposat. Es poden posar tants else if com els vulgui però el primer ha de ser un if. El else no és necessari, només en cas que volguem que faci alguna cosa si cap de les condicions s'ha complert.

while: Aquesta estructura s'executarà continuament fins que la condició es deixi de complir. Va molt bé per a fer bucles que no parin de repetir-se fins que vulguem.


while(i<100)
{
}


for: Aquesta estructura s'executa fins que la condició es compleix. Cal dir que el for va bé quan sabem quantes iteracions volem que es produeixin


for(i=0;i<1000;i++)
{
}

El for rep tres paràmetres separats per punt i coma. El primer és la inicialització del valor de la variable, el segon la condició que mentre compleixi s'anirà executant una i altre vegada i finalment que ha de fer quan acabi una iteració. En aquest cas faria 1000 execucions, de 0 a 999, ja que quan la i valgués 1000 aquesta deixaria de ser lògicament més petita que 1000

switch: Aquesta funció és molt útil per a fer menús per exemple. El switch rep una variable i realitza una o altre acció en funció del seu valor.


switch(opcio)
{
case: 'A':
//Codi a executar-se
break;
case 'B':
break;
}


Si es complís que opció valgués A, s'executaria el codi de sota fins al break; (compte, si no es posa break continuaria executant instruccions fins a veure'n un o acabar el switch, tot i que a vegades pot interessar precisament això).

Amb això ja quasi podríem fer un programa, encara ens faltarà per veure els tipus de dades que empra C, a la propera ho veiem.