Controlar motor de passo em C

(Por Danilo Csar)

#include<stdio.h> #include<sys/io.h> //Libreria para acceso a los puertos #define PUERTO 0x378 //Direccion Hexadecimal del puerto paralelo #define espera 10000// tiempo de espera int main() { int valor, i; int lectura; ioperm(PUERTO, 3, 1); //Otorgar permisos para puerto Paralelo outb(1, PUERTO + 2); for (;;) { outb(1, PUERTO); usleep (espera); outb(2, PUERTO); usleep (espera); outb(4, PUERTO); usleep (espera); outb(8, PUERTO); usleep (espera); lectura = inb(PUERTO + 2); if((lectura & 0x0F) != 1) break; } outb(0, PUERTO); // outb(2, PUERTO); // Enviar 2 al puerto paralelo // valor = inb(PUERTO); //Lectura del Valor del Puerto // printf("Valor del Puerto: %d\n", valor); ioperm(PUERTO, 3, 0); //Remover permisos para puerto Paralelo return 0; }

________________________________________________________

Matrizes na Linguagem C
By Jair Gustavo de Mello Torres

6.1 Compreendendo as Matrizes

Muitas vezes em programas, necessrio que uma varivel contenha muitos valores. Por exemplo, a varivel nota pode controlar as notas obtidas por 100 alunos em um exame. Da mesma maneira, a varivel salrios poderia controlar os salrios de cada funcionrio em uma companhia. Uma matriz uma estrutura de dados que pode armazenar mltiplos valores do mesmo tipo. Por exemplo, pode-se criar uma matriz que possa conter 100 valores do tipo int e uma Segunda matriz com 25 valores do tipo float. Todo valor que voc atribui a uma matriz precisa ser do mesmo tipo que o tipo da matriz. Neste mdulo ser mostrado como criar e trabalhar com matrizes em programas. Com o tempo, aps o uso de matrizes, ficar claro como simples o uso de matrizes.

6.2 Declarando uma Matriz

Para declarar uma matriz, precisa-se especificar o tipo desejado (tal como int, float ou double), bem como o tamanho da matriz. Para especificar o tamanho de uma matriz, coloca-se o nmero de valores que a matriz pode armazenar dentro de colchetes aps o nome da matriz. Por exemplo, a declarao seguir cria uma matriz chamada notas, que pode armazenar 100 notas de exame do tipo int:

int notas [100];

De forma similar, a seguinte declarao cria uma matriz do tipo float, que contm 50 salrios:

float salarios [50];

Quando uma matriz declarada, a Linguagem C aloca memria suficiente para conter todos os elementos. O primeiro item est na posio 0. Por exemplo, nas matrizes notas esalarios, os comandos a seguir atribuem os valores 80 e 35000 aos primeiros elementos da matriz:

notas[0] = 80; salarios[0] = 35000;

Como o primeiro elemento da matriz inicia no deslocamento 0, o ltimo elemento da matriz ocorre uma posio antes do tamanho da matriz. Dadas as matrizes anteriores, os comandos a seguir atribuem valores ao ltimo elemento de cada matriz:

notas[99] = 65; salarios[49] = 250000;

6.3 Compreendendo os Requisitos de Armazenamento de uma Matriz

Ao declarar uma matriz, o compilador aloca memria suficiente para conter o nmero de valores especificado. A quantidade real de memria que o compilador aloca depende do tipo da matriz. Por exemplo, uma matriz de 100 elementos do tipo int normalmente ir requerer 100*2 ou 200 bytes de memria. Por outro lado, uma matriz de 100 elementos do tipo float ir requerer 100*4 bytes ou 400 bytes. O programa abaixo, usa o operador sizeof para exibir a quantidade de memria que os diferentes tipos de matrizes requerem:

#include <stdio.h>

void main(void) { int notas[100]; float salar[100]; char string[100];

printf("Memoria para conter int notas[100] %d bytes\n", sizeof(notas)); printf("Memoria para conter float salar[100] %d bytes\n", sizeof(salar)); printf("Memoria para conter char string[100] %d bytes\n", sizeof(string)); }

6.4 - Inicializando uma Matriz

Muitos programas em Linguagem C inicializam as strings de caracteres como segue:

char titulo[] = "UNESP - Ilha Solteira"; char secao[64] = "Matrizes";

No primeiro caso, o compilador alocar 22 bytes para armazenar a string. No segundo, o compilador alocar uma matriz de 64 bytes, inicializando os primeiro 8 caracteres com as letras "Matrizes" e o caracter NULL. A maioria dos compiladores tambm inicializar as posies de bytes restantes com NULL. Quando declara-se matrizes de outros tipos, pode inicializar matrizes da mesma forma. Por exemplo, o comando a seguir inicializa a matriz de inteiros notas com os valores 80, 70, 90, 85 e 80:

int notas[5] = {80, 70, 90, 85, 80};

Quando atribui-se valores iniciais a uma matriz, necessrio delimitar os valores por abre e fecha chaves ( {} ). No caso anterior, o tamanho da matriz igual ao nmero de valores atribudos. O comando a seguir, no entanto, atribui quatro valores de ponto flutuante a uma matriz que pode armazenar 64 valores:

float salar[64] = {25000.0, 32000.0; 44000.0, 23000.0};

Dependendo do compilador, ele pode atribuir 0 aos elementos aos quais o programa no atribui valores explcitos. No entanto, como regra, no se deve assumir que o compilador inicializar os outros elementos. Alm disso, se no for especificado um tamanho de matriz, o compilador alocar memria suficiente para conter somente os valores que voc especificar. Por exemplo, a seguinte declarao de matriz cria uma matriz grande o suficiente para conter trs valores do tipo long:

long planetas[] = {1234567L, 654321L, 1221311L};

6.5 Acessando Elementos da Matriz

Os valores armazenados em uma matriz so chamados elementos de matriz. Para acessar um elemento da matriz, voc especifica o nome da matriz e o elemento que deseja. O programa a seguir, inicializa a matriz notas e depois usa printf para exibir os valores dos elementos:

#include <stdio.h>

void main(void) { int notas[5] = {80, 70, 90, 85, 80};

printf("Valores da Matriz\n"); printf("notas[0] %d\n", notas[0]); printf("notas[1] %d\n", notas[1]); printf("notas[2] %d\n", notas[2]); printf("notas[3] %d\n", notas[3]); printf("notas[4] %d\n", notas[4]);

6.6 Percorrendo em um Lao Elementos da Matriz

Quando se referencia muitos elementos de uma matriz, especificar nmeros para cada elemento da matriz individualmente pode ser demorado e tedioso. Como uma alternativa, os programas podem usar uma varivel para referenciar os elementos da matriz. Por exemplo, assumindo que a varivel i contenha o valor 2, o comando a seguir atribuiria o valor 80 a matriz[2]:

i = 2; matriz[i] = 80;

O cdigo a seguir usa a varivel i e um lao for para exibir os elementos da matriznotas:

#include <stdio.h>

void main(void) { int notas[5] = {80, 70, 90, 85, 80}; int i;

printf("Valores da Matriz\n"); for (i = 0; i < 5; i++) printf("notas[%d] %d\n", i, notas[i]); }

6.7 Usando Constantes Para Definir as Matrizes

Como visto, quando os programas trabalham com matrizes, necessrio especificar o tamanho da matriz. Por exemplo, o programa a seguir declara uma matriz de cinco valores e depois usa um lao for para exibir os valores da matriz:

#include <stdio.h>

void main(void) { int valores[5] = {80, 70, 90, 85, 80}; int i;

for (i = 0; i < 5; i++) printf("valores[%d] %d\n", i, valores[i]); }

Por exemplo, suponha que seja necessrio alterar o cdigo anterior de tal forma que ele suporte 10 valores. Precisar alterar no somente a declarao da matriz, mas tambm o lao for. Quanto mais alteraes forem feitas em um programa, maiores as chances de errar. O programa a seguir declara uma matriz com base na constante TAM_MATRIZ. Como se v, o programa no somente usa a constante para declarar a matriz, mas tambm usa a constante como a condio final para o lao for:

#include <stdio.h> #define TAM_MATRIZ 5

void main(void) {

int valores[TAM_MATRIZ] = {80, 70, 90, 85, 80}; int i;

for (i = 0; i < TAM_MATRIZ; i++) printf("valores[%d] %d\n", i, valores[i]); }

Se mais tarde for necessrio alterar o tamanho da matriz, poder alterar o valor atribudo constante TAM_MATRIZ para que o programa automaticamente atualize os laos que controlam a matriz como o tamanho da matriz.

6.8 Passando uma Matriz a uma Funo

Quando declara-se uma funo que trabalha com um parmetro matriz, precisa informar o compilador. Por exemplo, o seguinte programa usa a funo exibe_matriz para exibir os valores em uma matriz. Como pode-se ver, o programa passa para a funo tanto a matriz como o nmero de elementos que a matriz contm, como mostrado a seguir:

#include <stdio.h> void exibe_matriz(int valores[], int num_de_elementos) { int i; for (i = 0; i < num_de_elementos; i++) printf("%d\n", valores[i]); } void main(void) { int notas[5] = {70, 80, 90, 100, 90};

exibe_matriz(notas, 5); }

Quando uma funo recebe uma matriz como parmetro, o programa no precisa especificar o tamanho da matriz na declarao do parmetro. No caso da funoexibe_valores, os colchetes aps o nome da varivel valor informam o compilador de que o parmetro uma matriz. Sabendo que o parmetro uma matriz, o compilador no se preocupa com o tamanho da matriz que o programa passa para a funo.

6.9 Revisitando as Matrizes Como Funes

No item anterior, foi visto que ao declarar o parmetro formal para uma matriz, no necessrio declarar o tamanho da matriz. Em vez disso, pode-se especificar somente o abre e fecha colchetes. O programa a seguir passa trs matrizes diferentes (de diferentes tamanhos) para a funo exibe_valores:

#include <stdio.h>

void exibe_matriz(int valores[], int num_de_elementos) { int i;

printf("Prestes a exibir %d valores\n",num_de_elementos); for (i = 0; i < num_de_elementos; i++) printf("%d\n", valores[i]); }

void main(void) { int notas[5] = {70, 80, 90, 100, 90}; int conta[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int pequeno[2] = {-33, -44};

exibe_matriz(notas, 5); exibe_matriz(conta, 10); exibe_matriz(pequeno, 2); }

6.10 Compreendendo Como as Matrizes de String Diferem

Muitos programas passam string para funes. Em muitos casos, as funes no especificaram o tamanho da string. Por exemplo, o comando a seguir usa a funo strupr para converter uma string para maisculas:

char titulo[64] = "Unesp Ilha Solteira"; strupr(titulo);

Como foi visto, na Linguagem C o caracter NULL representa o final de uma string de caracteres. Portanto, as funes podem procurar o caracter NULL nos elementos da matriz para determinar onde a matriz termina. No entanto, as matrizes de outros tipos, tais como int, float ou long, no tem um caracter finalizador equivalente. Portanto, voc normalmente precisa passar para as funes que trabalham com matrizes o nmero de elementos que a matriz contm.

6.11 Determinando Quantos Elementos Uma Matriz Pode Armazenar

J foi visto anteriormente que, dependendo do tipo de uma matriz, a quantidade real de memria que uma matriz pode consumir diferir. Se o ambiente de trabalho for o DOS, a quantidade de memria que as matrizes podem consumir depender do modelo de memria atual. Em geral, uma matriz no pode consumir mais do que

64Kb de espao. O programa a seguir pode no passar na compilao porque as matrizes consomem muita memria:

void main(void) { char string[66000L]; int values[33000L]; float numbers[17000]; } /* 66,000 bytes */ /* 33,000 * 2 = 66,000 bytes */ /* 17,000 * 4 = 68,000 bytes */

6.12 Compreendendo as Matrizes Multidimensionais

Como foi visto, uma matriz uma varivel que pode armazenar mltiplos valores do mesmo tipo. Em todos os exemplos apresentados at o momento, as matrizes consistiram de uma fileira de dados. No entanto, a Linguagem C permite matrizes bi, tri emultidimensionais. O melhor modo de visualizar uma matriz bidimensional com uma tabela com linhas e colunas. Se uma matriz contm trs dimenses, visualize-a como vrias pginas, cada uma das quais contendo uma tabela bidimensional. Por exemplo, ao declarar-se uma matriz bidimensional, o primeiro valor que for especificado informar o nmero de linhas, e o segundo valor, o nmero de colunas:

int tabela [2] [3];

6.13 - Inicializando Elementos em Uma Matriz Bidimensional

No item 5.4 foi visto que, para inicializar elementos de matriz, voc pode colocar os valores do elemento dentro de abre e fecha colchetes aps a declarao da matriz. O comando a seguir usa a mesma tcnica para inicializar uma matriz bidimensional. No entanto, neste caso, o comando especifica os valores para cada linha da matriz dentro de chaves:

int tabela [2] [3] = {{1,2,3}, {4,5,6}};

O compilador inicializar os elementos da matriz como mostrado a seguir:

1 4

2 5

3 6

6.14 Percorrendo em Um Lao Uma Matriz Bidimensional

Quando os programas trabalham com matrizes bidimensionais, normalmente usa-se duas variveis para acessar elementos da matriz. O programa a seguir usa as variveis linha ecoluna para exibir os valores contidos dentro da matriz tabela:

#include <stdio.h> void main(void) { int linha, coluna;

float tabela[3][5] = {{1.0, 2.0, 3.0, 4.0, 5.0}, {6.0, 7.0, 8.0, 9.0, 10.0}, {11.0, 12.0, 13.0, 14.0, 15.0}};

for (linha = 0; linha < 3; linha++) for (coluna = 0; coluna < 5; coluna++) printf("tabela[%d][%d] = %f\n", linha, coluna,

tabela[linha][coluna]); }

Colocando laos for um dentro do outro, como mostrado, o programa exibir os elementos contidos na primeira linha da matriz (1.0 at 5.0). Em seguida, o programa ir se mover para a prxima linha, e, depois, para a terceira linha, exibindo os elementos dentro de cada linha.

6.15 Percorrendo Uma Matriz Tridimensional

No item anterior foi visto como percorrer uma matriz bidimensional usando duas variveis chamadas linha e coluna. O programa a seguir usa as variveis linha, coluna etabela para percorrer uma matriz tridimensional:

#include <stdio.h>

void main(void) { int linha, coluna, tabela;

float valores[2][3][5] = { {{1.0, 2.0, 3.0, 4.0, 5.0}, {6.0, 7.0, 8.0, 9.0, 10.0}, {11.0, 12.0, 13.0, 14.0, 15.0}},

{{16.0, 17.0, 18.0, 19.0, 20.0}, {21.0, 22.0, 23.0, 24.0, 25.0}, {26.0, 27.0, 28.0, 29.0, 30.0}} };

for (linha = 0; linha < 2; linha++) for (coluna = 0; coluna < 3; coluna++) for (tabela = 0; tabela < 5; tabela++) printf("valores[%d][%d][%d] = %f\n", linha, coluna, tabela, valores[linha][coluna][tabela]); }

6.16 Passando uma Matriz Bidimensional Para uma Funo

No item 5.8, foi visto que, ao passar matrizes para uma funo, no ser necessrio especificar o nmero de elementos na matriz. Em matrizes bidimensionais, no ser necessrio especificar o nmero de linha na matriz, mas, sim, especificar o nmero de colunas. O programa a seguir usa a funo exibe_2d_matriz para exibir o contedo de variveis matrizes bidimensionais:

#include <stdio.h> void exibe_2d_matriz(int matriz[][10], int linhas) { int i, j; for (i = 0; i < linhas; i++) for (j = 0; j < 10; j++) printf("matriz[%d][%d] = %d\n", i, j, matriz[i][j]); } void main(void) {

int a[1][10] = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}; int b[2][10] = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {11, 12, 13, 14, 15, 16, 17, 18, 19,20}}; int c[3][10] = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {11, 12, 13, 14, 15, 16, 17, 18, 19, 20}, {21, 22, 23, 24, 25, 26, 27, 28, 29, 30}}; exibe_2d_matriz(a, 1); exibe_2d_matriz(b, 2); exibe_2d_matriz(c, 3); }

6.17 Tratando as Matrizes Multidimensionais Como Uma Dimenso

Quando for necessrio trabalhar com os elementos de uma matriz multidimensional, mas sem precisar acessar os elementos em suas posies de linha ou coluna, as funes podero tratar a matriz multidimensional como se ela tivesse uma dimenso. O programa a seguir retorna a soma dos valores em uma matriz bidimensional:

#include <stdio.h>

long soma_matriz(int matriz[], int elementos) { long soma = 0; int i;

for (i = 0; i < elementos; i++)

soma += matriz[i]; return(soma); }

void main(void) { int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int b[2][10]={{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {11, 12, 13, 14, 15, 16, 17, 18, 19,20}}; int c[3][10]={{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {11, 12, 13, 14, 15, 16, 17, 18, 19, 20}, {21, 22, 23, 24, 25, 26, 27, 28, 29,30}};

printf("Soma dos elementos da primeira matriz %d\n", soma_matriz(a, 10)); printf("Soma dos elementos da segunda matriz %d\n", soma_matriz(b, 20)); printf("Soma dos elementos da terceira matriz %d\n", soma_matriz(c, 30)); }

6.18 Sntese do Mdulo

 apresentado seguir, uma sntese do que foi tratado em cada item deste mdulo. Com esta sntese voc poder relembrar conceitos vistos durante nosso estudo ou mesmo direcionar seu estudo, caso voc j tenha conhecimentos na Linguagem C. 6.1 Compreendendo as Matrizes: dada uma explicao que uma matriz uma

estrutura de dados que pode armazenar mltiplos valores do mesmo tipo. 6.2 Declarando uma Matriz: neste item visto como declarar uma matriz, precisando-

se especificar o tipo desejado (tal como int, float ou double), bem como o tamanho da matriz. 6.3 Compreendendo os Requisitos de Armazenamento de uma Matriz: foi visto que

ao declarar uma matriz, o compilador aloca memria suficiente para conter o nmero de valores especificado. A quantidade real de memria que o compilador aloca depende do tipo da matriz. 6.4 Inicializando uma Matriz: neste item explicada de maneira clara como inicializar

diferentes tipos de matrizes. 6.5 Acessando Elementos da Matriz: foi visto que para acessar um elemento da

matriz, voc especifica o nome da matriz e o elemento que deseja. 6.6 Percorrendo em um Lao Elementos da Matriz: foi mostrado que quando se

referencia muitos elementos de uma matriz, especificar nmeros para cada elemento da matriz individualmente pode ser demorado e tedioso. Como uma alternativa, os programas podem usar uma varivel para referenciar os elementos da matriz. 6.7 Usando Constantes Para Definir as Matrizes: mostra como os programas usam

constantes para definir matrizes. 6.8 Passando uma Matriz a uma Funo: visto que programas passam para a

funo tanto a matriz como o nmero de elementos que a matriz contm. 6.9 Revisitando as Matrizes Como Funes: . foi visto um programa que passa trs

matrizes diferentes (de diferentes tamanhos) para a funo exibe_valores. 6.10 Compreendendo Como as Matrizes de String Diferem:explica as principais

diferenas das matrizes de string. 6.11 Determinando Quantos Elementos Uma Matriz Pode Armazenar: foi visto que

se o ambiente de trabalho for o DOS, a quantidade de memria que as matrizes podem consumir depender do modelo de memria atual. Em geral, uma matriz no pode consumir mais do que 64Kb de espao. 6.12 Compreendendo as Matrizes Multidimensionais: foi visto que a Linguagem C

permite matrizes bi, tri e multidimensionais.

6.13 Inicializando Elementos em Uma Matriz Bidimensional: foi mostrado como

inicializar uma matriz bidimensional. 6.14 Percorrendo em Um Lao Uma Matriz Bidimensional: foi mostrado um

programa que usa as variveis linha e coluna para exibir os valores contidos dentro da matriz tabela. 6.15 Percorrendo Uma Matriz Tridimensional: foi mostrado um programa que usa as

variveis linha, coluna e tabela para percorrer uma matriz tridimensional. 6.16 Passando uma Matriz Bidimensional Para uma Funo:foi visto que para

passar matrizes bidimensionais para uma funo, no ser necessrio especificar o nmero de linha na matriz, mas, sim, especificar o nmero de colunas. 6.17 Tratando as Matrizes Multidimensionais Como Uma Dimenso: foi visto que

quando for necessrio trabalhar com os elementos de uma matriz multidimensional, mas sem precisar acessar os elementos em suas posies de linha ou coluna, as funes podero tratar a matriz multidimensional como se ela tivesse uma dimenso.