aplicado ao aprendizado eletromagnetismosite.livrariacultura.com.br/imagem/capitulo/30743937.pdf ·...

EDUARD MONTGOMERY MEIRA COSTA, D.SC.

CAPLICADO AO APRENDIZADO

DE ELETROMAGNETISMO

��

��©©�� !�"#$%��#!&'&#!!(%��)� �� *��+��% � �� % �� ,�� ,�� -��% � �.��% ��/��0��%�� 1��+�23�%��%��

��4�� 1�4��,�� 5��,�� 5�� 6��7��8��+�

5*�� ,�� /�� ,� � �� 9� ��23�% � �� % � � � �� +�� /��%� �:�/��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

�� %�� !��&�& �� ' () * ��+�� ,��' �, * -�� ./&01/231/ �� 4.35 ../32))).6 ��7� 4.35 ../32)80)�2��!� !��9!��&�"�&-� :::&!��&�"�&-� /863.

À 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 aevolução digital. A aplicação da programação em todas as áreas, especi-almente na engenharia, é essencial, para converter problemas em umalinguagem computacional, o que facilita o aprendizado com a traduçãodos problemas em algoritmos e códigos de programas, além de se obteruma ferramenta que realiza os cálculos necessários que são muito traba-lhosos quando realizados via calculadoras.

É de notório saber que programar facilita o aprendizado, especialmentede áreas técnicas, pois a tradução passo a passo dos problemas em umcódigo sintetiza a consolidação da teoria. Dessa forma, conhecer aprogramação em uma linguagem como C, que é uma linguagem universalé de grande importância, e saber aplicá-la aos estudos cotidianos, rendeduplo ganho.

Este livro é dedicado a leitores curiosos que interessam em aprofundarseus estudos, tanto na área básica de computação, como a estudantes deengenharia e computação que desejam consolidar seus conhecimentos naárea de eletromagnetismo, desenvolver ferramentas para solucionar seusproblemas e aprender a aplicar a linguagem C para desenvolver seuspróprios softwares na solução de problemas que lhes convier.

Naturalmente, este livro é básico, dando uma visão direta de tópicos dateoria de eletromagnetismo e aplicação direta da linguagem C a essesproblemas. Assim, é um livro para quem conhece um pouco da área deeletromagnetismo (ou pretende conhecer ou se aprofundar) e para quemjá tem alguma base na programação. De toda forma, na bibliografia destelivro são apresentados alguns títulos para dar bases ao conteúdo destelivro, para quem ainda não tem muita segurança nessas áreas.

Deve-se ter em mente que na atualidade, a programação é uma das áreasmais necessárias, necessitando que técnicos, graduandos e graduados nasáreas de computação e engenharia conheçam e saibam aplicar as lingua-gens de programação aos problemas do cotidiano, para solucioná-los.

C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMOX

Como este livro é básico, os programas são feitos utilizando, muitasvezes, formas primitivas, direcionando os estudantes a modificarem osprogramas por meio dos exercícios propostos, de forma a melhorá-los,ampliá-los e torná-los mais profissionais, consolidando seus conhecimen-tos 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 .................................................................................. 11.1.1 Entendendo o Programa CARGA.C ........................................ 8

1.2 Lei de Coulomb ................................................................................ 141.2.1 Entendendo o Programa COULOMB.C ................................ 19

1.3 Campo Elétrico ................................................................................. 221.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 ...... 452.1.1 Entendendo o Programa Fluxo.C ........................................... 64

2.2 Divergente, Operador Nabla e Teorema da Divergência ............ 762.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 ... 1013.1.1 Entendendo o Programa WV.C ........................................... 106

3.2 Gradiente do Potencial Elétrico ................................................... 1103.2.1 Entendendo o Programa GRAD.C ...................................... 118

3.3 Campos do Dipolo Elétrico .......................................................... 1253.3.1 Entendendo o Programa DIPOLO.C .................................. 130

3.4 Energia no Campo Eletrostático .................................................. 1333.4.1 Entendendo o Programa ENERGIA.C ............................... 137

3.5 Exercícios ....................................................................................... 140

CAPÍTULO 4 - MATERIAIS ELÉTRICOS E PROPRIEDADES ............................... 143

4.1 Corrente, Densidade de Corrente e Continuidade da Corrente 1434.1.1 Entendendo o Programa CORRENTES.C.......................... 151

4.2 Condutores: Propriedades e Condições de Contorno ............... 1564.2.1 Entendendo o Programa CONDUTOR.C .......................... 163

4.3 Semicondutores ............................................................................. 167

C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMOXII

4.3.1 Entendendo o Programa SEMICOND.C ............................ 1744.4 Dielétricos: Propriedades e Condições de Contorno ................. 177

4.4.1 Entendendo o Programa DIELETRICO.C ......................... 1984.5 Capacitância ................................................................................... 212

4.5.1 Entendendo o Programa CAPACITOR.C ........................... 2204.6 Exercícios ....................................................................................... 224

CAPÍTULO 5 - EQUAÇÕES DE POISSON E LAPLACE ....................................... 229

5.1 A Equação de Poisson e a Equação de Laplace ........................ 2295.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 ..................... 2416.1.1 Entendendo o Programa MAGNETICO.C ......................... 247

6.2 Rotacional e Teorema de Stokes .................................................. 2526.2.1 Entendendo o Programa ROT.C .......................................... 264

6.3 Fluxo Magnético e Densidade de Fluxo Magnético ................. 2686.3.1 Entendendo o Programa FLUXOB.C ................................. 274

6.4 Potencial Escalar e Potencial Vetor Magnéticos ......................... 2766.4.1 Entendendo o Programa VM.C ........................................... 283

6.5 Exercícios ....................................................................................... 287

CAPÍTULO 7 - FORÇA E ENERGIA NO CAMPO MAGNÉTICO ............................ 291

7.1 Forças nos Campos Magnéticos .................................................. 2917.1.1 Entendendo o Programa FQB.C .......................................... 304

7.2 Torque nos Circuitos Fechados .................................................... 3117.2.1 Entendendo o Programa TORQUE.C ................................. 315

7.3 Energia nos Campos Magnéticos ................................................ 3197.3.1 Entendendo o Programa WB.C ........................................... 321

7.4 Indutâncias ..................................................................................... 3247.4.1 Entendendo o Programa INDUT.C ..................................... 331

7.5 Exercícios ....................................................................................... 335

CAPÍTULO 8 - MATERIAIS MAGNÉTICOS, PROPRIEDADES E CIRCUITOS

MAGNÉTICOS .............................................................................................. 337

8.1 Materiais Magnéticos .................................................................... 3378.1.1 Entendendo o Programa CONTB.C.................................... 357

8.2 Circuitos Magnéticos ..................................................................... 3738.2.1 Entendendo o Programa CIRCB.C ..................................... 382

SUMÁRIO XIII

8.3 Força e Energia Potencial em Circuitos Magnéticos ................. 386Considerações sobre Indutâncias com Núcleos

Ferromagnéticos .............................................................. 3888.3.1 Entendendo o Programa FVB.C .......................................... 391

8.4 Exercícios ....................................................................................... 394

CAPÍTULO 9 - EQUAÇÕES DE MAXWEEL E OS CAMPOS VARIANTES NO TEMPO

397

9.1 A Lei de Faraday ........................................................................... 3979.1.1 Entendendo o Programa FARADAY.C ............................... 405

9.2 Corrente de Deslocamento ........................................................... 4079.2.1 Entendendo o Programa DESLOC.C.................................. 422

9.3 Variações nos Campos Potenciais ................................................ 4359.3.1 Entendendo o Programa VARPOT.C .................................. 442

9.4 Exercícios ....................................................................................... 447

CAPÍTULO 10 - ONDAS ELETROMAGNÉTICAS ............................................... 449

10.1 Ondas Eletromagnéticas ............................................................. 44910.1.1 Entendendo o Programa ONDAS.C ................................. 462

10.2 Vetor de Poynting ........................................................................ 46410.2.1 Entendendo o Programa POYNTING.C .......................... 469

10.3 Ondas Eletromagnéticas em Bons Condutores e Efeito Pelicular 47010.3.1 Entendendo o Programa PELICULAR.C ......................... 479

10.4 Reflexão e Transmissão de Ondas Eletromagnéticas e Coeficien-te de Onda Estacionária.................................................................. 48210.4.1 Entendendo o Programa REFTRANS.C .......................... 495

10.5 Exercícios ..................................................................................... 498

CAPÍTULO 1

Neste capítulo são apresentados os conceitos de carga elétrica, Lei deCoulomb e campo elétrico de várias distribuições de cargas. Para isto, umaapresentação básica da teoria é realizada para o entendimento dos progra-mas e com isto, o estudante conhecer como aprofundar a aplicação destalinguagem de programação a estes conceitos, podendo assim, solucionarproblemas que envolvam estas leis e teoremas.

1.1 CARGAS ELÉTRICAS

O conceito de carga elétrica é uma propriedade física que determinaalgumas das interações eletromagnéticas da matéria. As cargas elétricassão concebidas em dois tipos: positivas e negativas. Todas as cargaselétricas são baseadas na carga fundamental (ou carga elementar) que é oelétron (negativa), tendo a carga elétrica positiva fundamental como sendoo 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, asquais podem ser descritas como:

� Densidade linear de carga: L

[C/m];

� Densidade superficial de carga: S

[C/m2];

CARGAS ELÉTRICAS, LEI DE COULOMB

E CAMPO ELÉTRICO

C - APLICADO AO APRENDIZADO DE ELETROMAGNETISMO2

� Densidade volumétrica de carga: [C/m3],

em que o valor total da carga é a soma de toda a carga distribuída,respectivamente:

.

;

;

��

�

�

�

vol

S S

L

dvQ

dSQ

dLQ

�

�

�

Se as cargas são distribuídas uniformemente na região ( L

, S

ouconstantes), tem-se Q=

LL, Q=

SS e Q= v, respectivamente. Caso

contrário, é necessário resolver as integrais em suas respectivas coordenadas:

Cartesianas:

.;;;

;;;

��

�

��

��

dxdydzQ

dydzQdxdzQdxdyQ

dzQdyQdxQ

SSS

LLL

�

��

��

Cilíndricas:

.;;;

;;;

��

�

��

��

dzrdrdQ

drdzQdzrdQrdrdQ

dzQrdQdrQ

SSS

LLL

��

��

��

Esféricas:

.

sen

;sen;;sen

;;sen;

2

2

��

�

��

��

��

��

��

ddrdrQ

ddrQrdrdQdrdrQ

rdQdrQdrQ

SSS

LLL

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 umadistribuição qualquer, calcula-se a integral conforme definida em seuslimites determinados.

O cálculo de uma integral de uma variável (as três primeiras em cadadescrição de coordenadas citada) pode ser realizado computacionalmenteentre os limites de uma simples, dividindo-se o total da diferença entre oslimites em um passo definido pequeno, em que se multiplica a função noponto inicial por este valor do passo, somando-se ao novo valor da funçãono ponto posterior (ponto inicial somado do passo) multiplicado pelo valordo 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 vistana 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 decada descrição dada nas respectivas coordenadas), realiza-se o mesmoprocedimento anterior (integral de uma variável), mas gerando dois laços:um para cada variável. Assim, determinam-se dois passos (um para cadavariável) através da divisão do total entre os limites, multiplica-se o valorda função por um passo de uma das variáveis, mantendo-se a outravariável no ponto fixo, realizando-se o procedimento da integral de umavariável. Depois, incrementa-se o passo da segunda variável e repete-se oprocedimento para a primeira variável, somando-se os resultados. Repetese este procedimento até que a segunda variável atinja o limite superior.Este procedimento pode ser visto na Figura 1.2.


Figura 1.2: Divisão de uma superfície qualquer em quadrados de área x y parao 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 comopequenos cubos de volumes definidos, cuja soma total dos pequenosvolumes determina o valor numérico da integral tripla de formacomputacional. Observe que o preenchimento de um vaso com pequenascaixas cúbicas apresenta muitos vazios e a soma do total dos volumes daspequenas caixas determina um erro grande em relação ao volume real dovaso (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) determinacom mais certeza o volume do vaso (quando os passos em x, y e z tendema zero, o valor numérico tende ao valor da integral corretamente). Devese observar que, em ambos os casos, o valor numérico é tão mais próximodo 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 programaque calcula o valor de uma carga distribuída em coordenadas cartesianas,de acordo com funções pré-definidas ou quando é uniformemente distri-buída. Neste caso, sempre que se deseja calcular uma carga com umadistribuição não uniforme, deve-se colocar as funções destas distribuiçõesnas linhas de comandos #define no início do programa.


————————————

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;


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: “);


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; }


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.CEste 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 tantona condição de uma carga uniformemente distribuída, como uma cargadistribuí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 nestecaso, são as de trabalho com strings e matemática.


Com essa inclusão, entram-se as definições das constantes com asfunçõ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ídalinearmente, superficialmente ou volumetricamente. Estas funções defini-das podem ser modificadas para que o programa calcule cargas totaisdistribuídas de outras formas, que não estas funções.


#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:

zyxyxz

yxxy

xx

��

2233132 2

considerando que x = cont1; y = cont2 e z = cont3.

As variáveis definidas como tipo int são utilizadas como controle defluxo do programa, na escolha de itens do menu e na verificação de entradade dados. As variáveis do tipo char são utilizadas para controle de fluxoda entrada de dados e cálculo dos valores finais da carga. As variáveis tipodouble são as definidas para valor de passo, cálculo da carga e limitesinferior 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 processamentodos dados após a escolha de um item do menu, o comando switch...caseavalia e direciona o programa para entrar os dados:

case 1: dadosin(); break;

para apresentar os resultados, caso os dados já tenham sido inseridos (valorda variável dados igual a 1), através da chamada à função ccarga:


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, esolicita que o usuário digite um deles. Caso o usuário digite um valorinvalido, é apresentada a mensagem “Inválido! Pressione uma tecla!” e atela é 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));}


A função dadosin solicita a entrada dos dados, em que na primeirapergunta, o usuário deve entrar com o valor da carga distribuída, caso elaseja 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 sedepender das funções definidas): “);

scanf(“%lf”, &val_carga);

Essa condição é realizada na segunda pergunta do programa, quedetermina o valor da variável equ, a qual é utilizada no calculo da cargana função ccarga, de acordo com seu valor. Como está dentro de um laçodo...while, o programa repete a pergunta até que seja digitado um ‘s’ ouum ‘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áriopode digitar as letras ‘l’, ‘s’ ou ‘v’, que representam, respectivamente, adistribuiçã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 solicitaos limites inferior e superior das coordenadas, de acordo com o tipo dedistribuiçã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’){


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 paravoltar 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 queforam inseridos. As variáveis locais cont1, cont2 e cont3 recebem osvalores dos limites inferiores das coordenadas, para começar o procedi-mento de cálculo. Observe que essas variáveis são definidas com osmesmos nomes das variáveis dentro das funções constantes nas definiçõesno início do programa. As demais variáveis locais são criadas para receberos 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 condicionaiscalculam primeiramente o número total de passos a serem utilizados parao 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);


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 dacarga através da multiplicação direta do valor da carga multiplicado pelocomprimento da linha (caso seja uma distribuição linear), pela área (casoseja 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 valoraproximado 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áveisque são somadas passo a passo. Primeiro a primeira coordenada é somadaaté alcançar o limite superior. Quando atinge esse valor, essa volta ao valordo limite inferior e incrementa de delta a segunda coordenada. Repete-se


isso, até que a segunda coordenada atinja o limite superior, quando aterceira 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 sepode 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 atingiuo 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. Estaforça pode ser de atração (quando as cargas envolvidas são de mesmosinal) ou de repulsão (quando as cargas apresentam sinais contrários). Seuvalor é um vetor dirigido de uma carga para outra, podendo ser acomponente resultante da interação entre várias forças geradas por váriascargas sobre uma outra carga.

A lei de Coulomb determina que o módulo da força entre duas cargasQ

1 e Q

2é:

20

21

4 R

QQF

� [N]


em que R é a distância entre as cargas e

mFmF /10361/10854,8 912

0��

é 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 cargaQ

2 é:

122120

2112 4 Ra

R

QQF

�

em que a direção da força é dada pelo vetor unitário (ou versor)

212

212

212

121212

12

12

)()()(

)()()(12

zzyyxx

azzayyaxx

R

Ra zyx

R��

��

com os versores xa , ya e za sendo os versores que dão as direções doseixos coordenados x, y e z, respectivamente. O exemplo desta força, parao 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.


A força resultante que várias cargas Q1, Q

2, ..., Q

n, exercem sobre uma

carga Q, é definida pelo somatório vetorial das forças:

��

��n

iR

iQ

in

iiR iQ

aR

QQFF

12

01 4 .

Uma força de Coulomb resultante de três cargas sobre uma carga Qpode 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 programaque calcula o valor da força exercida sobre uma carga Q provinda de umacarga ou conjunto de cargas, apresentando seu resultado tanto em magni-tude, como na forma vetorial.

————————————

Programa COULOMB.C

————————————


int item, dados = 0, totalq;float coordsq[30][3], coordsQ[3];


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”);


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);




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.CDa mesma forma que o programa CARGA.C, este programa gera um

menu principal, onde se determina se deseja entrar com dados, calcular asforças ou sair do programa. O cálculo das forças determina a força vetoriale sua magnitude para cada carga atuando sobre uma carga de teste Q, etambém a força total resultante gerada por todas as cargas em conjuntosobre esta carga de teste Q, na forma vetorial e sua magnitude, as quais sãoapresentadas ao ser chamada a função cforca() no menu principal.

Como todo programa, são incluídas as bibliotecas das funções utiliza-das. Neste caso, são as mesmas do programa CARGA.C.


As variáveis globais deste programa são as inteiras (tipo int) quedefinem o fluxo dos dados no menu e o número total de cargas queexercem força sobre a carga de teste Q, que é a variável totalq; tipo floattem as variáveis coordsq e coordsQ, que guardam as posições x, y e z de


cada carga q e da carga de teste Q e, tipo double encontram-se as variáveiscarga, 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 porguardar o valor da magnitude da força resultante de todas as cargas q sobrea carga Q, Fvr que guarda o valor vetorial da roça resultante de todas ascargas q sobre a carga Q, fvr que guarda o valor vetorial de cada carga qsobre a carga Q e fr que guarda o valor da magnitude de cada carga q sobrea carga Q.

Os protótipos das funções são: menu (responsável pela apresentação domenu e direcionamento do fluxo de informações do programa), dadosin(responsável pela entrada de dados) e cforca (responsável pelo cálculo dasforças individuais das cargas e da resultante final, tanto na forma vetorialcomo 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 apresen-tação dos resultados, quando há entrada de dados, o programa apresentapara 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 ascargas 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 comocontador. Nesta função, são solicitados os dados:


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 ez, 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, utilizadacomo contador, e a variável local r, tipo float, responsável pelo calculo dadistància entre cada carga q e a carga Q.

Realizada a declaração das variáveis, um laço do...while calcula adistância entre cada carga q da carga de teste Q, e calcula a força geradapor q em Q em cada uma das componentes x, y e z, calculando por fim amagnitude 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));





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, oprograma zera a variável Fvr:

cont = 0;Fvr[0] = 0;Fvr[1] = 0;Fvr[2] = 0;

e gera um laço para calcular a resultante vetorial das forces exercidas sobreQ:

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, emqualquer 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ênciade um campo de forças gerado pela carga, o qual é denominado de campo


elétrico. Este campo elétrico é um campo vetorial, e tem sempre a direçãoperpendicular à carga.

Tomando uma carga q (denominada de carga de teste) em que se podevariar a sua posição, e uma carga fixa Q que se deseja calcular o valor docampo na posição da carga q, define-se o campo elétrico da carga Q por:

q

FE � ,

cuja equação determina a eliminação da carga de teste para calcular ocampo da carga Q no ponto em que a carga q se encontra. A unidade docampo elétrico é [N/C] (Newton/Coulomb), ou mais conhecida como [V/m] (Volt/metro).

Assim, o campo de uma carga pontual é definido como sendo:

rar

QE 2

04� ,

considerando que a carga está na origem do sistema de coordenadas, emque se referencia a direção do campo na direção do raio (em coordenadasesféricas, desde que para qualquer ponto que se deseja calcular o valordeste 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 sistemade coordenadas, tem-se:

RaR

QE 2

04�

em que o R é a distância entre o ponto a ser medido o campo, e a posiçãoem que se encontra a carga que o gera:

zyx azzayyaxxR )()()( 121212 ��

com R sendo seu módulo. Este campo pode ser visto na Figura 1.5.


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 quantidadede cargas pontuais dQ sobrepostas, o que dá pela lei de Coulomb para cadauma das cargas sobrepostas, um elemento diferencial de força:

RaR

qdQFd 2

04�

que, juntando todas as contribuições para calcular a força total tem-se:

��

�� R

L aR

dzqFdF 2

04�

desde que a carga dQ = L dz. Dessa forma, como

zrzyx azarazzayyaxxR �� )()()( 121212 ,

e a linha de carga se encontrar no eixo z (o que indica que os valores dex

1 e y

1 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 valorde z

1 pode ser considerado zero (plano xy) devido à simetria da carga

(inicia no - e finaliza no + ). Assim, retirando a carga de teste q, tem-se:


que é completamente radial cilíndrica e perpendicular à linha. Este podeser visto na Figura 1.6.

Figura 1.6: Campo elétrico de uma linha de cargaou de uma carga distribuída em um cilindro: radial cilíndrico.

Considerando que a linha de carga seja finita, o campo só será vistodesta forma numa distância em que haja simetria (ponto central). Casocontrário, o resultado terá direções em r e z, quando se mudam os limitesde integração, o que se pode verificar na equação do campo.


Utilizando este resultado e juntando uma quantidade infinita de linhas decargas paralelas formando uma superfície plana, encontra-se o resultadopara uma superfície com cargas distribuídas

S. Assim, tem-se que,

considerando uma superfície de cargas no plano xz, uma porção destasuperfície que forma uma linha (um elemento

S com largura dx) tem o

valor L =

Sdx. E consequentemente, pelo resultado do campo elétrico

para uma linha de cargas, encontra-se:

� �

� �y

S

yS

yxS

yxSRL

a

a

ax

yayx

dxyx

ayaxdx

R

aEdE

0

0

22

0

2200

2

2

arctanln21

2

22

�

�

�

�

�

�

�

��

��

��

�

��

�

��

��

��

o que pode ser estendido de uma forma geral, como:

nS aE02�

�

com na 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.


Figura 1.7: Campo elétrico de uma superfície de carga.

Da mesma forma, utilizando o mesmo procedimento, encontra-se ocampo 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ãolimitada, encontra-se:

Rvola

R

dvE �� 2

04�

,

desde que para cada elemento diferencial dv, em um ponto R distantedele, é 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 duasdistribuições de cargas quaisquer, em um ponto definido, utiliza-se oproduto escalar:

ABBABzAzByAyBxAxBA EEEEEEEEEE �cos��


ou

��

�

�

��

�

��

��

�

�

��

�

��

�BA

BzAzByAyBxAx

BA

BAAB

EE

EEEEEE

EE

EE arccosarccos�

em que A e B são os dois campos gerados pelas cargas qA e q

B no ponto

determinado.

De acordo com a teoria apresentada, o programa apresentado a seguircalcula o valor do campo elétrico em um ponto P devido a uma distribuiçãode cargas, apresentando seu resultado tanto em magnitude, como na formavetorial.

————————————

Programa CAMPO.C

————————————

#include <stdio.h>#include <conio.h>#include <math.h>#include <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();


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 dascargas 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/



break; case ‘z’: printf(“Ervet = %eax + (%e)ay [V/


printf(“ou em CoordenadasCilí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->”);


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]);


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’:


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);



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;


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.CEste programa apresenta um menu similar aos programas anteriores,

mas devido aos cálculos mais detalhados e mais amplidão em suasaplicações, as funções necessitam de maiores detalhamentos além deoutros comandos. Neste programa, o usuário pode calcular o campoelétrico em um ponto determinado, cujo campo pode ser gerado por umacarga elétrica, várias cargas em pontos determinados, uma linha de cargaem um dos eixos, ou uma superfície de cargas em um dos planos. Osresultados podem ser modificados tantos no tipo de distribuição das cargase localização, como apenas no ponto onde se quer calcular o campo, sendo


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 bibliotecastring.h é necessária. As demais bibliotecas são utilizadas pelos mesmosmotivos dos programas anteriores.

#include <stdio.h>#include <conio.h>#include <math.h>#include <string.h>

Nas variáveis globais deste programa são incluídas em relação aoprograma 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 porguardar os valores da carga em uma distribuição linear, carga em umadistribuição superficial, magnitude do campo total, campo vetorial total,campo vetorial por carga e magnitude do campo por carga, respectiva-mente; tipo char – muda, tipo e eixo, responsáveis pelo delineamento dofluxo do programa, para verificar se o usuário tem interesse em mudarvalores ou distribuição das cargas, avaliando o tipo de distribuição dacarga e qual eixo ou plano que se encontra as cargas, quando sãodistribuí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 afunção ccampo, que chama a função que realiza a análise e o cálculo docampo no ponto definido na entrada dos dados.

void menu (void);void dadosin (void);void ccampo(void);


O programa, em relação ao programa COULOMB.C, diferencia-semais a partir da função main. Especificamente, no teste do comandoswitch...case, quando o valor da variável item é 2. Neste caso, a funçãoccampo é chamada, onde são realizados os cálculos do campo no pontodeterminado, e um novo switch...case é aberto, de forma a direcionar ofluxo do programa, de acordo com a variável tipo. Quando o gerador docampo é uma única carga, esta variável apresenta seu valor como ‘q’, eo 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 naforma 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 umalinha de cargas, e o campo no ponto é apresentado de acordo com oeixo que o usuário definiu (outro switch...case testando o valor davariável eixo)


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á definidaposicionada no eixo z, o resultado é apresentado tanto nas coordenadascartesianas, como nas coordenadas cilíndricas.

Se a carga está distribuída em uma superfície, a variável tipo apresentaseu 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 serinvertida, como plano xy ou plano yx, que o programa entende da mesmaforma.

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;


Por fim, a função main é finalizada como nos demais programas.

A função menu, só difere dos programas anteriores, no texto de entradade 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 xpara 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 entraros dados.

clrscr();strcpy(muda, “s”);

Quando os dados já foram introduzidos uma vez (variável dados é iguala 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çãodas 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 tenhaentrado com os dados e solicitado mudança nos valores e disposições dascargas, o programa na função dadosin solicita o tipo de distribuição decargas que se deseja, em que necessariamente a variável tipo pode obteros valores ‘q’ (para uma única carga), ‘v’ (para várias cargas), ‘l’ (paradistribuição linear) e ‘s’ (para distribuição superficial).


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 valorda 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 cadauma 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;


Se seu valor é ‘l’, o programa solicita a entrada do valor de L

e o eixoem que essa linha de cargas se encontra:

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 S e o plano em que ela se

localiza:

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 ouyx, xz ou zx e yz ou zy. Enquanto não houver a entrada de um dessesplanos, o programa continua a solicitar a entrada correta.

Ao finalizar o switch...case, o programa solicita a entrada do pontoonde se deseja calcular o campo elétrico:

printf(“Qual a posição a ser calculado o campo? (x, y, zseparados por espaços)\n”);

scanf(“%f”, &coordsE[0]);scanf(“%f”, &coordsE[1]);scanf(“%f”, &coordsE[2]);


Por fim, o programa apresenta o texto confirmando que os dados foraminseridos, aguardando o pressionamento de uma tecla qualquer, tornandoa 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 serutilizada como contador, e a variável r, tipo float, é declarada para calculara 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, paradirecionar o fluxo dos cálculos do programa para a especificidade defini-da. Assim, se seu valor é ‘q’, a carga é uma única, e o programa calcula adistância r da carga Q ao ponto em que se deseja calcular o campo, e calculaos 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 ovalor do campo no ponto, referente à cada uma das cargas distribuídasindividualmente:

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));





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çõesdas cargas distribuídas, para determinar nesta variável, o valor do campovetorial 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 é geradopara 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 (apenascom 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));


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’, ascomponentes 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 asuperfí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 casodo campo de uma superfície de cargas em um dos planos definidos, duascomponentes são nulas. Dessa forma, o programa só precisa calcular umacomponente única.


1.4 EXERCÍCIOS

1.1)Modifique o programa CARGA.C para que seja possível calcularcargas 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 calcularforças em distribuições volumétricas de cargas.

1.4)Modifique o programa COULOMB.C para que seja possível entrarcom pontos em outras coordenadas e seus cálculos serem realiza-dos nas coordenadas que o usuário definir.

1.5)Modifique o programa CAMPO.C para que sejam calculadoscampos gerados por distribuições volumétricas de cargas.

1.6)Modifique o programa CAMPO.C para que se possam entrar comequações de campos e o programa calcule seu valor em um pontoque o usuário desejar.

1.7)Modifique o programa CAMPO.C para que o seja apresentada aequação do campo da distribuição de cargas definida.

1.8)Modifique o programa CAMPO.C para que se possa calcular ocampo em um ponto definido, de linhas e superfícies de cargasfinitas.

aplicado ao aprendizado eletromagnetismosite.livrariacultura.com.br/imagem/capitulo/30743937.pdf ·...

Documents