====== Curso básico de C ======

===== Estrutura de um programa =====

Um programa na linguagem C pode apresentar as mais diversas formas, até mesmo ser composto por uma única linha, pois o compilador de código atenta apenas ao cumprimento das regras de sintaxe e não exige a implementação de uma estrutura específica. Contudo, é aconselhável aos programadores, adotarem um estilo de programação que apresente clareza e simplicidade para qualquer tipo de pessoa que leia o código. Esta é a estrutura típica de um programa em linguagem C:

<code c>
/* Include header files */
#include <avr/io.h>
#include <stdio.h>

/* Macro declarations */
#define PI 3.141

/* Data type definitions */
typedef struct
{
	int a, b;
}
element;

/* Global variables */
element e;

/* Functions */
int main(void)
{	
	// Local variables
	int x;

	// Program code
	printf("Hello World!\n");
}
</code>

===== Comentários =====

Ao programador é dada a liberdade de escrever qualquer tipo de texto num ficheiro de código. Este texto é geralmente utilizado para escrever anotações ou descrição do funcionamento de um excerto de código, neste caso este texto é ignorado pelo compilador. Os comentários podem também ser utilizados para por exemplo excluir temporalmente bocados de código da compilação. Os dois tipos de métodos de comentários em linguagem C são:

<code c>
// Line comment is on one line.
// Text after two slash signs is considered as comment.

/*
 Block comment can be used to include more than one line.
 The beginning and the end of a comment is assigned with slash and asterisk signs.
*/
</code>


===== Dados =====

==== Tipos de dados ====

Os tipos básicos de dados do C:

^ Tipo             ^ Valor Minimo       ^ Valor Máximo    ^ Bits ^ Bytes ^
| (signed) char    | -128               | 127               | 8    | 1     |
| unsigned char    | 0                  | 255               | 8    | 1     |
| (signed) short   | -32768             | 32767             | 16   | 2     |
| unsigned short   | 0                  | 65535             | 16   | 2     |
| (signed) long    | -2147483648        | 2147483647        | 32   | 4     |
| unsigned long    | 0                  | 4294967295        | 32   | 4     |
| float            | -3.4<sup>38</sup>  | 3.4<sup>38</sup>  | 32   | 4     |
| double           | -1.7<sup>308</sup> | 1.7<sup>308</sup> | 64   | 8     |

A palavra "signed" em parêntesis é considerada opcional, pois por omissão um qualquer tipo de dados numérico é considerado "signed" (bipolar).

Ns microcontroladores AVR //int// = //short// \\
No PC //int// = //long// \\

A linguagem C não tem um tipo de dados que represente uma string (conjunto de carateres). Em vez disso são utilizados vetores de carateres (assunto que será abordado adiante), e são utilizados carateres ASCII onde a cada caracter alfabético é representado um valor numérico.

==== Variáveis ====

Um programa pode utilizar um tipo de espações de memória pré-definidos, a isto chamamos variáveis. Os nomes das variáveis podem incluir qualquer caratere do alfabeto latino, números ou //underscores//, desde que o primeiro caractere não seja um caractere numérico. Quando se declara uma variável num programa, é necessário preceder o nome da variável com o tipo de dados desejado. Por forma a atribuir-se um valor a uma variável é utilizado o sinal de igualdade (=). A seguir apresenta-se um exemplo que ilustra a utilização de variáveis:

<code c>
// char type variable c declaration
char c;

// Value is given to variable c.
c = 65;
c = 'A'; // A has in ASCII character map also value 65

// int type variable i20 declaration and initialization
int i20 = 55;

// Declaration of several unsigned short type variables
unsigned short x, y, test_variable;
</code>

==== Constantes ====

As constantes são declaradas da mesma maneira que as variáveis, apenas precedendo a palavra //const// com o tipo de dados respetivo. Uma constante nunca altera o seu valor durante a execução de um programa.
Um exemplo de utilização de constantes:

<code c>
// int type constant declaration
const int x_factor = 100;
</code>

==== Estruturas ====

Os tipos básicos de dados podem ser re-agrupados em estruturas por forma a criarem-se tipos de dados mais complexos, recorrendo à palavra //struct//. Uma estrutura representa um tipo de dados combinado, este tipo é declarado com a palavra //typedef//.
Um exemplo sobre estruturas, sua criação e utilização de tipos de dados complexos:

<code c>
// Declaration of a new data type "point"
typedef struct
{
	// x and y coordinates and color code
	int x, y;
	char color;
}
point;

// declaration of a variable as data type of point
point p;

// Assigning values for point variable
p.x = 3;
p.y = 14;
</code>

==== Vetores ====

Os tipos básicos de dados podem ser organizados em vetores. Os vetores podem ter várias dimensões (tabelas, cubos, etc.). Seguem-se exemplos da utilização de vetores de uma e duas dimensões respetivamente:

<code c>
// Declaration of one- and two-dimensional arrays
char text[3];
int table[10][10];

// Creating a string from char array
text[0] = 'H';  // Char
text[1] = 'i';  // Char
text[2] = 0;    // Text terminator (0 B)

// Assigning new value for one element.
table[4][3] = 1;
</code>

<pagebreak>

===== Operadores =====

As variáveis, constantes e valores retornados de funções podem ser utilizados na composição de operações. O resultado de uma operação pode ser atribuído a uma variável, pode ser utilizado como parâmetro para outras funções ou como valor em diversas estruturas de controlo.

==== Operadores aritméticos ====

A linguagem C suporta a generalidade dos operadores aritméticos, como a soma (+), subtração (-), multiplicação (*), divisão (/) e o módulo (%). Seguem-se alguns exemplos ilustrativos da utilização destes operadores:

<code c>
int x, y;

// Modulo, multiplication and assigning value
// x gets value of 9
x = (13 % 5) * 3;

// Adding-assigning operator
// x gets value of 14
x += 5;

// Quick style method for subtracting 1
// x gets value of 13
x--;
</code>

==== Operadores lógicos ====

Os operadores lógicos na linguagem C são compostos pela negação NOT (!), multiplicação lógica AND (&&) e a adição lógica (||). Seguem-se exemplos da utilização destes operadores:

<code c>
bool a, b, c;

// Initialization
a = true;
b = false;

// Negation
// c will get a value of false because a is true
c = !a;

// Logic multiplication
// c will get a value of false because one of the operators is false
c = a && b;

// Logic addition
// c will get a value of true because one of the operators is true
c = a || b;
</code>

**NOTA!** O tipo de dados //bool// na linguagem C, na realidade não existe, pelo que em alternativa geralmente são utilizados valores inteiros para a representação destes valores, em que o valor 0 representa //Falso//, e qualquer outro valor diferente de 0 representa //Verdadeiro//. Por exemplo, na biblioteca do HomeLab, o tipo de dados //bool// é representado pelo tipo de dados //unsigned char//. A constante //Verdadeiro// é então representada pelo valor 1 e //Falso// representado pelo valor 0.


==== Operadores relacionais e de igualdade ====

Os valores lógicos são geralmente resultado de uma comparação entre variáveis. Os operadores de igualdade são: (==) //igual a//, (!=) //diferente//, (>) //maior que//, (>=) //maior ou igual que//, (<) //menor que//, (<=) //menor ou igual que//. Segue-se um exemplo de utilização destes operadores:

<code c>
int x = 10, y = 1;

// greater than operation which is true
// brackets around the operation are only for clarity
bool b = (5 > 4);

// Not equal to operation
// The result is false
b = (4 != 4);

// Arithmetic, equality and logic operations altogether
// b is false because the first operator of logic multiplication is false
b = (x + 4 > 15) && (y < 4);
</code>

==== Operações de bit ====

As operações de //bit// são utilizadas para manipulação de dados em formato binário. Estas apenas podem ser aplicadas a tipos de dados inteiros. As operações de //bit// são bastante semelhantes às operações lógicas, com a única diferença que porque estas são aplicadas diretamente a cada um dos bits que compõem o valor, e não apenas ao conjunto que compõem o número. As operações de //bit// que existem na Linguagem C são a inversão (~), conjunção (&), disjunção (|), anti-valência (^), rotação à esquerda (<<) e a rotação à direita (>>).

<code c>
// Declaration of unsigned 8 bit char type variable
// Variable value is 5 in decimal system, 101 in binary system
unsigned char c = 5;

// Disjunction of c with a digit 2 (010 in binary)
// c value will become 7 (111 in binary)
c = c | 2;

// Bit left shift by 2
// c value will become 28 (11100 in binary)
c = c << 2;
</code>

As operações de //bit// são essenciais na manipulação de registos de um microcontrolador. Estes registos serão descritos adiante no capítulo de registos do AVR.

<pagebreak>

===== Funções =====

As funções definem partes de um programa que pode ser denominadas e invocadas pelo nome. As funções podem incluir parâmetros de entrada e permitem retornar um valor de saída. Se a função não retorna nenhum valor, esta função é definida com o tipo //void//. Se a função não possui parâmetros de entrada, em versões mais antigas da Linguagem C, o tipo //void// também deve ser incluído dentro dos parêntesis da sua declaração.
Segue-se um exemplo de uma função que adiciona dois números inteiros e outro de uma função que não retorna nenhum valor.

<code c>
// Declaration of 2 int type parameter function
// The function returns int type value
int sum(int a, int b)
{
	// Addition of 2 variables and returning of their sum
	return a + b;
}

// Function without parameters and no return output
void power_off(void)
{
}
</code>

Para utilizar-se uma função, esta deve ser invocada. Para isso, é necessário que a função seja declarada antes de ser invocada. Um exemplo com a invocação de uma função:

<code c>
int x;
int y = 3;

// Calling an addition function
// Parameetriteks on muutuja ja konstandi väärtus
// The parameters are variable and constant
x = sum(y, 5);

// The call of a power off function
// No parameters
power_off();
</code>

A execução de um programa em Linguagem C é sempre iniciada na função //main//.

<pagebreak>

===== Declarações =====

==== Declarações If/Else ====

As declarações condicionais, permitem a execução condicional do código de um programa com base em operações lógicas e/ou relacionais. Uma declaração condicional utiliza a palavra //if//. Exemplo:

<code c>
// Statement is true and operation x = 5 will be executed
// because 2 + 1 is higher than 2
if ((2 + 1) > 2) x = 5;

// If x equals 5 and y equals 3 then the following code will be executed
if ((x == 5) && (y == 3))
{
	// Random action
	y = 4;
	my_function();
}
</code>

Um //if// permite também adicionar uma cláusula //else// que só é executada em caso do valor Falso. Exemplo:

<code c>
// Is x equal with 5 ?
if (x == 5)
{
	// Random action
	z = 3;
}
// If this is false then x might be equal with 6
else if (x == 6)
{
	// Random action
	q = 3;
}
// If x was not 5 nor 6 ...
else
{
	// Random action
	y = 0;
}
</code>

<pagebreak>

==== Declaração Switch ====

Quando é necessário comparar operações e variáveis com várias combinações de diferentes valores, é geralmente recomendável que se use em alternativa uma comparação com base na declaração //switch//. Exemplo da sua utilização:

<code c>
int y;

// Switch statement for comparing y
switch (y)
{
	// is y equal to 1 ?
	case 1:
		// Random action
		function1();
		break;

	// is y equal to 2 ?
	case 2:
		// Random action
		function2();
		break;

	// All other cases
	default:
		// Random action
		functionX();
		// break operation not needed,
		// because the comparison ends anyway
}
</code>

===== Loops =====

Os //loops// permitem-nos executar código várias vezes.

==== while loop ====

O código encapsulado por um //while// é executado até que a condição entre parêntesis obtenha o valor Falso. Exemplo:

<code c>
int x = 0;

// Loop will execute until x is smaller than 5
while (x < 5)
{
	// x incrementation
	x++;
}
</code>

<pagebreak>

==== for loop ====

O loop //for// assemelha-se ao loop //while//, excepto que as operações que este engloba são executadas antes da condição de e a verificação da condição é sempre efetuada no fim de cada ciclo. Exemplo:

<code c>
int i, x = 0;

// i is equal to 1 at the beginning of the loop.
// Loop will be executed until i is smaller than 5.
// i will be incremented in the end of every loop cycle.
for (i = 0; i < 5; i++)
{
	// x addition by 2
	x += 2;
}

// here x value is 10
</code>

==== Saída de loops ====

A iteração de ciclos //while// ou //for// pode ser terminada com a instrução //break//. Para retomar a próxima iteração de um ciclo evitanto a execução do código que se segue pode ser feita com um //continue//. Por exemplo:

<code c>
int x = 0, y = 0;
 
// Infinite loop because 1 is logic true
while (1)
{    
	// Exit the the loop cycle if x becomes 100
	if (x >= 100) break;
	
	// x incrementation to end loop at some time
	x++;
 
	// If x is 10 or less then the next cycle is started
	if (x <= 10) continue;
 
	// y incrementation
	y++;
}

// Here y value is 90
</code>

==== Operações de texto ====

As operações de texto são geralmente utilizadas em microcontroladores para mostrar caracteres e texto num ecrã LCD, por exemplo.

==== sprintf ====

A função //sprintf// é bastante simular à função //printf// mais comumente utilizada na Linguagem C. A diferença entre estas é que o resultado desta função é carregado numa variável em vez do //standard output//.

return = sprintf(variable, parameter_text, parameters);

Exemplo:

<code c>
int r = sprintf(buffer, "%d pluss %d on %d", a, b, a+b);
</code>


Esta função carrega a variável passada como primeiro argumento com texto formatado, texto este que é passado como segundo argumento da função, ao qual podem ser atribuídos valores com os seus restantes argumentos. O uso da função //sprintf// permitirá compôr texto mais complexo de maneira mais simples. Como retorno, esta função devolve o tamanho do texto que foi carregado na variável e no caso de erro, um valor negativo é retornado.

Exemplo:
<code c>
  sprintf(x, "%d. is first", 1);
  // the same result can be achieved also:
  x = "1. is first";

  sprintf(x, "%s is %d years old", "Juku", 10);
  // the same result can be achieved also:
  x = "Juku is 10 years old";
</code>

%s e %d neste exemplosão parâmetros que irão ser substituídos pelos valores dos dois últimos parâmetros da função, respetivamente. O número de parâmetros deve igualar ao número de variáveis utilizadas na expressão.
No primeiro exemplo, o parâmetro %d toma o valor 1. No segundo exemplo, os parâmetros %s e %d são substituídos pelos valores das variáveis, "Juku" e 10 respetivamente. Esta ordem de substituição dos parâmetros é respetiva à ordem em que se apresentam os valores. Existem vários descrições para os diferentes tipos de dados:

^ Parameter       ^ Description     ^ Example    ^
| %c | Char     | a |
| %i or %d    | Integer| 123 |
| %f | Real number | 3,14 |
| %s | Text   | example|
| %X | Hexadecimal number| 3F |

<code c>
#include <stdio.h>

int main ()
{
  char buffer [50];
  int n, a=5, b=3;
  n=sprintf (buffer, "%d plus %d is %d", a, b, a+b);
  printf ("\"%s\" is %d digits long\n",buffer,n);
  return 0;
}
</code>

==== Funções genéricas ====

A biblioteca standard da Linguagem C (stdlib.h) inclui funções que permitem a simplificação de várias operações e conversões mais comuns

==== Função aleatória ====

Não é fácil gerar um número aleatório num microcontrolador.

Primeiro, é necessário dar como parâmetro de entrada um //gerador// que servirá como base para a geração do conjunto de números aleatórios. Este conjunto, se for sempre baseado no mesmo número //gerador//, será sempre igual. Por forma a tornar o resultado desta função mais aleatório, geralmente utiliza-se como valor //gerador//, um dos valores recolhidos de um dos pinos do ADC do microcontrolador.

Exemplo:
<code c>
srand(100);
rand();
</code>

Exemplo de geração de um número aleatório na gama de 1-16:
<code c>
#include <stdlib.h>

int x;
x=rand() % 16;
</code>

Para uma descrição mais detalhada de todas as funções incluídas na Linguagem C:

[[http://www.cplusplus.com/reference/clibrary/|http://www.cplusplus.com/reference/clibrary/]]