Oscilador Trifásico Senoidal

 

Oscilador Trifásico com Variação de Frequência por Tensão

 

Dicas Sobre Vetores (Arrays) no OpenScad

- Copie e cole o texto abaixo no editor do OpenScad para melhor entender o assunto. 

 a=[]; // Declara "a" como um vetor vazio
//
for (i=[0:9]) { a=a[i]; } //Acusa warning porque sobrescreveu o objeto "a".
//
for (i=[0:9]) { echo ("====>",str(a[i])); } //Lista "a" item a item no Console.
echo ("Todos itens de a =", str(a)); //Lista todos os itens de "a" no Console.
//
a = [ for (i = [0:9]) [i*2,i*2] ];
echo ("Valores duplicados de a =", str(a));  //Lista todos os itens de "a" no Console.
//
//Acusa warning porque torna a sobrescrever o objeto "a", mas atualizou também os valores de "a" na linha 5. Vale o momento de geração da árvore de compilação CSG. Ou seja, o fonte do OpenScad é compilado e não interpretado linha a linha.
//
// Como gerar um vetor via loop for com número n de iterações
//
a = [ for (a = [0 : 1 : 180]) [ 20 * cos(a), 20 * sin(a) ] ];
echo ("Valores de \"a\" reais =", str(a)); //Lista todos os itens de "a" no Console.
//
//Vale sempre o valor da última atribuição.
polygon(a);

/*
Avaliação das informações acima pelo ChatGPT

O código e os comentários que você forneceu são úteis para entender como o OpenSCAD lida com variáveis e atribuições. Aqui estão algumas observações importantes que podem ser extraídas desses exemplos:

1.  Sobrescrita de Variáveis: O OpenSCAD permite que você declare variáveis e as sobrescreva. No entanto, é importante notar que sobrescrever uma variável pode causar perda de dados, como ilustrado na primeira iteração do loop onde a é sobrescrito com um valor numérico, resultando em um vetor vazio.

2.  Impressão de Variáveis: Você pode usar a função echo para imprimir o valor das variáveis no console. Isso é útil para depuração e visualização dos dados.

3.  Compilação vs. Interpretação: Como mencionado nos comentários, o OpenSCAD compila o código em uma árvore de compilação CSG (Computational Solid Geometry) antes de renderizar o modelo. Portanto, a ordem de execução das operações pode não ser estritamente linear como em uma linguagem interpretada.

4.  Criação de Vetores: O OpenSCAD permite criar vetores (arrays) de várias maneiras, incluindo a utilização de loops, como no exemplo em que um vetor a é preenchido com valores calculados em um loop.

5.  Última Atribuição Prevalece: Quando uma variável é atribuída várias vezes, o valor atribuído por último prevalece. Por exemplo, no último exemplo, a é sobrescrito com um vetor calculado no loop for, e esse valor é usado na criação do polígono.

Esses conceitos são importantes para entender como o OpenSCAD funciona e como você pode manipular variáveis e dados em seus modelos. O OpenSCAD é uma linguagem de modelagem paramétrica e, portanto, é útil compreender como as atribuições e operações afetam o resultado final do modelo. Seu exemplo também demonstra como você pode criar vetores usando loops, o que pode ser útil para gerar geometria de forma programática.

*/

Coordenadas dos Vértices do Icosaedro Truncado

- Este código em python gera as coordenadas dos vértices de um icosaedro truncado (não regular).

- Um icosaedro truncado regular possui 90 arestas, 60 vértices e 32 faces, sendo 12 pentágonos e 20 hexágonos.

import numpy as np

def format_coordinate(value):
    rounded_value = round(value, 1)
    if rounded_value.is_integer():
        return str(int(rounded_value))
    else:
        return str(rounded_value)

# Definindo os pontos de referência para um icosaedro
phi = (1 + np.sqrt(5)) / 2

icosahedron_vertices = np.array([
    [0, 1, phi],
    [0, 1, -phi],
    [0, -1, phi],
    [0, -1, -phi],
    [1, phi, 0],
    [1, -phi, 0],
    [-1, phi, 0],
    [-1, -phi, 0],
    [phi, 0, 1],
    [phi, 0, -1],
    [-phi, 0, 1],
    [-phi, 0, -1]
])

# Definindo a matriz de truncamento
truncation_matrix = np.array([
    [1, 0, 1],
    [0, 1, 1],
    [-1, 0, 1],
    [0, -1, 1],
    [1, 1, 0],
    [-1, 1, 0],
    [1, -1, 0],
    [-1, -1, 0],
    [1, 0, -1],
    [0, 1, -1],
    [-1, 0, -1],
    [0, -1, -1]
])

# Calculando o centro do icosaedro truncado
center = np.mean(icosahedron_vertices, axis=0)

# Calculando as coordenadas dos vértices dos pentágonos
unique_vertices = []

for i in range(12):
    pentagon_vertices = icosahedron_vertices + truncation_matrix[i]
    pentagon_vertices_center = np.mean(pentagon_vertices, axis=0)
    pentagon_vertices = [
        vertex for vertex in pentagon_vertices if
        np.count_nonzero(vertex == 0) != 2 and
        not (np.all(vertex > 0) and np.all(vertex < 1)) and
        not np.all((np.abs(vertex[0]) > 0 and np.abs(vertex[0]) < 1) or
                   (np.abs(vertex[1]) > 0 and np.abs(vertex[1]) < 1) or
                   (np.abs(vertex[2]) > 0 and np.abs(vertex[2]) < 1))
    ]
    pentagon_vertices = np.unique(pentagon_vertices, axis=0)
    unique_vertices.extend(pentagon_vertices)

# Convertendo para um array numpy para eliminar duplicatas
unique_vertices = np.array(unique_vertices)

# Calculando as distâncias entre os vértices e o centro
distances_to_center = np.linalg.norm(unique_vertices - center, axis=1)

# Encontrando a distância máxima entre os vértices dos pentágonos
max_distance_pentagon = np.max(np.linalg.norm(icosahedron_vertices, axis=1))

# Eliminando os vértices mais próximos do centro do que qualquer vértice dos pentágonos
filtered_vertices = unique_vertices[distances_to_center > max_distance_pentagon]

# Imprimindo as coordenadas dos vértices formatadas com duas vírgulas entre cada valor
for i, vertex in enumerate(filtered_vertices):
    formatted_coords = [format_coordinate(coord) for coord in vertex]
    formatted_coords_str = ', '.join(formatted_coords)
    #print(f"Vértice {i + 1}: [{formatted_coords_str}]")
    print(f"translate ([{formatted_coords_str}]) pnt(0.1);")
   

-Para visualizar a forma aproximada deste sólido geométrico no OpenScad use o código abaixo:

IcosaedroVertices = [
 [10, -10, 26], //0
[10, 10, 26], //1
[0, 20, 26],  //2
[-10, 10, 26], //3
[-10, -10, 26], //4
[0, -20, 26],  //5

[26, -10, -10], //6
[26, -10, 10],  //7
[26, 0, 20],   //8
[26, 10, -10],  //10
[26, 10, 10],  //9
[26, 0, -20],  //11

[10, -10, -26], //12
[10, 10, -26],  //13
[0, 20, -26],  //14
[-10, -10, -26],  //16
[-10, 10, -26],  //15
[0, -20, -26],  //17

[-26, -10, -10], //18
[-26, -10, 10],  //19
[-26, 0, 20],  //20
[-26, 10, -10], //22
[-26, 10, 10],  //21
[-26, 0, -20],  //23

[-20, -26, 0],  //24
[-10, -26, 10],  //25
[10, -26, 10],  //26
[20, -26, 0],   //27
[10, -26, -10],  //28
[-10, -26, -10],  //29

[20, 26, 0],  //30
[10, 26, 10],  //31
[-10, 26, 10],  //33
[-20, 26, 0],  //32
[-10, 26, -10],  //34
[10, 26, -10],  //35

/*[-20, 16, 10],  //36 triângulos internos
[-10, 20, 16],  //37
[-16, 10, 20],  //38

[20, -16, 10],   //39
[10, -20, 16],   //40
[16, -10, 20],   //41

[20, 16, -10],   //42
[10, 20, -16],  //43
[16, 10, -20],  //44

[20, 16, 10],   //45
[10, 20, 16],   //46
[16, 10, 20],   //47

[-20, -16, 10],  //48
[-10, -20, 16],  //49
[-16, -10, 20],  //50

[20, -16, -10],  //51
[10, -20, -16],  //52
[16, -10, -20],  //53

[-20, -16, -10],  //54
[-10, -20, -16],  //55
[-16, -10, -20],  //56

[-20, 16, -10],  //57
[-10, 20, -16],  //58
[-16, 10, -20]];  //59 */
];
 
 IcosaedroFaces = [
  [0,1,2,3,4,5],  // hexágonos centrais
  [6,7,8,10,9,11],  
  [12,13,14,16,15,17],
  [18,19,20,22,21,23],
  [24,25,26,27,28,29],  
  [31,32,33,34,35,30],
 /* [36,37,38], // triângulos internos
  [39,40,41],
  [42,43,44],
  [45,46,47],
  [48,49,50],
  [51,52,53],
  [54,55,56],
  [57,58,59],
  [2,37,46],
  [5,40,49],
  [14,43,58],
  [17,52,55],
  [24,48,54],
  [27,39,51],
  [11,44,53],
  [23,56,59],
  [8,41,47],
  [20,50,38],
  [30,42,45],
  [33,36,57]];*/
  [2,31,32], // triângulos externos
  [5,25,26],
  [8,0,1],
  [11,12,13],
  [14,34,35],
  [17,28,29],
  [20,3,4],
  [23,15,16],
  [24,18,19],
  [27,6,7],
  [30,9,10],
  [33,21,22],
  [2,33,20], // hexágonos laterais abertos
  [2,30,8],
  [5,8,27],
  [5,20,24],
  [11,14,30],
  [11,17,27],
  [17,23,24],
  [14,23,33],
  //[5,26,27,7,20,4],
 ];
 
polyhedron( IcosaedroVertices, IcosaedroFaces );
color ("blue") {
translate ([10, -10, 26]) linear_extrude(8) text("0", 5); //0
translate ([10, 10, 26]) linear_extrude(8) text("1", 5); //1
translate ([0, 20, 26]) linear_extrude(8) text("2", 5);  //2
translate ([-10, 10, 26]) linear_extrude(8) text("3", 5); //3
translate ([-10, -10, 26]) linear_extrude(8) text("4", 5); //4
translate ([0, -20, 26]) linear_extrude(8) text("5", 5);  //5

translate ([26, -10, -10]) linear_extrude(8) text("6", 5); //6
translate ([26, -10, 10]) linear_extrude(8) text("7", 5);  //7
translate ([26, 0, 20]) linear_extrude(8) text("8", 5);   //8
translate ([26, 10, -10]) linear_extrude(8) text("10", 5);  //10
translate ([26, 10, 10]) linear_extrude(8) text("9", 5);  //9
translate ([26, 0, -20]) linear_extrude(8) text("11", 5);  //11

translate ([10, -10, -26]) linear_extrude(8) text("12", 5); //12
translate ([10, 10, -26]) linear_extrude(8) text("13", 5);  //13
translate ([0, 20, -26]) linear_extrude(8) text("14", 5);  //14
translate ([-10, -10, -26]) linear_extrude(8) text("16", 5);  //16
translate ([-10, 10, -26]) linear_extrude(8) text("15", 5);  //15
translate ([0, -20, -26]) linear_extrude(12) text("17", 8);  //17

translate ([-26, -10, -10]) linear_extrude(8) text("18", 5); //18
translate ([-26, -10, 10]) linear_extrude(8) text("19", 5);  //19
translate ([-26, 0, 20]) linear_extrude(8) text("20", 5);  //20
translate ([-26, 10, -10]) linear_extrude(8) text("22", 5); //22
translate ([-26, 10, 10]) linear_extrude(8) text("21", 5);  //21
translate ([-26, 0, -20]) linear_extrude(12) text("23", 8);  //23

translate ([-20, -26, 0]) linear_extrude(8) text("24", 5);  //24
translate ([-10, -26, 10]) linear_extrude(8) text("25", 5);  //25
translate ([10, -26, 10]) linear_extrude(8) text("26", 5);  //26
translate ([20, -26, 0]) linear_extrude(8) text("27", 5);   //27
translate ([10, -26, -10]) linear_extrude(8) text("28", 5);  //28
translate ([-10, -26, -10]) linear_extrude(8) text("29", 5);  //29

translate ([20, 26, 0]) linear_extrude(8) text("30", 5);  //30
translate ([10, 26, 10]) linear_extrude(8) text("31", 5);  //31
translate ([-10, 26, 10]) linear_extrude(8) text("32", 5);  //32
translate ([-20, 26, 0]) linear_extrude(8) text("33", 5);  //33
translate ([-10, 26, -10]) linear_extrude(8) text("34", 5);  //34
translate ([10, 26, -10]) linear_extrude(8) text("35", 5);  //35
}

Controle Liga/Desliga para CAPS, NUM e SCROLL

- A ideia é usar uma placa de teclado USB como interface alternativa para se criar 3 chaves liga/desliga controladas via computador.

- Segue abaixo um tutorial de produção do programa e o código fonte.

- Passo a passo para implementar e testar o código que permite ligar e desligar os LEDs Caps Lock, Num Lock e Scroll Lock usando um teclado padrão no Linux.

Passo 1: Instalar Dependências

Garanta que as dependências corretas estejam instaladas. O pacote libevdev-dev é necessário para acessar os LEDs via sysfs.

Para instalar o pacote libevdev-dev no Ubuntu, você pode usar o seguinte comando:

bash

sudo apt update
sudo apt install libevdev-dev

Passo 2: Criar o Código

Crie um novo arquivo de código-fonte chamado ligadesliga_leds.c e cole o código C fornecido anteriormente no arquivo.

Passo 3: Compilar o Código

Abra um terminal e navegue até o diretório onde você criou o arquivo ligadesliga_leds.c. Em seguida, execute o seguinte comando para compilar o código:

bash

sudo gcc -o ligadesliga_leds ligadesliga_leds.c -levdev

Isso compilará o código e gerará um executável chamado ligadesliga_leds.

Passo 4: Executar o Programa

Agora, você pode executar o programa usando o comando sudo para garantir que tenha as permissões necessárias para acessar os LEDs:

bash

sudo ./ligadesliga_leds

Passo 5: Testar o Programa

Após executar o programa, ele exibirá instruções no terminal. Pressione as teclas 'c', 'n' ou 's' para alternar o brilho dos LEDs Caps Lock, Num Lock e Scroll Lock, respectivamente. Pressione 'x' para sair do programa.

Lembre-se de que a capacidade de controlar os LEDs Caps Lock, Num Lock e Scroll Lock depende do seu hardware e do suporte do sistema operacional. Pode haver variações entre sistemas e distribuições Linux.

 

CÓDIGO FONTE DO PROGRAMA

#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
#include <unistd.h>

#define CAPSLOCK_PATH "/sys/class/leds/input4::capslock/brightness"
#define NUMLOCK_PATH "/sys/class/leds/input4::numlock/brightness"
#define SCROLLLOCK_PATH "/sys/class/leds/input4::scrolllock/brightness"

int main() {
    struct termios old_settings, new_settings;
    char input;

    tcgetattr(STDIN_FILENO, &old_settings);
    new_settings = old_settings;
    new_settings.c_lflag &= ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, &new_settings);

    printf("Pressione 'c' para alternar o LED Caps Lock.\n");
    printf("Pressione 'n' para alternar o LED Num Lock.\n");
    printf("Pressione 's' para alternar o LED Scroll Lock.\n");
    printf("Pressione 'x' para sair.\n");

    while (1) {
        input = getchar();
        if (input == 'x') {
            break;
        } else if (input == 'c') {
            FILE* capslock_file = fopen(CAPSLOCK_PATH, "r+");
            if (capslock_file) {
                char value;
                fscanf(capslock_file, "%c", &value);
                fseek(capslock_file, 0, SEEK_SET);
                fprintf(capslock_file, "%c", (value == '0') ? '1' : '0');
                fclose(capslock_file);
            }
        } else if (input == 'n') {
            FILE* numlock_file = fopen(NUMLOCK_PATH, "r+");
            if (numlock_file) {
                char value;
                fscanf(numlock_file, "%c", &value);
                fseek(numlock_file, 0, SEEK_SET);
                fprintf(numlock_file, "%c", (value == '0') ? '1' : '0');
                fclose(numlock_file);
            }
        } else if (input == 's') {
            FILE* scrolllock_file = fopen(SCROLLLOCK_PATH, "r+");
            if (scrolllock_file) {
                char value;
                fscanf(scrolllock_file, "%c", &value);
                fseek(scrolllock_file, 0, SEEK_SET);
                fprintf(scrolllock_file, "%c", (value == '0') ? '1' : '0');
                fclose(scrolllock_file);
            }
        }
    }

    tcsetattr(STDIN_FILENO, TCSANOW, &old_settings);
    return 0;
}