Projeto 2012.1 - Mecabot
________________________________________________________
 |
| Interface gráfica - Mecabotcontroller |
Projeto 2011.1 - Furadeira CNC
________________________________________________________
Interface gráfica
Algoritmo desenvolvido pela equipe Mecawork em Shell Script
________________________________________________________
Controlar motor de passo em C
(Por Danilo César)
#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
#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;
{
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);
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
// 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, é necessário que uma variável contenha muitos valores. Por exemplo, a variável nota pode controlar as notas obtidas por 100 alunos em um exame. Da mesma maneira, a variável salários poderia controlar os salários de cada funcionário em uma companhia. Uma matriz é uma estrutura de dados que pode armazenar múltiplos 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 módulo será mostrado como criar e trabalhar com matrizes em programas. Com o tempo, após 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 número de valores que a matriz pode armazenar dentro de colchetes após o nome da matriz. Por exemplo, a declaração à seguir cria uma matriz chamada notas, que pode armazenar 100 notas de exame do tipo int:
int notas [100]; |
De forma similar, a seguinte declaração cria uma matriz do tipo float, que contém 50 salários:
float salarios [50]; |
Quando uma matriz é declarada, a Linguagem C aloca memória suficiente para conter todos os elementos. O primeiro item está na posição 0. Por exemplo, nas matrizes notas e salarios, 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 posição 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 memória suficiente para conter o número de valores especificado. A quantidade real de memória 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 memória. 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 memória 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 também inicializará as posições 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, é necessário delimitar os valores por abre e fecha chaves ( {} ). No caso anterior, o tamanho da matriz é igual ao número de valores atribuídos. 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 não atribui valores explícitos. No entanto, como regra, não se deve assumir que o compilador inicializará os outros elementos. Além disso, se não for especificado um tamanho de matriz, o compilador alocará memória suficiente para conter somente os valores que você especificar. Por exemplo, a seguinte declaração de matriz cria uma matriz grande o suficiente para conter três valores do tipo long:
long planetas[] = {1234567L, 654321L, 1221311L}; |
6.5 – Acessando Elementos da Matriz
Os valores armazenados em uma matriz são 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 Laço Elementos da Matriz
Quando se referencia muitos elementos de uma matriz, especificar números para cada elemento da matriz individualmente pode ser demorado e tedioso. Como uma alternativa, os programas podem usar uma variável para referenciar os elementos da matriz. Por exemplo, assumindo que a variável i contenha o valor 2, o comando a seguir atribuiria o valor 80 a matriz[2]:
i = 2; matriz[i] = 80; |
O código a seguir usa a variável i e um laço for para exibir os elementos da matriz notas:
#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, é necessário especificar o tamanho da matriz. Por exemplo, o programa a seguir declara uma matriz de cinco valores e depois usa um laço 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 necessário alterar o código anterior de tal forma que ele suporte 10 valores. Precisará alterar não somente a declaração da matriz, mas também o laço for. Quanto mais alterações 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 não somente usa a constante para declarar a matriz, mas também usa a constante como a condição final para o laço 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 necessário alterar o tamanho da matriz, poderá alterar o valor atribuído à constante TAM_MATRIZ para que o programa automaticamente atualize os laços que controlam a matriz como o tamanho da matriz.
6.8 – Passando uma Matriz a uma Função
Quando declara-se uma função que trabalha com um parâmetro matriz, precisa informar o compilador. Por exemplo, o seguinte programa usa a função exibe_matriz para exibir os valores em uma matriz. Como pode-se ver, o programa passa para a função tanto a matriz como o número de elementos que a matriz contém, 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 função recebe uma matriz como parâmetro, o programa não precisa especificar o tamanho da matriz na declaração do parâmetro. No caso da função exibe_valores, os colchetes após o nome da variável valor informam o compilador de que o parâmetro é uma matriz. Sabendo que o parâmetro é uma matriz, o compilador não se preocupa com o tamanho da matriz que o programa passa para a função.
6.9 – Revisitando as Matrizes Como Funções
No item anterior, foi visto que ao declarar o parâmetro formal para uma matriz, não é necessário declarar o tamanho da matriz. Em vez disso, pode-se especificar somente o abre e fecha colchetes. O programa a seguir passa três matrizes diferentes (de diferentes tamanhos) para a função 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 funções. Em muitos casos, as funções não especificaram o tamanho da string. Por exemplo, o comando a seguir usa a função strupr para converter uma string para maiúsculas:
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 funções 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, não tem um caracter finalizador equivalente. Portanto, você normalmente precisa passar para as funções que trabalham com matrizes o número de elementos que a matriz contém.
6.11 – Determinando Quantos Elementos Uma Matriz Pode Armazenar
Já foi visto anteriormente que, dependendo do tipo de uma matriz, a quantidade real de memória que uma matriz pode consumir diferirá. Se o ambiente de trabalho for o DOS, a quantidade de memória que as matrizes podem consumir dependerá do modelo de memória atual. Em geral, uma matriz não pode consumir mais do que 64Kb de espaço. O programa a seguir pode não passar na compilação porque as matrizes consomem muita memória:
void main(void) { char string[66000L]; /* 66,000 bytes */ int values[33000L]; /* 33,000 * 2 = 66,000 bytes */ float numbers[17000]; /* 17,000 * 4 = 68,000 bytes */ } |
6.12 – Compreendendo as Matrizes Multidimensionais
Como foi visto, uma matriz é uma variável que pode armazenar múltiplos 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 e multidimensionais. O melhor modo de visualizar uma matriz bidimensional é com uma tabela com linhas e colunas. Se uma matriz contém três dimensões, visualize-a como várias páginas, cada uma das quais contendo uma tabela bidimensional.
Por exemplo, ao declarar-se uma matriz bidimensional, o primeiro valor que for especificado informará o número de linhas, e o segundo valor, o número 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 após a declaração da matriz. O comando a seguir usa a mesma técnica 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 | 2 | 3 |
4 | 5 | 6 |
6.14 – Percorrendo em Um Laço Uma Matriz Bidimensional
Quando os programas trabalham com matrizes bidimensionais, normalmente usa-se duas variáveis para acessar elementos da matriz. O programa a seguir usa as variáveis linha e coluna 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 laços 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 próxima 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 variáveis chamadas linha e coluna. O programa a seguir usa as variáveis linha, coluna e tabela 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 Função
No item 5.8, foi visto que, ao passar matrizes para uma função, não será necessário especificar o número de elementos na matriz. Em matrizes bidimensionais, não será necessário especificar o número de linha na matriz, mas, sim, especificar o número de colunas. O programa a seguir usa a função exibe_2d_matriz para exibir o conteúdo de variáveis 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 Dimensão
Quando for necessário trabalhar com os elementos de uma matriz multidimensional, mas sem precisar acessar os elementos em suas posições de linha ou coluna, as funções poderão tratar a matriz multidimensional como se ela tivesse uma dimensão. 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 – Síntese do Módulo
É apresentado à seguir, uma síntese do que foi tratado em cada item deste módulo. Com esta síntese 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 explicação que uma matriz é uma estrutura de dados que pode armazenar múltiplos 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 memória suficiente para conter o número de valores especificado. A quantidade real de memória 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 Laço Elementos da Matriz: foi mostrado que quando se referencia muitos elementos de uma matriz, especificar números para cada elemento da matriz individualmente pode ser demorado e tedioso. Como uma alternativa, os programas podem usar uma variável 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 Função: é visto que programas passam para a função tanto a matriz como o número de elementos que a matriz contém.
· 6.9 – Revisitando as Matrizes Como Funções: . foi visto um programa que passa três matrizes diferentes (de diferentes tamanhos) para a função exibe_valores.
· 6.10 – Compreendendo Como as Matrizes de String Diferem: explica as principais diferenças 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 memória que as matrizes podem consumir dependerá do modelo de memória atual. Em geral, uma matriz não pode consumir mais do que 64Kb de espaço.
· 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 Laço Uma Matriz Bidimensional: foi mostrado um programa que usa as variáveis 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 variáveis linha, coluna e tabela para percorrer uma matriz tridimensional.
· 6.16 – Passando uma Matriz Bidimensional Para uma Função: foi visto que para passar matrizes bidimensionais para uma função, não será necessário especificar o número de linha na matriz, mas, sim, especificar o número de colunas.
· 6.17 – Tratando as Matrizes Multidimensionais Como Uma Dimensão: foi visto que quando for necessário trabalhar com os elementos de uma matriz multidimensional, mas sem precisar acessar os elementos em suas posições de linha ou coluna, as funções poderão tratar a matriz multidimensional como se ela tivesse uma dimensão.
