aplicado ao aprendizado de eletromagnetismo

EDUARD MONTGOMERY MEIRA COSTA, D.SC.
C
APLICADO AO APRENDIZADO
DE ELETROMAGNETISMO
©
!"#$%#!&'&#!!(%) *
+% % ,, -% .% /
0
% 1
+23%
%
414,
5,
5
6
78+
5* ,
/ , 923% % +
/
% :/9
% 23/
+23;,
)2 0
* <
!"#$%&' !
COSTA, Eduard Montgomery Meira.
C Aplicado ao Aprendizado de Eletromagnetismo
Rio de Janeiro: Editora Ciência Moderna Ltda., 2012.
1. Magnetismo e Eletromagnetismo. 2. Linguagem de Programação.
I — Título
ISBN: 978-85-399-0294-1
CDD 538
005.133
)$+
+ ,-./0
1,1/234+5647864
#938:33487...3; <938:33487.=5.
7!$$>$+%+2 ???+$+%+24=;83
À minha família.
Aos que buscam evoluir.
AGRADECIMENTOS
Ao Deus Criador e os Espíritos de Luz.
À minha esposa e filhos.
"O maior presente que Deus nos dá é a consciência.
Cada um tem o livre arbítrio de fazer
deste presente o que desejar."
Eduard Montgomery Meira Costa
PREFÁCIO
A necessidade de aprender a programar se amplia a cada dia, com a
evolução digital. A aplicação da programação em todas as áreas, especialmente na engenharia, é essencial, para converter problemas em uma
linguagem computacional, o que facilita o aprendizado com a tradução
dos problemas em algoritmos e códigos de programas, além de se obter
uma ferramenta que realiza os cálculos necessários que são muito trabalhosos quando realizados via calculadoras.
É de notório saber que programar facilita o aprendizado, especialmente
de áreas técnicas, pois a tradução passo a passo dos problemas em um
código sintetiza a consolidação da teoria. Dessa forma, conhecer a
programação em uma linguagem como C, que é uma linguagem universal
é de grande importância, e saber aplicá-la aos estudos cotidianos, rende
duplo ganho.
Este livro é dedicado a leitores curiosos que interessam em aprofundar
seus estudos, tanto na área básica de computação, como a estudantes de
engenharia e computação que desejam consolidar seus conhecimentos na
área de eletromagnetismo, desenvolver ferramentas para solucionar seus
problemas e aprender a aplicar a linguagem C para desenvolver seus
próprios softwares na solução de problemas que lhes convier.
Naturalmente, este livro é básico, dando uma visão direta de tópicos da
teoria de eletromagnetismo e aplicação direta da linguagem C a esses
problemas. Assim, é um livro para quem conhece um pouco da área de
eletromagnetismo (ou pretende conhecer ou se aprofundar) e para quem
já tem alguma base na programação. De toda forma, na bibliografia deste
livro são apresentados alguns títulos para dar bases ao conteúdo deste
livro, para quem ainda não tem muita segurança nessas áreas.
Deve-se ter em mente que na atualidade, a programação é uma das áreas
mais necessárias, necessitando que técnicos, graduandos e graduados nas
áreas de computação e engenharia conheçam e saibam aplicar as linguagens de programação aos problemas do cotidiano, para solucioná-los.
X
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
Como este livro é básico, os programas são feitos utilizando, muitas
vezes, formas primitivas, direcionando os estudantes a modificarem os
programas por meio dos exercícios propostos, de forma a melhorá-los,
ampliá-los e torná-los mais profissionais, consolidando seus conhecimentos na arte de programação aplicada e na teoria de eletromagnetismo.
Eduard Montgomery Meira Costa
D.Sc. Eng. Elétrica
SUMÁRIO
CAPÍTULO 1 - CARGAS ELÉTRICAS, LEI
DE
COULOMB E CAMPO ELÉTRICO ...... 1
1.1 Cargas Elétricas .................................................................................. 1
1.1.1 Entendendo o Programa CARGA.C ........................................ 8
1.2 Lei de Coulomb ................................................................................ 14
1.2.1 Entendendo o Programa COULOMB.C ................................ 19
1.3 Campo Elétrico ................................................................................. 22
1.3.1 Entendendo o Programa CAMPO.C ...................................... 34
1.4 Exercícios .......................................................................................... 44
CAPÍTULO 2 - LEI DE GAUSS, FLUXO ELÉTRICO E DENSIDADE DE FLUXO
ELÉTRICO ...................................................................................................... 45
2.1 Fluxo Elétrico, Densidade de Fluxo Elétrico e Lei de Gauss ...... 45
2.1.1 Entendendo o Programa Fluxo.C ........................................... 64
2.2 Divergente, Operador Nabla e Teorema da Divergência ............ 76
2.2.1 Entendendo o Programa DIV.C .............................................. 89
2.3 Exercícios .......................................................................................... 99
CAPÍTULO 3 - POTENCIAL E ENERGIA NO CAMPO ELÉTRICO ........................ 101
3.1 Trabalho de uma Carga em Movimento e Potencial Elétrico ...
3.1.1 Entendendo o Programa WV.C ...........................................
3.2 Gradiente do Potencial Elétrico ...................................................
3.2.1 Entendendo o Programa GRAD.C ......................................
3.3 Campos do Dipolo Elétrico ..........................................................
3.3.1 Entendendo o Programa DIPOLO.C ..................................
3.4 Energia no Campo Eletrostático ..................................................
3.4.1 Entendendo o Programa ENERGIA.C ...............................
3.5 Exercícios .......................................................................................
CAPÍTULO 4 - MATERIAIS ELÉTRICOS
E
101
106
110
118
125
130
133
137
140
PROPRIEDADES ............................... 143
4.1 Corrente, Densidade de Corrente e Continuidade da Corrente
4.1.1 Entendendo o Programa CORRENTES.C..........................
4.2 Condutores: Propriedades e Condições de Contorno ...............
4.2.1 Entendendo o Programa CONDUTOR.C ..........................
4.3 Semicondutores .............................................................................
143
151
156
163
167
XII
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
4.3.1 Entendendo o Programa SEMICOND.C ............................
4.4 Dielétricos: Propriedades e Condições de Contorno .................
4.4.1 Entendendo o Programa DIELETRICO.C .........................
4.5 Capacitância ...................................................................................
4.5.1 Entendendo o Programa CAPACITOR.C ...........................
4.6 Exercícios .......................................................................................
CAPÍTULO 5 - EQUAÇÕES
DE
POISSON
E
174
177
198
212
220
224
LAPLACE ....................................... 229
5.1 A Equação de Poisson e a Equação de Laplace ........................ 229
5.1.1 Entendendo o Programa LAPLACE.C ............................... 236
5.2 Exercícios ....................................................................................... 239
CAPÍTULO 6 - CAMPO MAGNÉTICO ............................................................. 241
6.1 A Lei de Biot-Savart e a Lei Circuital de Ampère .....................
6.1.1 Entendendo o Programa MAGNETICO.C .........................
6.2 Rotacional e Teorema de Stokes ..................................................
6.2.1 Entendendo o Programa ROT.C ..........................................
6.3 Fluxo Magnético e Densidade de Fluxo Magnético .................
6.3.1 Entendendo o Programa FLUXOB.C .................................
6.4 Potencial Escalar e Potencial Vetor Magnéticos .........................
6.4.1 Entendendo o Programa VM.C ...........................................
6.5 Exercícios .......................................................................................
241
247
252
264
268
274
276
283
287
CAPÍTULO 7 - FORÇA E ENERGIA NO CAMPO MAGNÉTICO ............................ 291
7.1 Forças nos Campos Magnéticos ..................................................
7.1.1 Entendendo o Programa FQB.C ..........................................
7.2 Torque nos Circuitos Fechados ....................................................
7.2.1 Entendendo o Programa TORQUE.C .................................
7.3 Energia nos Campos Magnéticos ................................................
7.3.1 Entendendo o Programa WB.C ...........................................
7.4 Indutâncias .....................................................................................
7.4.1 Entendendo o Programa INDUT.C .....................................
7.5 Exercícios .......................................................................................
291
304
311
315
319
321
324
331
335
CAPÍTULO 8 - MATERIAIS MAGNÉTICOS, PROPRIEDADES E CIRCUITOS
MAGNÉTICOS .............................................................................................. 337
8.1 Materiais Magnéticos ....................................................................
8.1.1 Entendendo o Programa CONTB.C....................................
8.2 Circuitos Magnéticos .....................................................................
8.2.1 Entendendo o Programa CIRCB.C .....................................
337
357
373
382
SUMÁRIO
8.3 Força e Energia Potencial em Circuitos Magnéticos .................
Considerações sobre Indutâncias com Núcleos
Ferromagnéticos ..............................................................
8.3.1 Entendendo o Programa FVB.C ..........................................
8.4 Exercícios .......................................................................................
XIII
386
388
391
394
CAPÍTULO 9 - EQUAÇÕES DE MAXWEEL E OS CAMPOS VARIANTES NO TEMPO
397
9.1 A Lei de Faraday ...........................................................................
9.1.1 Entendendo o Programa FARADAY.C ...............................
9.2 Corrente de Deslocamento ...........................................................
9.2.1 Entendendo o Programa DESLOC.C ..................................
9.3 Variações nos Campos Potenciais ................................................
9.3.1 Entendendo o Programa VARPOT.C ..................................
9.4 Exercícios .......................................................................................
397
405
407
422
435
442
447
CAPÍTULO 10 - ONDAS ELETROMAGNÉTICAS ............................................... 449
10.1 Ondas Eletromagnéticas ............................................................. 449
10.1.1 Entendendo o Programa ONDAS.C ................................. 462
10.2 Vetor de Poynting ........................................................................ 464
10.2.1 Entendendo o Programa POYNTING.C .......................... 469
10.3 Ondas Eletromagnéticas em Bons Condutores e Efeito Pelicular 470
10.3.1 Entendendo o Programa PELICULAR.C ......................... 479
10.4 Reflexão e Transmissão de Ondas Eletromagnéticas e Coeficiente de Onda Estacionária.................................................................. 482
10.4.1 Entendendo o Programa REFTRANS.C .......................... 495
10.5 Exercícios ..................................................................................... 498
CARGAS
CAPÍTULO 1
ELÉTRICAS, LEI DE COULOMB
E CAMPO ELÉTRICO
Neste capítulo são apresentados os conceitos de carga elétrica, Lei de
Coulomb e campo elétrico de várias distribuições de cargas. Para isto, uma
apresentação básica da teoria é realizada para o entendimento dos programas e com isto, o estudante conhecer como aprofundar a aplicação desta
linguagem de programação a estes conceitos, podendo assim, solucionar
problemas que envolvam estas leis e teoremas.
1.1 CARGAS ELÉTRICAS
O conceito de carga elétrica é uma propriedade física que determina
algumas das interações eletromagnéticas da matéria. As cargas elétricas
são concebidas em dois tipos: positivas e negativas. Todas as cargas
elétricas são baseadas na carga fundamental (ou carga elementar) que é o
elétron (negativa), tendo a carga elétrica positiva fundamental como sendo
o próton. O elétron tem como carga o valor de
e = - 1,6 x 10-19 C (Coulomb),
Todas as cargas são múltiplas desta carga elementar.
O elétron tem massa
me = 9,11 x 10-31 kg.
Quando várias cargas se encontram distribuídas em uma região,
denominam-se de densidades de cargas, relativas a estas distribuições, as
quais podem ser descritas como:
‹
Densidade linear de carga:
‹
Densidade superficial de carga:
L
[C/m];
S
[C/m2];
2
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
‹
[C/m3],
Densidade volumétrica de carga:
em que o valor total da carga é a soma de toda a carga distribuída,
respectivamente:
³ U L dL;
Q ³S U S dS ;
Q ³vol Udv.
Q
Se as cargas são distribuídas uniformemente na região ( L, S ou
constantes), tem-se Q= LL, Q= SS e Q= v, respectivamente. Caso
contrário, é necessário resolver as integrais em suas respectivas coordenadas:
Cartesianas:
Q
Q
³ U dx;
³³ U dxdy;
³³³ Udxdydz
L
S
Q
Q
Q
³ U dy;
³³ U dxdz;
³ U dz;
³³ U dydz; .
Q
L
L
Q
S
S
Cilíndricas:
Q
Q
Q
³ U dr;
L
³³ U rdrdI ;
³³³ UrdrdIdz
S
Q
Q
³ U rdI ;
³³ U rdIdz;
L
S
Q
Q
³ U dz;
³³ U drdz; .
L
S
Esféricas:
Q
Q
Q
³ U dr;
L
³³ U rsenTdrdI ;
³³³ Ur senTdrdIdT
S
2
Q
Q
³ U rsenTdI ;
³³ U rdrdT ;
Q
L
S
Q
³ U rdT ;
L
³³ U r senTdIdT ; .
2
S
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
3
Naturalmente, para se determinar o valor total de uma carga em uma
distribuição qualquer, calcula-se a integral conforme definida em seus
limites determinados.
O cálculo de uma integral de uma variável (as três primeiras em cada
descrição de coordenadas citada) pode ser realizado computacionalmente
entre os limites de uma simples, dividindo-se o total da diferença entre os
limites em um passo definido pequeno, em que se multiplica a função no
ponto inicial por este valor do passo, somando-se ao novo valor da função
no ponto posterior (ponto inicial somado do passo) multiplicado pelo valor
do passo, repetindo-se até o último ponto anterior ao final. Dessa forma,
calcula-se uma integral de uma única variável. Essa forma pode ser vista
na Figura 1.1.
Figura 1.1: Divisão de uma curva qualquer em passos de largura x = f(x1) – f(x0)
para o cálculo de uma integral de uma única variável. Quanto menor o valor do
passo x, mais correto o valor da integral que é a área sob a curva.
Para o cálculo de uma integral de duas variáveis (as três segundas de
cada descrição dada nas respectivas coordenadas), realiza-se o mesmo
procedimento anterior (integral de uma variável), mas gerando dois laços:
um para cada variável. Assim, determinam-se dois passos (um para cada
variável) através da divisão do total entre os limites, multiplica-se o valor
da função por um passo de uma das variáveis, mantendo-se a outra
variável no ponto fixo, realizando-se o procedimento da integral de uma
variável. Depois, incrementa-se o passo da segunda variável e repete-se o
procedimento para a primeira variável, somando-se os resultados. Repete
se este procedimento até que a segunda variável atinja o limite superior.
Este procedimento pode ser visto na Figura 1.2.
4
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
Figura 1.2: Divisão de uma superfície qualquer em quadrados de área x y para
o cálculo de uma integral de duas variáveis: quanto menor o passo mais próximo
o valor da área calculada com o valor real.
Para o cálculo da integral tripla, o mesmo procedimento é realizado,
incluindo-se a terceira variável. Pode-se ver a divisão de um volume como
pequenos cubos de volumes definidos, cuja soma total dos pequenos
volumes determina o valor numérico da integral tripla de forma
computacional. Observe que o preenchimento de um vaso com pequenas
caixas cúbicas apresenta muitos vazios e a soma do total dos volumes das
pequenas caixas determina um erro grande em relação ao volume real do
vaso (o passo é grande), enquanto o preenchimento com grãos de areia
(sabendo quantos grãos e qual o volume de cada grão de areia) determina
com mais certeza o volume do vaso (quando os passos em x, y e z tendem
a zero, o valor numérico tende ao valor da integral corretamente). Deve
se observar que, em ambos os casos, o valor numérico é tão mais próximo
do valor real, quanto menor for o valor do passo, o que determina também,
maior tempo no processamento do resultado.
Considerando essas informações, a seguir é apresentado um programa
que calcula o valor de uma carga distribuída em coordenadas cartesianas,
de acordo com funções pré-definidas ou quando é uniformemente distribuída. Neste caso, sempre que se deseja calcular uma carga com uma
distribuição não uniforme, deve-se colocar as funções destas distribuições
nas linhas de comandos #define no início do programa.
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
5
————————————
Programa CARGA.C
————————————
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define funcao1var 2*cont1*cont1+3*cont1+1
#define funcao2var 3*cont1*cont2+3*cont1+2*cont2
#define funcao3var cont1*cont3+2*cont2-cont1+cont3*cont2
int item, dados = 0;;
char tipo_q[2], equ[2];
double delta = 1e-2, carga = 0, val_carga = 0, coord1inf = 0,
coord1sup = 0, coord2inf = 0, coord2sup = 0, coord3inf = 0,
coord3sup = 0;
void menu (void);
void dadosin (void);
void ccarga(void);
void main(){
clrscr();
do{
menu();
switch(item){
case 1:
dadosin();
break;
case 2:
if (!dados){
printf(“\nNão houve entrada de dados!\n”);
printf(“Pressione uma tecla!”);
while(!kbhit());
}
else{
ccarga();
printf(“\nCarga total na região definida: %lf
C\n”, carga);
printf(“Pressione uma tecla!”);
while(!kbhit());
}
break;
6
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
case 0:
break;
}
}while (item != 0);
}
void menu(void){
do{
clrscr();
printf(“\n(0) - Sai”);
printf(“\n(1) - Entrada de dados”);
printf(“\n(2) - Calcular carga total\n\n->”);
scanf(“%d”, &item);
if((item > 2) || (item < 0)){
printf(“Inválido! Pressione uma tecla!”);
while(!kbhit());
}
}while((item < 0) || (item > 2));
}
void dadosin(void){
clrscr();
printf(“\nEntre com o valor da carga (ou qualquer número se
depender das funções definidas): “);
scanf(“%lf”, &val_carga);
equ[1] = ‘\0’;
do{
printf(“\nÉ uma carga distribuída uniformemente? (s/n)”);
scanf(“%s”, &equ);
}while ((equ[0] != ‘s’) && (equ[0] != ‘n’));
do{
printf(“\nÉ uma carga distribuída (l)inearmente,
(s)uperficialmente ou (v)olumetricamente?: “);
scanf(“%s”, &tipo_q);
}while ((tipo_q[0] != ‘l’) && (tipo_q[0] != ‘s’) &&
(tipo_q[0] != ‘v’));
clrscr();
printf(“\nEntre com os limites da primeira coordenada (inferior
/superior) separados por espaço: “);
scanf(“%lf”, &coord1inf);
scanf(“%lf”, &coord1sup);
if(tipo_q[0] != ‘l’){
printf(“\nEntre com os limites da segunda coordenada
(inferior/superior) separados por espaço: “);
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
scanf(“%lf”, &coord2inf);
scanf(“%lf”, &coord2sup);
}
if(tipo_q[0] == ‘v’){
printf(“\nEntre com os limites da terceira coordenada
(inferior/superior) separados por espaço: “);
scanf(“%lf”, &coord3inf);
scanf(“%lf”, &coord3sup);
}
printf(“\nOs valores de delta são definidos como 1e-2.
Digite seu novo valor: “);
scanf(“%f”, &delta);
printf(“\nDados completos! Pressione uma tecla...”);
while(!kbhit());
dados = 1;
}
void ccarga(void){
double cont1 = coord1inf, cont2 = coord2inf, cont3 =
coord3inf, func1, func2, func3, total, cont;
if(tipo_q[0] == ‘l’) total = (coord1sup - coord1inf)/delta;
else if(tipo_q[0] == ‘s’) total = (coord1sup coord1inf)*(coord2sup - coord2inf)/(delta*delta);
else if(tipo_q[0] == ‘v’) total = (coord1sup coord1inf)*(coord2sup - coord2inf)*(coord3sup coord3inf)/(delta*delta*delta);
if (equ[0] == ‘s’){
carga = val_carga *(coord1sup - coord1inf);
if (tipo_q[0] != ‘l’)
carga = carga *(coord2sup - coord2inf);
if (tipo_q[0] == ‘v’)
carga = carga *(coord3sup - coord3inf);
}
else{
carga = 0;
cont = 0;
do{
if (tipo_q[0] == ‘l’) {
func1 = funcao1var;
carga = carga + func1*delta;
}
else if (tipo_q[0] == ‘s’) {
func2 = funcao2var;
carga = carga + func2*delta*delta;
}
7
8
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
else if (tipo_q[0] == ‘v’) {
func3 = funcao3var;
carga = carga + func3*delta*delta*delta;
}
cont1+=delta;
if(cont1 >= coord1sup){
cont1 = coord1inf;
if ((tipo_q[0] != ‘l’)&&(cont1 < coord1sup)){
cont2+=delta;
if(cont2 >= coord2sup){
cont2 = coord2inf;
if ((tipo_q[0] == ‘v’)&&(cont2 < coord2sup))
cont3+=delta;
}
}
}
cont+=1;
}while(cont < total);
}
}
1.1.1 Entendendo o Programa CARGA.C
Este programa cria um menu básico em que se pode entrar com os dados
e também calcular o valor de uma carga em coordenadas cartesianas tanto
na condição de uma carga uniformemente distribuída, como uma carga
distribuída de acordo com equações pré-definidas: distribuição linear,
distribuição superficial e distribuição volumétrica.
Como todo programa, a inclusão das bibliotecas é necessária, que neste
caso, são as de trabalho com strings e matemática.
#include <stdio.h>
#include <conio.h>
#include <math.h>
Com essa inclusão, entram-se as definições das constantes com as
funções de uma variável, duas variáveis e três variáveis, respectivamente,
as quais são utilizadas caso o usuário deseje calcular uma carga distribuída
linearmente, superficialmente ou volumetricamente. Estas funções definidas podem ser modificadas para que o programa calcule cargas totais
distribuídas de outras formas, que não estas funções.
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
9
#define funcao1var 2*cont1*cont1+3*cont1+1
#define funcao2var 3*cont1*cont2+3*cont1+2*cont2
#define funcao3var cont1*cont3+2*cont2-cont1+cont3*cont2
No caso destas funções pré-definidas, essas expressam as equações:
2 x 2 3x 1
3xy 3 x 2 y
xz 2 y x zy
considerando que x = cont1; y = cont2 e z = cont3.
As variáveis definidas como tipo int são utilizadas como controle de
fluxo do programa, na escolha de itens do menu e na verificação de entrada
de dados. As variáveis do tipo char são utilizadas para controle de fluxo
da entrada de dados e cálculo dos valores finais da carga. As variáveis tipo
double são as definidas para valor de passo, cálculo da carga e limites
inferior e superior das coordenadas.
Para o programa ser bem organizado, três funções são definidas, que são:
void menu (void);
void dadosin (void);
void ccarga(void);
as quais abrem o menu, entra com os dados e calcula a carga total,
respectivamente.
A função main é utilizada para limpar a tela, chamar a função menu,
processar os dados do programa e sair do programa. No processamento
dos dados após a escolha de um item do menu, o comando switch...case
avalia e direciona o programa para entrar os dados:
case 1:
dadosin();
break;
para apresentar os resultados, caso os dados já tenham sido inseridos (valor
da variável dados igual a 1), através da chamada à função ccarga:
10
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
case 2:
if (!dados){
printf(“\nNão houve entrada de dados!\n”);
printf(“Pressione uma tecla!”);
while(!kbhit());
}
else{
ccarga();
printf(“\nCarga total na região definida: %lf C\n”,
carga);
printf(“Pressione uma tecla!”);
while(!kbhit());
}
break;
e fechar o programa:
case 0:
break;
}
Este procedimento é repetido até que o usuário digite o valor 0 (zero)
no menu, desde que o switch...case está dentro de um laço do...while.
A função menu apresenta na tela os itens a serem escolhidos, e
solicita que o usuário digite um deles. Caso o usuário digite um valor
invalido, é apresentada a mensagem “Inválido! Pressione uma tecla!” e a
tela é limpa após esse pressionamento, reapresentando o menu.
void menu(void){
do{
clrscr();
printf(“\n(0) - Sai”);
printf(“\n(1) - Entrada de dados”);
printf(“\n(2) - Calcular carga total\n\n->”);
scanf(“%d”, &item);
if((item > 2) || (item < 0)){
printf(“Inválido! Pressione uma tecla!”);
while(!kbhit());
}
}while((item < 0) || (item > 2));
}
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
11
A função dadosin solicita a entrada dos dados, em que na primeira
pergunta, o usuário deve entrar com o valor da carga distribuída, caso ela
seja uniforme. Se a carga estiver distribuída de modo não uniforme,
qualquer valor numérico pode ser colocado, como por exemplo, 0 (zero).
printf(“\nEntre com o valor da carga (ou qualquer número se
depender das funções definidas): “);
scanf(“%lf”, &val_carga);
Essa condição é realizada na segunda pergunta do programa, que
determina o valor da variável equ, a qual é utilizada no calculo da carga
na função ccarga, de acordo com seu valor. Como está dentro de um laço
do...while, o programa repete a pergunta até que seja digitado um ‘s’ ou
um ‘n’.
do{
printf(“\nÉ uma carga distribuída uniformemente? (s/n)”);
scanf(“%s”, &equ);
}while ((equ[0] != ‘s’) && (equ[0] != ‘n’));
Da mesma forma, a terceira pergunta se procede, de modo que o usuário
pode digitar as letras ‘l’, ‘s’ ou ‘v’, que representam, respectivamente, a
distribuição das cargas de forma linear, superficial ou volumétrica.
do{
printf(“\nÉ uma carga distribuída (l)inearmente,
(s)uperficialmente ou (v)olumetricamente?: “);
scanf(“%s”, &tipo_q);
}while ((tipo_q[0] != ‘l’) && (tipo_q[0] != ‘s’) &&
(tipo_q[0] != ‘v’));
Após essa entrada, o programa limpa a tela via função clrscr() e solicita
os limites inferior e superior das coordenadas, de acordo com o tipo de
distribuição definida:
printf(“\nEntre com os limites da primeira coordenada
(inferior/superior) separados por espaço: “);
scanf(“%lf”, &coord1inf);
scanf(“%lf”, &coord1sup);
if(tipo_q[0] != ‘l’){
12
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
printf(“\nEntre com os limites da segunda coordenada
(inferior/superior) separados por espaço: “);
scanf(“%lf”, &coord2inf);
scanf(“%lf”, &coord2sup);
}
if(tipo_q[0] == ‘v’){
printf(“\nEntre com os limites da terceira coordenada
(inferior/superior) separados por espaço: “);
scanf(“%lf”, &coord3inf);
scanf(“%lf”, &coord3sup);
}
Finalmente, o programa pede um novo valor para a variável delta
(passo de integração) e aguarda que o usuário pressione uma tecla para
voltar ao menu, dando o valor 1 à variável de controle dados.
printf(“\nOs valores de delta são definidos como 1e-2.
Digite seu novo valor: “);
scanf(“%f”, &delta);
printf(“\nDados completos! Pressione uma tecla...”);
while(!kbhit());
dados = 1;
Na função ccarga, a carga é calculada de acordo com os dados que
foram inseridos. As variáveis locais cont1, cont2 e cont3 recebem os
valores dos limites inferiores das coordenadas, para começar o procedimento de cálculo. Observe que essas variáveis são definidas com os
mesmos nomes das variáveis dentro das funções constantes nas definições
no início do programa. As demais variáveis locais são criadas para receber
os valores das funções em cada ponto (a cada passo) e controle do laço.
double cont1 = coord1inf, cont2 = coord2inf, cont3 =
coord3inf, func1, func2, func3, total, cont;
Conforme definida a distribuição da carga, os comandos condicionais
calculam primeiramente o número total de passos a serem utilizados para
o cálculo da integral da carga, caso ela não seja distribuída uniformemente:
if(tipo_q[0] == ‘l’) total = (coord1sup - coord1inf)/delta;
else if(tipo_q[0] == ‘s’) total = (coord1sup coord1inf)*(coord2sup - coord2inf)/(delta*delta);
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
13
else if(tipo_q[0] == ‘v’) total = (coord1sup coord1inf)*(coord2sup - coord2inf)*(coord3sup coord3inf)/(delta*delta*delta);
Caso a carga seja distribuída uniformemente, é calculado o valor da
carga através da multiplicação direta do valor da carga multiplicado pelo
comprimento da linha (caso seja uma distribuição linear), pela área (caso
seja superficial) ou pelo volume (caso seja volumétrica):
if (equ[0] == ‘s’){
carga = val_carga *(coord1sup - coord1inf);
if (tipo_q[0] != ‘l’)
carga = carga *(coord2sup - coord2inf);
if (tipo_q[0] == ‘v’)
carga = carga *(coord3sup - coord3inf);
}
Se a carga não é distribuída de modo não uniforme, é calculado o valor
aproximado da integral de acordo com o passo definido (variável delta)
através das linhas de código:
else{
carga = 0;
cont = 0;
do{
if (tipo_q[0] == ‘l’) {
func1 = funcao1var;
carga = carga + func1*delta;
}
else if (tipo_q[0] == ‘s’) {
func2 = funcao2var;
carga = carga + func2*delta*delta;
}
else if (tipo_q[0] == ‘v’) {
func3 = funcao3var;
carga = carga + func3*delta*delta*delta;
}
O controle do laço é realizado com a variação de cada uma das variáveis
que são somadas passo a passo. Primeiro a primeira coordenada é somada
até alcançar o limite superior. Quando atinge esse valor, essa volta ao valor
do limite inferior e incrementa de delta a segunda coordenada. Repete-se
14
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
isso, até que a segunda coordenada atinja o limite superior, quando a
terceira coordenada é incrementada, e assim por diante. Naturalmente,
como a carga pode não estar definida como superficial ou volumétrica,
esses comandos condicionais testam a variável tipo_q, para verificar se
pode incrementar a segunda ou terceira coordenadas.
cont1+=delta;
if(cont1 >= coord1sup){
cont1 = coord1inf;
if ((tipo_q[0] != ‘l’)&&(cont1 < coord1sup)){
cont2+=delta;
if(cont2 >= coord2sup){
cont2 = coord2inf;
if ((tipo_q[0] == ‘v’)&&(cont2 < coord2sup))
cont3+=delta;
}
}
}
Por fim, o programa incrementa a variável cont e verifica se ela atingiu
o valor total de passos definidos para o cálculo da integral.
cont+=1;
}while(cont < total);
1.2 LEI DE COULOMB
A lei de Coulomb determina a força existente entre cargas elétricas. Esta
força pode ser de atração (quando as cargas envolvidas são de mesmo
sinal) ou de repulsão (quando as cargas apresentam sinais contrários). Seu
valor é um vetor dirigido de uma carga para outra, podendo ser a
componente resultante da interação entre várias forças geradas por várias
cargas sobre uma outra carga.
A lei de Coulomb determina que o módulo da força entre duas cargas
Q1 e Q2 é:
F
Q1Q2
4SH 0 R 2
[N]
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
15
em que R é a distância entre as cargas e
H0
8,854 u 10 12 F / m #
1
u 10 9 F / m
36S
é a permissividade do espaço livre, cuja unidade é o Farad/metro (F/m).
Em termos vetoriais, a força que uma carga Q1 exerce sobre outra carga
Q2 é:
F12
Q1Q2
2
4SH 0 R12
a R12
em que a direção da força é dada pelo vetor unitário (ou versor)
a R12
R12
R12
( x2 x1 )a x ( y2 y1 )a y ( z 2 z1 )a z
( x2 x1 ) 2 ( y2 y1 ) 2 ( z 2 z1 ) 2
com os versores a x , a y e a z sendo os versores que dão as direções dos
eixos coordenados x, y e z, respectivamente. O exemplo desta força, para
o caso de duas cargas de mesmo sinal, pode ser visto na Figura 1.3.
Figura 1.3: Forças de Coulomb entre duas cargas elétricas.
16
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
A força resultante que várias cargas Q1, Q2, ..., Qn, exercem sobre uma
carga Q, é definida pelo somatório vetorial das forças:
FR
n
Q
i 1
4SH 0
¦ Fi
n
¦
Qi
2
i 1 RiQ
a RiQ .
Uma força de Coulomb resultante de três cargas sobre uma carga Q
pode ser vista na Figura 1.4.
Figura 1.4: Força resultante sobre a carga Q devido a três cargas próximas.
Considerando essas informações, a seguir é apresentado um programa
que calcula o valor da força exercida sobre uma carga Q provinda de uma
carga ou conjunto de cargas, apresentando seu resultado tanto em magnitude, como na forma vetorial.
————————————
Programa COULOMB.C
————————————
#include <stdio.h>
#include <conio.h>
#include <math.h>
int item, dados = 0, totalq;
float coordsq[30][3], coordsQ[3];
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
17
double carga[30], Q, Fr, Fvr[3], fvr[30][3], fr[30];
void menu (void);
void dadosin (void);
void cforca(void);
void main(){
int k;
clrscr();
do{
menu();
switch(item){
case 1:
dadosin();
break;
case 2:
if (!dados){
printf(“\nNão houve entrada de dados!\n”);
printf(“Pressione uma tecla!”);
while(!kbhit());
}
else{
cforca();
printf(“\nForças sobre a carga Q por carga:\n”);
for(k = 0; k < totalq; k++)
printf(“Carga q(%d): Fvet = %eax + (%e)ay +
(%e)az [N]; Fmod = %e[N]\n”, k, fvr[k][0],
fvr[k][1], fvr[k][2], fr[k]);
printf(“\nForça total sobre a carga Q:\n”);
printf(“Frvet = %eax + (%e)ay + (%e)az [N];
Frmod = %e[N]\n”, Fvr[0], Fvr[1], Fvr[2], Fr);
printf(“Pressione uma tecla!”);
while(!kbhit());
}
break;
case 0:
break;
}
}while (item != 0);
}
void menu(void){
do{
clrscr();
printf(“\n(0) - Sai”);
printf(“\n(1) - Entrada de dados”);
18
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
printf(“\n(2) - Calcular forças\n\n->”);
scanf(“%d”, &item);
if((item > 2) || (item < 0)){
printf(“Inválido! Pressione uma tecla!”);
while(!kbhit());
}
}while((item < 0) || (item > 2));
}
void dadosin(void){
int x;
clrscr();
printf(“\nEntre com o valor da carga de teste Q: “);
scanf(“%lf”, &Q);
printf(“\nEntre com a localização da carga Q (x, y, z sepa
radas por espaços):”);
for(x = 0; x < 3; x++)
scanf(“%f”, &coordsQ[x]);
printf(“Quantas cargas agem sobre a carga Q = %e? “, Q);
scanf(“%d”, &totalq);
x = 0;
do{
printf(“\nEntre com o valor da carga q(%d):”, x+1);
scanf(“%lf”, &carga[x]);
printf(“\nEntre com a localização da carga q(%d) (x, y, z
separadas por espaços):”, x+1);
scanf(“%f”, &coordsq[x][0]);
scanf(“%f”, &coordsq[x][1]);
scanf(“%f”, &coordsq[x][2]);
x++;
}while (x < totalq);
printf(“\nDados completos! Pressione uma tecla...”);
while(!kbhit());
dados = 1;
}
void cforca(void){
int cont = 0;
float r;
do{
r = sqrt(pow(coordsQ[0] - coordsq[cont][0],2) +
pow(coordsQ[1] - coordsq[cont][1],2) + pow(coordsQ[2] coordsq[cont][2],2));
fvr[cont][0] = 9e9*carga[cont]*Q*(coordsQ[0]coordsq[cont][0])/pow(r,3);
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
19
fvr[cont][1] = 9e9*carga[cont]*Q*(coordsQ[1]coordsq[cont][1])/pow(r,3);
fvr[cont][2] = 9e9*carga[cont]*Q*(coordsQ[2]coordsq[cont][2])/pow(r,3);
fr[cont]=sqrt(pow(fvr[cont][0],2) + pow(fvr[cont][1],2) +
pow(fvr[cont][2],2));
cont++;
}while(cont < totalq);
cont = 0;
Fvr[0] = 0;
Fvr[1] = 0;
Fvr[2] = 0;
do{
Fvr[0]+= fvr[cont][0];
Fvr[1]+= fvr[cont][1];
Fvr[2]+= fvr[cont][2];
cont++;
}while(cont < totalq);
Fr = sqrt(pow(Fvr[0],2) + pow(Fvr[1],2) + pow(Fvr[2],2));
}
1.2.1 Entendendo o Programa COULOMB.C
Da mesma forma que o programa CARGA.C, este programa gera um
menu principal, onde se determina se deseja entrar com dados, calcular as
forças ou sair do programa. O cálculo das forças determina a força vetorial
e sua magnitude para cada carga atuando sobre uma carga de teste Q, e
também a força total resultante gerada por todas as cargas em conjunto
sobre esta carga de teste Q, na forma vetorial e sua magnitude, as quais são
apresentadas ao ser chamada a função cforca() no menu principal.
Como todo programa, são incluídas as bibliotecas das funções utilizadas. Neste caso, são as mesmas do programa CARGA.C.
#include <stdio.h>
#include <conio.h>
#include <math.h>
As variáveis globais deste programa são as inteiras (tipo int) que
definem o fluxo dos dados no menu e o número total de cargas que
exercem força sobre a carga de teste Q, que é a variável totalq; tipo float
tem as variáveis coordsq e coordsQ, que guardam as posições x, y e z de
20
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
cada carga q e da carga de teste Q e, tipo double encontram-se as variáveis
carga, responsável por guardar os valores das cargas q podendo ter até
trinta cargas, Q que guarda o valor da carga de teste Q, Fr responsável por
guardar o valor da magnitude da força resultante de todas as cargas q sobre
a carga Q, Fvr que guarda o valor vetorial da roça resultante de todas as
cargas q sobre a carga Q, fvr que guarda o valor vetorial de cada carga q
sobre a carga Q e fr que guarda o valor da magnitude de cada carga q sobre
a carga Q.
Os protótipos das funções são: menu (responsável pela apresentação do
menu e direcionamento do fluxo de informações do programa), dadosin
(responsável pela entrada de dados) e cforca (responsável pelo cálculo das
forças individuais das cargas e da resultante final, tanto na forma vetorial
como a magnitude destas).
A função main, trabalha da mesma forma que no programa CARGA.C,
chamando o menu, direcionando o programa para receber os dados,
apresentando os resultados e saindo do programa. Neste caso, a apresentação dos resultados, quando há entrada de dados, o programa apresenta
para cada carga a força vetorial exercida sobre a carga de teste Q,
juntamente com sua magnitude, e a força resultante vetorial de todas as
cargas sobre a carga de teste Q juntamente com sua magnitude.
cforca();
printf(“\nForças sobre a carga Q por carga:\n”);
for(k = 0; k < totalq; k++)
printf(“Carga q(%d): Fvet = %eax + (%e)ay + (%e)az [N];
Fmod = %e[N]\n”, k, fvr[k][0], fvr[k][1], fvr[k][2], fr[k]);
printf(“\nForça total sobre a carga Q:\n”);
printf(“Frvet = %eax + (%e)ay + (%e)az [N]; Frmod =
%e[N]\n”, Fvr[0], Fvr[1], Fvr[2], Fr);
printf(“Pressione uma tecla!”);
while(!kbhit());
}
break;
A função menu tem o mesmo procedimento do programa CARGA.C.
No caso da função dadosin, a variável local x, tipo int, é utilizada como
contador. Nesta função, são solicitados os dados:
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
21
1) Carga de teste Q e sua localização nos eixos x, y e z, respectivamente:
printf(“\nEntre com o valor da carga de teste Q: “);
scanf(“%lf”, &Q);
printf(“\nEntre com a localização da carga Q (x, y, z sepa
radas por espaços):”);
for(x = 0; x < 3; x++)
scanf(“%f”, &coordsQ[x]);
2) Número total de cargas q que agem sobre a carga de teste Q:
printf(“Quantas cargas agem sobre a carga Q = %e? “, Q);
scanf(“%d”, &totalq);
3) Valor das cargas q e suas respectivas localizações nos eixos x, y e
z, respectivamente:
x = 0;
do{
printf(“\nEntre com o valor da carga q(%d):”, x+1);
scanf(“%lf”, &carga[x]);
printf(“\nEntre com a localização da carga q(%d) (x, y, z
separadas por espaços):”, x+1);
scanf(“%f”, &coordsq[x][0]);
scanf(“%f”, &coordsq[x][1]);
scanf(“%f”, &coordsq[x][2]);
x++;
}while (x < totalq);
Para a função cforca, é declarada a variável local cont, tipo int, utilizada
como contador, e a variável local r, tipo float, responsável pelo calculo da
distància entre cada carga q e a carga Q.
Realizada a declaração das variáveis, um laço do...while calcula a
distância entre cada carga q da carga de teste Q, e calcula a força gerada
por q em Q em cada uma das componentes x, y e z, calculando por fim a
magnitude resultante destas, até a última carga.
do{
r = sqrt(pow(coordsQ[0] - coordsq[cont][0],2) +
pow(coordsQ[1] - coordsq[cont][1],2) + pow(coordsQ[2] coordsq[cont][2],2));
22
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
fvr[cont][0] = 9e9*carga[cont]*Q*(coordsQ[0]coordsq[cont][0])/pow(r,3);
fvr[cont][1] = 9e9*carga[cont]*Q*(coordsQ[1]coordsq[cont][1])/pow(r,3);
fvr[cont][2] = 9e9*carga[cont]*Q*(coordsQ[2]coordsq[cont][2])/pow(r,3);
fr[cont]=sqrt(pow(fvr[cont][0],2) + pow(fvr[cont][1],2) +
pow(fvr[cont][2],2));
cont++;
}while(cont < totalq);
Tendo calculado as forças de cada uma das cargas separadamente, o
programa zera a variável Fvr:
cont =
Fvr[0]
Fvr[1]
Fvr[2]
0;
= 0;
= 0;
= 0;
e gera um laço para calcular a resultante vetorial das forces exercidas sobre
Q:
do{
Fvr[0]+= fvr[cont][0];
Fvr[1]+= fvr[cont][1];
Fvr[2]+= fvr[cont][2];
cont++;
}while(cont < totalq);
finalizando com o cálculo da magnitude da força resultante, na declaração:
Fr = sqrt(pow(Fvr[0],2) + pow(Fvr[1],2) + pow(Fvr[2],2));
1.3 CAMPO ELÉTRICO
Em se tratando de forças elétricas, vê-se que onde há uma carga, em
qualquer ponto do espaço ao seu redor em que for colocada outra carga,
uma força de repulsão (se as cargas forem de sinais iguais) ou de atração
(se as cargas forem de sinais contrários) surgirá. Isso sugere a existência
de um campo de forças gerado pela carga, o qual é denominado de campo
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
23
elétrico. Este campo elétrico é um campo vetorial, e tem sempre a direção
perpendicular à carga.
Tomando uma carga q (denominada de carga de teste) em que se pode
variar a sua posição, e uma carga fixa Q que se deseja calcular o valor do
campo na posição da carga q, define-se o campo elétrico da carga Q por:
E
F
,
q
cuja equação determina a eliminação da carga de teste para calcular o
campo da carga Q no ponto em que a carga q se encontra. A unidade do
campo elétrico é [N/C] (Newton/Coulomb), ou mais conhecida como [V/
m] (Volt/metro).
Assim, o campo de uma carga pontual é definido como sendo:
E
Q
4SH 0 r 2
ar ,
considerando que a carga está na origem do sistema de coordenadas, em
que se referencia a direção do campo na direção do raio (em coordenadas
esféricas, desde que para qualquer ponto que se deseja calcular o valor
deste campo, em relação à origem é o próprio valor de um raio esférico).
Por outro lado, se a carga que gera o campo não está na origem do sistema
de coordenadas, tem-se:
E
Q
4SH 0 R 2
aR
em que o R é a distância entre o ponto a ser medido o campo, e a posição
em que se encontra a carga que o gera:
R
( x2 x1 )a x ( y2 y1 )a y ( z2 z1 )a z
com R sendo seu módulo. Este campo pode ser visto na Figura 1.5.
24
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
Figura 1.5: Campo elétrico de uma carga pontual ou esférica.
Considerando que uma carga é distribuída em uma linha L (por
exemplo, no eixo z), pode-se ver esta carga como uma infinita quantidade
de cargas pontuais dQ sobrepostas, o que dá pela lei de Coulomb para cada
uma das cargas sobrepostas, um elemento diferencial de força:
dF
qdQ
4SH 0 R 2
aR
que, juntando todas as contribuições para calcular a força total tem-se:
F
f
³ f d F
f
³ f
qU L dz
4SH 0 R 2
desde que a carga dQ =
R
aR
L
dz. Dessa forma, como
( x2 x1 )a x ( y2 y1 )a y ( z2 z1 )a z
r ar z a z ,
e a linha de carga se encontrar no eixo z (o que indica que os valores de
x1 e y1 são zero) isso que faz com que, para a distância R fixa, o giro de
2 no plano xy desenhe um círculo de raio cilíndrico r. Também, o valor
de z1 pode ser considerado zero (plano xy) devido à simetria da carga
(inicia no - e finaliza no + ). Assim, retirando a carga de teste q, tem-se:
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
25
que é completamente radial cilíndrica e perpendicular à linha. Este pode
ser visto na Figura 1.6.
Figura 1.6: Campo elétrico de uma linha de carga
ou de uma carga distribuída em um cilindro: radial cilíndrico.
Considerando que a linha de carga seja finita, o campo só será visto
desta forma numa distância em que haja simetria (ponto central). Caso
contrário, o resultado terá direções em r e z, quando se mudam os limites
de integração, o que se pode verificar na equação do campo.
26
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
Utilizando este resultado e juntando uma quantidade infinita de linhas de
cargas paralelas formando uma superfície plana, encontra-se o resultado
para uma superfície com cargas distribuídas S. Assim, tem-se que,
considerando uma superfície de cargas no plano xz, uma porção desta
superfície que forma uma linha (um elemento S com largura dx) tem o
valor L =
dx. E consequentemente, pelo resultado do campo elétrico
S
para uma linha de cargas, encontra-se:
E
U L aR
f
³ d E ³ f 2SH R dx
0
U S f xax y a y
dx
³
2SH 0 f x 2 y 2
US ª 1
§ y·
2
2
« ln x y a x arctan¨ ¸a y
2SH 0 ¬« 2
©x¹
f
f
US
S ay
2SH 0
US
ay
2H 0
o que pode ser estendido de uma forma geral, como:
E
US
an
2H 0
com an sendo o vetor de direção normal (perpendicular). Neste resultado,
vê-se que, o campo de uma superfície infinita com carga distribuída é
completamente normal e uniforme, o qual é apresentado na Figura 1.7.
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
27
Figura 1.7: Campo elétrico de uma superfície de carga.
Da mesma forma, utilizando o mesmo procedimento, encontra-se o
campo elétrico de um volume de cargas distribuído em uma região finita.
Isto é, dado uma distribuição volumétrica de cargas
em uma região
limitada, encontra-se:
E
³vol
Udv
aR ,
4SH 0 R 2
dv, em um ponto R distante
desde que para cada elemento diferencial
dele, é criado um pequeno campo elétrico, e a soma de todas as contribuições de campo dos elementos do volume da carga geram o campo total.
Para calcular o ângulo formado entre dois campos resultantes de duas
distribuições de cargas quaisquer, em um ponto definido, utiliza-se o
produto escalar:
E A ˜ EB
E Ax EBx E Ay EBy E Az EBz
E A EB cos T AB
28
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
ou
T AB
§
¨E ˜E
arccos¨ A B
¨ E A EB
©
·
§
·
¨ E Ax EBx E Ay EBy E Az E Bz ¸
¸
¸
¸ arccos¨
¸
¨
¸
E A EB
¹
©
¹
em que A e B são os dois campos gerados pelas cargas qA e qB no ponto
determinado.
De acordo com a teoria apresentada, o programa apresentado a seguir
calcula o valor do campo elétrico em um ponto P devido a uma distribuição
de cargas, apresentando seu resultado tanto em magnitude, como na forma
vetorial.
————————————
Programa CAMPO.C
————————————
#include
#include
#include
#include
<stdio.h>
<conio.h>
<math.h>
<string.h>
int item, dados = 0, totalq;
float coordsq[30][3], coordsQ[3], coordsE[3];
double carga[30], Q, rho_l, rho_s, Er, Evr[3], evr[30][3], er[30];
char muda[2] = “”, tipo[2] = “”, eixo[2];
void menu (void);
void dadosin (void);
void ccampo(void);
void main(){
int k;
clrscr();
do{
menu();
switch(item){
case 1:
dadosin();
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
29
break;
case 2:
if (!dados){
printf(“\nNão houve entrada de dados!\n”);
printf(“Pressione uma tecla!”);
while(!kbhit());
}
else{
ccampo();
switch(tipo[0]){
case ‘q’:
printf(“\nCampo no ponto (%f, %f, %f) da
carga Q = %e [C] definida:\nEvr = %eax +
(%e)ay + (%e)az [V/m]\nEr = %e [V/m]\n”,
coordsE[0], coordsE[1], coordsE[2], Q,
Evr[0], Evr[1], Evr[2], Er);
break;
case ‘v’:
printf(“Campos individuais das cargas no
ponto (%f, %f, %f):\n”, coordsE[0],
coordsE[1], coordsE[2]);
for(k = 0; k < totalq; k++)
printf(“\nCarga q(%d) = %e [C]:\nEvet =
%eax + (%e)ay + (%e)az [V/m];\nEmod =
%e[V/m]\n”, k, carga[k], evr[k][0],
evr[k][1], evr[k][2], er[k]);
printf(“\nCampo resultante total das
cargas no ponto (%f, %f, %f):\n”,
coordsE[0], coordsE[1], coordsE[2]);
printf(“Ervet = %eax + (%e)ay + (%e)az
[V/m];\nErmod = %e[V/m]\n”, Evr[0],
Evr[1], Evr[2], Er);
break;
case ‘l’:
printf(“Campo da linha de carga Rho_L = %e
[C/m] disposta no eixo %s:\n”, rho_l,
eixo);
switch(eixo[0]){
case ‘x’:
printf(“Ervet = %eay + (%e)az [V/
m];\nErmod = %e[V/m]\n”, Evr[1],
Evr[2], Er);
break;
case ‘y’:
printf(“Ervet = %eax + (%e)az [V/
30
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
m];\nErmod = %e[V/m]\n”, Evr[0],
Evr[2], Er);
break;
case ‘z’:
printf(“Ervet = %eax + (%e)ay [V/
m];\nErmod = %e[V/m]\n”, Evr[0],
Evr[1], Er);
printf(“ou em Coordenadas
Cilíndricas\nErvet = %ear [V/
m]\n”, Er);
break;
}
break;
case ‘s’:
printf(“Campo da superfície de carga Rho_S
= %e [C/m^2] disposta no plano %s:\n”,
rho_s, eixo);
if(strcmp(eixo, “xy”) || strcmp(eixo, “yx”))
printf(“Ervet = %eaz [V/m];\nErmod =
%e[V/m]\n”, Evr[2], Er);
else if(strcmp(eixo, “yz”) || strcmp(eixo, “zy”))
printf(“Ervet = %eax [V/m];\nErmod
= %e[V/m]\n”, Evr[0], Er);
else if(strcmp(eixo, “xz”) ||
strcmp(eixo, “zx”))
printf(“Ervet = %eay [V/
m];\nErmod = %e[V/m]\n”,
Evr[1], Er);
break;
}
printf(“Pressione uma tecla!”);
while(!kbhit());
}
break;
case 0:
break;
}
}while (item != 0);
}
void menu(void){
do{
clrscr();
printf(“\n(0) - Sai”);
printf(“\n(1) - Entrada de dados”);
printf(“\n(2) - Calcular campos\n\n->”);
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
31
scanf(“%d”, &item);
if((item > 2) || (item < 0)){
printf(“Inválido! Pressione uma tecla!”);
while(!kbhit());
}
}while((item < 0) || (item > 2));
}
void dadosin(void){
int x;
clrscr();
strcpy(muda, “s”);
if(dados == 1){
do{
printf(“Deseja mudar os dados das cargas? (s/n)\n->”);
scanf(“%s”, muda);
}while(strcmp(muda, “s”) && strcmp(muda, “n”));
}
if(muda[0] == ‘s’){
do{
printf(“Que tipo de distribuição de cargas:\n(q)Uma
carga, (v)Várias cargas, (l)Linear,
(s)Superficial\n->”);
scanf(“%s”, tipo);
}while((tipo[0] != ‘q’) && (tipo[0] != ‘v’) &&
(tipo[0] != ‘l’) && (tipo[0] != ‘s’));
switch(tipo[0]){
case ‘q’:
printf(“\nEntre com o valor da carga de teste Q: “);
scanf(“%lf”, &Q);
printf(“\nEntre com a localização da carga Q (x, y,
z separados por espaços): “);
for(x = 0; x < 3; x++)
scanf(“%f”, &coordsQ[x]);
break;
case ‘v’:
printf(“Quantas cargas?\n”);
scanf(“%d”, &totalq);
x = 0;
do{
printf(“\nEntre com o valor da carga q(%d):\n”, x+1);
scanf(“%lf”, &carga[x]);
printf(“\nEntre com a localização da carga q(%d)
(x, y, z separados por espaços):\n”, x+1);
scanf(“%f”, &coordsq[x][0]);
scanf(“%f”, &coordsq[x][1]);
32
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
scanf(“%f”, &coordsq[x][2]);
x++;
}while (x < totalq);
break;
case ‘l’:
printf(“\nEntre com o valor de Rho_L:\n”);
scanf(“%lf”, &rho_l);
printf(“Em qual eixo a linha de cargas se encontra?
(x)/(y)/(z)\n”);
do{
scanf(“%s”, eixo);
}while((eixo[0] != ‘x’) && (eixo[0] != ‘y’) &&
(eixo[0] != ‘z’));
eixo[1] = ‘\0’;
break;
case ‘s’:
printf(“\nEntre com o valor de Rho_S:\n”);
scanf(“%lf”, &rho_s);
printf(“Em qual plano a superfície de cargas se
encontra? (xy)/(yz)/(xz)\n”);
do{
scanf(“%s”, eixo);
}while(strcmp(eixo, “xy”) && strcmp(eixo, “yx”)
&& strcmp(eixo, “xz”) && strcmp(eixo, “zy”)
&& strcmp(eixo, “yz”) && strcmp(eixo, “zx”));
break;
default:
break;
}
}
printf(“Qual a posição a ser calculado o campo? (x, y, z
separados por espaços)\n”);
scanf(“%f”, &coordsE[0]);
scanf(“%f”, &coordsE[1]);
scanf(“%f”, &coordsE[2]);
printf(“\nDados completos! Pressione uma tecla...”);
while(!kbhit());
dados = 1;
}
void ccampo(void){
int cont;
float r;
switch(tipo[0]){
case ‘q’:
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
33
r = sqrt(pow(coordsE[0]-coordsQ[0],2)+pow(coordsE[1]coordsQ[1],2)+ pow(coordsE[2]-coordsQ[2],2));
Evr[0] = 9e9*Q*(coordsE[0]-coordsQ[0])/pow(r,3);
Evr[1] = 9e9*Q*(coordsE[1]-coordsQ[1])/pow(r,3);
Evr[2] = 9e9*Q*(coordsE[2]-coordsQ[2])/pow(r,3);
Er=sqrt(pow(Evr[0],2) + pow(Evr[1],2) +
pow(Evr[2],2));
break;
case ‘v’:
cont = 0;
do{
r = sqrt(pow(coordsE[0]coordsq[cont][0],2)+pow(coordsE[1]coordsq[cont][1],2)+pow(coordsE[2]coordsq[cont][2],2));
evr[cont][0] = 9e9*carga[cont]*(coordsE[0]coordsq[cont][0])/ pow(r,3);
evr[cont][1] = 9e9*carga[cont]*(coordsE[1]coordsq[cont][1])/ pow(r,3);
evr[cont][2] = 9e9*carga[cont]*(coordsE[2]coordsq[cont][2])/ pow(r,3);
er[cont]=sqrt(pow(evr[cont][0],2) +
pow(evr[cont][1],2) + pow(evr[cont][2],2));
cont++;
}while(cont < totalq);
cont = 0;
Evr[0] = 0;
Evr[1] = 0;
Evr[2] = 0;
do{
Evr[0]+= evr[cont][0];
Evr[1]+= evr[cont][1];
Evr[2]+= evr[cont][2];
cont++;
}while(cont < totalq);
Er = sqrt(pow(Evr[0],2) + pow(Evr[1],2) + pow(Evr[2],2));
break;
case ‘l’:
switch(eixo[0]){
case ‘x’:
r = sqrt(pow(coordsE[1],2)+pow(coordsE[2],2));
Evr[0] = 0;
Evr[1] = 1.8e10*rho_l*coordsE[1]/r;
Evr[2] = 1.8e10*rho_l*coordsE[2]/r;
Er = sqrt(pow(Evr[1],2) + pow(Evr[2],2));
break;
34
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
case ‘y’:
r = sqrt(pow(coordsE[0],2)+pow(coordsE[2],2));
Evr[0] = 1.8e10*rho_l*coordsE[0]/r;
Evr[1] = 0;
Evr[2] = 1.8e10*rho_l*coordsE[2]/r;
Er = sqrt(pow(Evr[0],2) + pow(Evr[2],2));
break;
case ‘z’:
r = sqrt(pow(coordsE[0],2)+pow(coordsE[1],2));
Evr[0] = 1.8e10*rho_l*coordsE[0]/r;
Evr[1] = 1.8e10*rho_l*coordsE[1]/r;
Evr[2] = 0;
Er = sqrt(pow(Evr[0],2) + pow(Evr[1],2));
break;
}
break;
case ‘s’:
Evr[0] = 0;
Evr[1] = 0;
Evr[2] = 0;
if(strcmp(eixo, “xy”) || strcmp(eixo, “yx”))
Evr[2] = rho_s/1.7708e-11;
else if(strcmp(eixo, “yz”) || strcmp(eixo, “zy”))
Evr[0] = rho_s/1.7708e-11;
else if(strcmp(eixo, “xz”) || strcmp(eixo, “zx”))
Evr[1] = rho_s/1.7708e-11;
break;
default:
break;
}
}
1.3.1 Entendendo o Programa CAMPO.C
Este programa apresenta um menu similar aos programas anteriores,
mas devido aos cálculos mais detalhados e mais amplidão em suas
aplicações, as funções necessitam de maiores detalhamentos além de
outros comandos. Neste programa, o usuário pode calcular o campo
elétrico em um ponto determinado, cujo campo pode ser gerado por uma
carga elétrica, várias cargas em pontos determinados, uma linha de carga
em um dos eixos, ou uma superfície de cargas em um dos planos. Os
resultados podem ser modificados tantos no tipo de distribuição das cargas
e localização, como apenas no ponto onde se quer calcular o campo, sendo
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
35
esses resultados apresentados nas formas vetorial e modular (magnitude)
para cada caso.
Devido à necessidade de utilização de funções como strcmp e strcpy,
que compara strings e copia textos para variáveis, a inclusão da biblioteca
string.h é necessária. As demais bibliotecas são utilizadas pelos mesmos
motivos dos programas anteriores.
#include
#include
#include
#include
<stdio.h>
<conio.h>
<math.h>
<string.h>
Nas variáveis globais deste programa são incluídas em relação ao
programa COULOMB.C: tipo float – coordsE, que guarda o valor do ponto
(as três coordenadas) onde se deseja determinar o valor do campo elétrico;
tipo double – rho_l, rho_s, Er, Evr, evr e er, que são responsáveis por
guardar os valores da carga em uma distribuição linear, carga em uma
distribuição superficial, magnitude do campo total, campo vetorial total,
campo vetorial por carga e magnitude do campo por carga, respectivamente; tipo char – muda, tipo e eixo, responsáveis pelo delineamento do
fluxo do programa, para verificar se o usuário tem interesse em mudar
valores ou distribuição das cargas, avaliando o tipo de distribuição da
carga e qual eixo ou plano que se encontra as cargas, quando são
distribuídas em linhas ou superfícies, respectivamente.
int item, dados = 0, totalq;
float coordsq[30][3], coordsQ[3], coordsE[3];
double carga[30], Q, rho_l, rho_s, Er, Evr[3], evr[30][3], er[30];
char muda[2] = “”, tipo[2] = “”, eixo[2];
Os protótipos das funções apresentam uma modificação apenas para a
função ccampo, que chama a função que realiza a análise e o cálculo do
campo no ponto definido na entrada dos dados.
void menu (void);
void dadosin (void);
void ccampo(void);
36
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
O programa, em relação ao programa COULOMB.C, diferencia-se
mais a partir da função main. Especificamente, no teste do comando
switch...case, quando o valor da variável item é 2. Neste caso, a função
ccampo é chamada, onde são realizados os cálculos do campo no ponto
determinado, e um novo switch...case é aberto, de forma a direcionar o
fluxo do programa, de acordo com a variável tipo. Quando o gerador do
campo é uma única carga, esta variável apresenta seu valor como ‘q’, e
o valor do campo na forma vetorial e sua magnitude é apresentada:
ccampo();
switch(tipo[0]){
case ‘q’:
printf(“\nCampo no ponto (%f, %f, %f) da carga Q = %e
[C] definida:\nEvr = %eax + (%e)ay + (%e)az [V/
m]\nEr = %e [V/m]\n”, coordsE[0], coordsE[1],
coordsE[2], Q, Evr[0], Evr[1], Evr[2], Er);
quando o valor da variável tipo é ‘v’, o programa apresenta o campo na
forma vetorial e sua magnitude no ponto, referente à cada carga:
case ‘v’:
printf(“Campos individuais das cargas no ponto (%f, %f,
%f):\n”, coordsE[0], coordsE[1], coordsE[2]);
for(k = 0; k < totalq; k++)
printf(“\nCarga q(%d) = %e [C]:\nEvet = %eax + (%e)ay +
(%e)az [V/m];\nEmod = %e[V/m]\n”, k, carga[k],
evr[k][0], evr[k][1], evr[k][2], er[k]);
e o campo resultante no ponto, devido à todas as cargas:
printf(“\nCampo resultante total das cargas no ponto (%f,
%f, %f):\n”, coordsE[0], coordsE[1], coordsE[2]);
printf(“Ervet = %eax + (%e)ay + (%e)az [V/m];\nErmod = %e[V/
m]\n”, Evr[0], Evr[1], Evr[2], Er);
Se a variável tipo tem o valor ‘l’, a entrada de dados definiu uma
linha de cargas, e o campo no ponto é apresentado de acordo com o
eixo que o usuário definiu (outro switch...case testando o valor da
variável eixo)
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
37
case ‘l’:
printf(“Campo da linha de carga Rho_L = %e [C/m] disposta
no eixo %s:\n”, rho_l, eixo);
switch(eixo[0]){
case ‘x’:
printf(“Ervet = %eay + (%e)az [V/m];\nErmod = %e[V/
m]\n”, Evr[1], Evr[2], Er);
break;
case ‘y’:
printf(“Ervet = %eax + (%e)az [V/m];\nErmod = %e[V/
m]\n”, Evr[0], Evr[2], Er);
break;
case ‘z’:
printf(“Ervet = %eax + (%e)ay [V/m];\nErmod = %e[V/
m]\n”, Evr[0], Evr[1], Er);
printf(“ou em Coordenadas Cilíndricas\nErvet = %ear
[V/m]\n”, Er);
break;
Observe que, no caso da linha de cargas, quando a linha está definida
posicionada no eixo z, o resultado é apresentado tanto nas coordenadas
cartesianas, como nas coordenadas cilíndricas.
Se a carga está distribuída em uma superfície, a variável tipo apresenta
seu valor ‘s’. Consequentemente, a variável eixo é avaliada, e o resultado
é apresentado de acordo com o plano em que a carga está distribuída.
Observe que neste caso, a entrada dada referente ao plano, pode ser
invertida, como plano xy ou plano yx, que o programa entende da mesma
forma.
case ‘s’:
printf(“Campo da superfície de carga Rho_S = %e [C/m^2]
disposta no plano %s:\n”, rho_s, eixo);
if(strcmp(eixo, “xy”) || strcmp(eixo, “yx”))
printf(“Ervet = %eaz [V/m];\nErmod = %e[V/m]\n”,
Evr[2], Er);
else if(strcmp(eixo, “yz”) || strcmp(eixo, “zy”))
printf(“Ervet = %eax [V/m];\nErmod = %e[V/m]\n”,
Evr[0], Er);
else if(strcmp(eixo, “xz”) || strcmp(eixo, “zx”))
printf(“Ervet = %eay [V/m];\nErmod = %e[V/
m]\n”, Evr[1], Er);
break;
38
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
Por fim, a função main é finalizada como nos demais programas.
A função menu, só difere dos programas anteriores, no texto de entrada
de dados, referente aos cálculos.
printf(“\n(2) - Calcular campos\n\n->”);
A função de entrada de dados, dadosin, tem a variável local inteira x
para ser utilizada como contador em alguns laços:
int x;
Após a limpeza da tela pela função clrscr(), a variável tipo char, muda,
obtém o valor “s”, para direcionar o fluxo inicial do programa para entrar
os dados.
clrscr();
strcpy(muda, “s”);
Quando os dados já foram introduzidos uma vez (variável dados é igual
a 1), o valor da variável muda pode ser modificado: se for escolhido o valor
‘s’, o programa direciona para modificar os dados de valores e distribuição
das cargas, e se for ‘n’, o programa salta para o final da função dadosin,
para solicitar apenas o ponto em que se deseja calcular o campo elétrico:
if(dados == 1){
do{
printf(“Deseja mudar os dados das cargas? (s/n)\n->”);
scanf(“%s”, muda);
}while(strcmp(muda, “s”) && strcmp(muda, “n”));
}
Como inicialmente a variável muda tem o valor ‘s’, ou caso já se tenha
entrado com os dados e solicitado mudança nos valores e disposições das
cargas, o programa na função dadosin solicita o tipo de distribuição de
cargas que se deseja, em que necessariamente a variável tipo pode obter
os valores ‘q’ (para uma única carga), ‘v’ (para várias cargas), ‘l’ (para
distribuição linear) e ‘s’ (para distribuição superficial).
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
39
if(muda[0] == ‘s’){
do{
printf(“Que tipo de distribuição de cargas:\n(q)Uma
carga, (v)Várias cargas, (l)Linear,
(s)Superficial\n->”);
scanf(“%s”, tipo);
}while((tipo[0] != ‘q’) && (tipo[0] != ‘v’) &&
(tipo[0] != ‘l’) && (tipo[0] != ‘s’));
Logo em seguida, através de um switch...case, o valor da variável tipo
é avaliado. Caso seu valor seja ‘q’, o programa solicita a entrada do valor
da carga Q e sua localização:
case ‘q’:
printf(“\nEntre com o valor da carga de teste Q: “);
scanf(“%lf”, &Q);
printf(“\nEntre com a localização da carga Q (x, y, z
separados por espaços): “);
for(x = 0; x < 3; x++)
scanf(“%f”, &coordsQ[x]);
break;
Se o valor da variável tipo for ‘v’, o programa solicita o valor de cada
uma das cargas e sua respectiva localização:
case ‘v’:
printf(“Quantas cargas?\n”);
scanf(“%d”, &totalq);
x = 0;
do{
printf(“\nEntre com o valor da carga q(%d):\n”, x+1);
scanf(“%lf”, &carga[x]);
printf(“\nEntre com a localização da carga q(%d) (x,
y, z separados por espaços):\n”, x+1);
scanf(“%f”, &coordsq[x][0]);
scanf(“%f”, &coordsq[x][1]);
scanf(“%f”, &coordsq[x][2]);
x++;
}while (x < totalq);
break;
40
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
Se seu valor é ‘l’, o programa solicita a entrada do valor de
em que essa linha de cargas se encontra:
L
e o eixo
case ‘l’:
printf(“\nEntre com o valor de Rho_L:\n”);
scanf(“%lf”, &rho_l);
printf(“Em qual eixo a linha de cargas se encontra? (x)/
(y)/(z)\n”);
do{
scanf(“%s”, eixo);
}while((eixo[0] != ‘x’) && (eixo[0] != ‘y’) &&
(eixo[0] != ‘z’));
eixo[1] = ‘\0’;
break;
e se for ‘s’, o programa solicita o valor de
localiza:
S
e o plano em que ela se
case ‘s’:
printf(“\nEntre com o valor de Rho_S:\n”);
scanf(“%lf”, &rho_s);
printf(“Em qual plano a superfície de cargas se encontra?
(xy)/(yz)/(xz)\n”);
do{
scanf(“%s”, eixo);
}while(strcmp(eixo, “xy”) && strcmp(eixo, “yx”) &&
strcmp(eixo, “xz”) && strcmp(eixo, “zy”) &&
strcmp(eixo, “yz”) && strcmp(eixo, “zx”));
break;
Neste caso, o plano é solicitado, e entendido nos seus contrários: xy ou
yx, xz ou zx e yz ou zy. Enquanto não houver a entrada de um desses
planos, o programa continua a solicitar a entrada correta.
Ao finalizar o switch...case, o programa solicita a entrada do ponto
onde se deseja calcular o campo elétrico:
printf(“Qual a posição a ser calculado o campo? (x, y, z
separados por espaços)\n”);
scanf(“%f”, &coordsE[0]);
scanf(“%f”, &coordsE[1]);
scanf(“%f”, &coordsE[2]);
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
41
Por fim, o programa apresenta o texto confirmando que os dados foram
inseridos, aguardando o pressionamento de uma tecla qualquer, tornando
a variável dados igual a 1:
printf(“\nDados completos! Pressione uma tecla...”);
while(!kbhit());
dados = 1;
Na função ccampo, a variável cont, tipo int, é declarada para ser
utilizada como contador, e a variável r, tipo float, é declarada para calcular
a distância das cargas ao ponto em que se deseja calcular o campo elétrico:
int cont;
float r;
Por meio de um comando switch…case, a variável tipo é avaliada, para
direcionar o fluxo dos cálculos do programa para a especificidade definida. Assim, se seu valor é ‘q’, a carga é uma única, e o programa calcula a
distância r da carga Q ao ponto em que se deseja calcular o campo, e calcula
os valores de cada componente (x, y e z) do campo no ponto. Por fim,
calcula a magnitude deste campo:
case ‘q’:
r = sqrt(pow(coordsE[0]-coordsQ[0],2)+pow(coordsE[1]coordsQ[1],2)+ pow(coordsE[2]-coordsQ[2],2));
Evr[0] = 9e9*Q*(coordsE[0]-coordsQ[0])/pow(r,3);
Evr[1] = 9e9*Q*(coordsE[1]-coordsQ[1])/pow(r,3);
Evr[2] = 9e9*Q*(coordsE[2]-coordsQ[2])/pow(r,3);
Er=sqrt(pow(Evr[0],2) + pow(Evr[1],2) + pow(Evr[2],2));
Se a variável tipo tem o valor ‘v’, o programa calcula separadamente o
valor do campo no ponto, referente à cada uma das cargas distribuídas
individualmente:
case ‘v’:
cont = 0;
do{
r = sqrt(pow(coordsE[0]coordsq[cont][0],2)+pow(coordsE[1]coordsq[cont][1],2)+pow(coordsE[2]coordsq[cont][2],2));
42
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
evr[cont][0] = 9e9*carga[cont]*(coordsE[0]coordsq[cont][0])/ pow(r,3);
evr[cont][1] = 9e9*carga[cont]*(coordsE[1]coordsq[cont][1])/ pow(r,3);
evr[cont][2] = 9e9*carga[cont]*(coordsE[2]coordsq[cont][2])/ pow(r,3);
er[cont]=sqrt(pow(evr[cont][0],2) +
pow(evr[cont][1],2) + pow(evr[cont][2],2));
cont++;
}while(cont < totalq);
Depois zera os valores da variável Evr e soma todas as contribuições
das cargas distribuídas, para determinar nesta variável, o valor do campo
vetorial resultante:
cont = 0;
Evr[0] = 0;
Evr[1] = 0;
Evr[2] = 0;
do{
Evr[0]+= evr[cont][0];
Evr[1]+= evr[cont][1];
Evr[2]+= evr[cont][2];
cont++;
}while(cont < totalq);
e calcula o valor da magnitude do campo resultante:
Er = sqrt(pow(Evr[0],2) + pow(Evr[1],2) + pow(Evr[2],2));
Quando a variável tipo apresenta o valor ‘l’, um switch…case é gerado
para avaliar o valor da variável eixo.
case ‘l’:
switch(eixo[0]){
De acordo com o valor desta variável, a distância r é calculada (apenas
com os dois eixos diferentes do definido nesta variável), e o campo
(vetorial e magnitude) é calculado:
case ‘x’:
r = sqrt(pow(coordsE[1],2)+pow(coordsE[2],2));
CAPÍTULO 1 – CARGAS ELÉTRICAS, LEI DE COULOMB E CAMPO ELÉTRICO
43
Evr[0] = 0;
Evr[1] = 1.8e10*rho_l*coordsE[1]/r;
Evr[2] = 1.8e10*rho_l*coordsE[2]/r;
Er = sqrt(pow(Evr[1],2) + pow(Evr[2],2));
break;
case ‘y’:
r = sqrt(pow(coordsE[0],2)+pow(coordsE[2],2));
Evr[0] = 1.8e10*rho_l*coordsE[0]/r;
Evr[1] = 0;
Evr[2] = 1.8e10*rho_l*coordsE[2]/r;
Er = sqrt(pow(Evr[0],2) + pow(Evr[2],2));
break;
case ‘z’:
r = sqrt(pow(coordsE[0],2)+pow(coordsE[1],2));
Evr[0] = 1.8e10*rho_l*coordsE[0]/r;
Evr[1] = 1.8e10*rho_l*coordsE[1]/r;
Evr[2] = 0;
Er = sqrt(pow(Evr[0],2) + pow(Evr[1],2));
break;
Da mesma forma, caso a variável tipo esteja com o valor ‘s’, as
componentes do campo são zeradas:
case ‘s’:
Evr[0] = 0;
Evr[1] = 0;
Evr[2] = 0;
e o cálculo das mesmas é atualizado, de acordo com o plano que a
superfície de cargas se encontra.
if(strcmp(eixo, “xy”) || strcmp(eixo, “yx”))
Evr[2] = rho_s/1.7708e-11;
else if(strcmp(eixo, “yz”) || strcmp(eixo, “zy”))
Evr[0] = rho_s/1.7708e-11;
else if(strcmp(eixo, “xz”) || strcmp(eixo, “zx”))
Evr[1] = rho_s/1.7708e-11;
A necessidade de zerar as componentes primeiramente, é que no caso
do campo de uma superfície de cargas em um dos planos definidos, duas
componentes são nulas. Dessa forma, o programa só precisa calcular uma
componente única.
44
C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO
1.4 EXERCÍCIOS
1.1)Modifique o programa CARGA.C para que seja possível calcular
cargas nas coordenadas cilíndricas e esféricas.
1.2)Desenvolva um programa para converter coordenadas.
1.3)Modifique o programa COULOMB.C para que seja possível calcular
forças em distribuições volumétricas de cargas.
1.4)Modifique o programa COULOMB.C para que seja possível entrar
com pontos em outras coordenadas e seus cálculos serem realizados nas coordenadas que o usuário definir.
1.5)Modifique o programa CAMPO.C para que sejam calculados
campos gerados por distribuições volumétricas de cargas.
1.6)Modifique o programa CAMPO.C para que se possam entrar com
equações de campos e o programa calcule seu valor em um ponto
que o usuário desejar.
1.7)Modifique o programa CAMPO.C para que o seja apresentada a
equação do campo da distribuição de cargas definida.
1.8)Modifique o programa CAMPO.C para que se possa calcular o
campo em um ponto definido, de linhas e superfícies de cargas
finitas.