Robótica
Como encontrar a posição final de um braço robótico com 3 servos

Como encontrar a posição final de um braço robótico com 3 servos

Um braço robótico é uma estrutura mecânica articulada que pode ser controlada por meio de servos. Cada servo é responsável por controlar o movimento em um eixo específico, como o eixo X, Y ou Z. Para encontrar a posição final do braço robótico nos eixos X e Y, é necessário utilizar uma fórmula que leve em consideração os ângulos de rotação de cada servo.

Fórmula para encontrar a posição final

A fórmula para encontrar a posição final de um braço robótico com 3 servos nos eixos X e Y é baseada na trigonometria. Vamos supor que os ângulos de rotação dos servos sejam representados por θ1, θ2 e θ3, respectivamente.

Para o eixo X:

X = L1 * cos(θ1) + L2 * cos(θ1 + θ2) + L3 * cos(θ1 + θ2 + θ3)

Para o eixo Y:

Y = L1 * sin(θ1) + L2 * sin(θ1 + θ2) + L3 * sin(θ1 + θ2 + θ3)

Onde:

  • L1, L2 e L3 são os comprimentos dos segmentos do braço robótico;
  • θ1, θ2 e θ3 são os ângulos de rotação dos servos.

Exemplo prático

Vamos supor que o braço robótico tenha os seguintes comprimentos de segmentos:

  • L1 = 10 cm
  • L2 = 15 cm
  • L3 = 20 cm

E que os ângulos de rotação dos servos sejam:

  • θ1 = 45°
  • θ2 = 30°
  • θ3 = 60°

Substituindo os valores na fórmula, temos:

X = 10 * cos(45°) + 15 * cos(45° + 30°) + 20 * cos(45° + 30° + 60°)

Y = 10 * sin(45°) + 15 * sin(45° + 30°) + 20 * sin(45° + 30° + 60°)

Calculando os valores, obtemos:

X ≈ 32,07 cm

Y ≈ 31,75 cm

Portanto, a posição final do braço robótico nos eixos X e Y é aproximadamente (32,07 cm, 31,75 cm).

Considerações finais

A fórmula apresentada permite encontrar a posição final de um braço robótico nos eixos X e Y com base nos ângulos de rotação dos servos e nos comprimentos dos segmentos do braço. É importante lembrar que essa fórmula assume que o braço robótico opera em um plano bidimensional e que não há interferências ou restrições adicionais.

Além disso, é fundamental ter em mente que a precisão da posição final depende da precisão dos ângulos de rotação dos servos e dos comprimentos dos segmentos do braço. Qualquer imprecisão ou erro na medição ou no controle dos servos pode afetar a posição final do braço robótico.

Em resumo, a fórmula apresentada é uma ferramenta útil para calcular a posição final de um braço robótico nos eixos X e Y, mas é necessário ter cuidado ao utilizar e interpretar os resultados.

Sem categoria
Trabalho processamento de sinais

Conforme materia

https://github.com/raphaelPinheiro26/Processamento-de-Sinais-e-Imagens—Fatec-RP/blob/main/Trabalhos/Trabalho_01_Introdu%C3%A7%C3%A3o_ao_Python.ipynb

Exemplo de trabalho

Aluno: Marcelo Maurin Martins

Grupo: Sem grupo

1 – Senha Pronto Atendimento Escreva um programa que destribua senhas aos pacientes que chegam no Atendimento de Emergência de um Hospital. Deverá seguir os seguintes critérios

O hospital possui 3 filas (ortopedia, Atendimento Comum e Atendimento Prioritário) A senha será composta por 3 letras indicando a fila e 3 algarismos indicando a posição do paciente na fila (AAA-000) A senha de atendimento preferêncial irá iniciar com as letras ATP A senha de atendimento comum irá iniciar com as letras ATC A senha de atendimento para ortopedia irá iniciar com as letras ORT Antes de finalizar o programa, o mesmo deverá imprimir a lista de senhas geradas em cada fila

In [1]:

# Função para gerar senhas
def gerar_senha(fila, tipo, contador):
    if tipo == "prioritaria":
        prefixo = "ATP"
    elif tipo == "comum":
        prefixo = "ATC"
    elif tipo == "ortopedia":
        prefixo = "ORT"
    else:
        raise ValueError("Tipo de fila inválido")

    senha = f"{prefixo}-{contador:03d}"
    fila.append(senha)

# Filas
ortopedia = []
atendimento_comum = []
atendimento_prioritario = []

# Função para imprimir senhas em uma fila
def imprimir_senhas(fila, nome):
    print(f"Senhas na fila {nome}:")
    for senha in fila:
        print(senha)

# Simulação de um estudante aprendendo Python
print("Bem-vindo ao sistema de distribuição de senhas do hospital!")
print("Escolha o tipo de atendimento:")
print("1 - Ortopedia")
print("2 - Atendimento Comum")
print("3 - Atendimento Prioritário")

opcao = input("Digite o número correspondente ao tipo de atendimento desejado: ")

if opcao == "1":
    gerar_senha(ortopedia, "ortopedia", len(ortopedia))
    imprimir_senhas(ortopedia, "Ortopedia")
elif opcao == "2":
    gerar_senha(atendimento_comum, "comum", len(atendimento_comum))
    imprimir_senhas(atendimento_comum, "Atendimento Comum")
elif opcao == "3":
    gerar_senha(atendimento_prioritario, "prioritaria", len(atendimento_prioritario))
    imprimir_senhas(atendimento_prioritario, "Atendimento Prioritário")
else:
    print("Opção inválida! Por favor, escolha uma opção válida.")
Bem-vindo ao sistema de distribuição de senhas do hospital!
Escolha o tipo de atendimento:
1 - Ortopedia
2 - Atendimento Comum
3 - Atendimento Prioritário
Digite o número correspondente ao tipo de atendimento desejado: 1
Senhas na fila Ortopedia:
ORT-000

Nota complementar

Fiz um outro programa em uma terceira linguagem aderente ao exercicio.

2 – Horário de Medicamentos Faça um programa que a equipe de enfermagem entre com as informações do paciente para lembra-los do horário da medicação com as seguintes recomendações:

Dados do Paciente – Nome Completo, Data de Nascimento e Tipo do sangue Dados da Medicação – Nome da Medicação, Classificação, e horário para aplicação A Classificação do Medicamento será – medicamento comum, Psicotrópico, Alto risco, Alto custo e Psicotrópicos Ao chegar nos horários do medicamento, um aviso deverá aparecer na tela o horário pode ser simulado mas se for usado a hora do computador ganhará mais pontos Pelo menos 2 horários distintos para alarmar

In [ ]:

import datetime
import time

# Função para calcular a idade a partir da data de nascimento
def calcular_idade(data_nascimento):
    hoje = datetime.date.today()
    ano_nascimento = data_nascimento.year
    idade = hoje.year - ano_nascimento
    if hoje.month < data_nascimento.month or (hoje.month == data_nascimento.month and hoje.day < data_nascimento.day):
        idade -= 1
    return idade

# Função para formatar a data de nascimento
def formatar_data(data):
    return data.strftime("%d/%m/%Y")

# Função para verificar se é hora da medicação
def verificar_horario_med(med_horario, hora_atual):
    for horario in med_horario:
        if hora_atual.hour == horario.hour and hora_atual.minute == horario.minute:
            return True
    return False

# Dados do paciente
nome = input("Digite o nome completo do paciente: ")
data_nascimento = datetime.datetime.strptime(input("Digite a data de nascimento do paciente (formato: dd/mm/aaaa): "), "%d/%m/%Y")
tipo_sangue = input("Digite o tipo sanguíneo do paciente: ")

# Dados da medicação
nome_med = input("Digite o nome da medicação: ")
classificacao_med = input("Digite a classificação da medicação (comum, psicotrópico, alto risco, alto custo, psicotrópicos): ").lower()
horarios = []
for i in range(2):
    hora = datetime.datetime.strptime(input(f"Digite o horário {i+1} para aplicação da medicação (formato: hh:mm): "), "%H:%M")
    horarios.append(hora.time())

# Imprimir informações do paciente e da medicação
print("\n--- Informações do Paciente ---")
print("Nome:", nome)
print("Data de Nascimento:", formatar_data(data_nascimento))
print("Idade:", calcular_idade(data_nascimento), "anos")
print("Tipo Sanguíneo:", tipo_sangue)

print("\n--- Informações da Medicação ---")
print("Nome da Medicação:", nome_med)
print("Classificação da Medicação:", classificacao_med.capitalize())
print("Horários de Aplicação:", ", ".join(map(lambda x: x.strftime("%H:%M"), horarios)))

# Variável para controlar se a mensagem já foi exibida
mensagem_exibida = False

# Simulação do tempo para verificar o horário da medicação
print("\nSimulando o tempo para verificar o horário da medicação...")

while True:
    hora_atual = datetime.datetime.now().time()
    if verificar_horario_med(horarios, hora_atual) and not mensagem_exibida:
        print("Hora da medicação! Não se esqueça de tomar o medicamento:", nome_med)
        mensagem_exibida = True
    elif not verificar_horario_med(horarios, hora_atual):
        mensagem_exibida = False
    # Aguardar 1 minuto antes de verificar novamente
    time.sleep(60)
Digite o nome completo do paciente: marcelo
Digite a data de nascimento do paciente (formato: dd/mm/aaaa): 20/12/1999
Digite o tipo sanguíneo do paciente: a
Digite o nome da medicação: paracetamol
Digite a classificação da medicação (comum, psicotrópico, alto risco, alto custo, psicotrópicos): 12:56
Digite o horário 1 para aplicação da medicação (formato: hh:mm): 12:57
Digite o horário 2 para aplicação da medicação (formato: hh:mm): 12:58

--- Informações do Paciente ---
Nome: marcelo
Data de Nascimento: 20/12/1999
Idade: 24 anos
Tipo Sanguíneo: a

--- Informações da Medicação ---
Nome da Medicação: paracetamol
Classificação da Medicação: 12:56
Horários de Aplicação: 12:57, 12:58

Simulando o tempo para verificar o horário da medicação...
Hora da medicação! Não se esqueça de tomar o medicamento: paracetamol

3 – Inventário de Equipamentos Biomédicos Faça um programa que tenha dois modos acessados por um menu. O primeiro módulo é de cadastro de equipamentos médicos e o segundo é de consulta dos equipamentos cadastrados. Siga as instruções:

O software deverá ter um menu principal onde o usuáriopoderá acessar as duas opções Na parte de cadastramento o usuário deverá entrar com os dados nos campos: Nome do Equipamento, TAG de identificação, e local de uso. A tag é um jeito mais fácil de identificar os equipamentos. exemplo:3° monitor multiparemetro da UTI -> UTI-MNP-0003 Porém vc pode criar a sua forma No modo de consulta deverá ter 3 formas de consulta (TAG, Tipo de equipamento e Local de uso) Ao consultar um item por uma das formas, as outras informações referente a este item taambém deverá aparecer

In [ ]:

# Função para cadastrar um novo equipamento
def cadastrar_equipamento(inventario):
    print("\n--- Cadastro de Equipamento ---")
    nome = input("Digite o nome do equipamento: ")
    local = input("Digite o local de uso do equipamento: ")
    tag = input("Digite a TAG de identificação do equipamento: ")
    inventario.append({"Nome": nome, "Local": local, "TAG": tag})
    print("Equipamento cadastrado com sucesso!")

# Função para consultar equipamentos por TAG
def consultar_por_tag(inventario):
    tag_consulta = input("Digite a TAG do equipamento que deseja consultar: ")
    encontrado = False
    for equipamento in inventario:
        if equipamento["TAG"] == tag_consulta:
            print("\n--- Informações do Equipamento ---")
            print("Nome:", equipamento["Nome"])
            print("Local de Uso:", equipamento["Local"])
            print("TAG:", equipamento["TAG"])
            encontrado = True
            break
    if not encontrado:
        print("Equipamento não encontrado!")

# Função para consultar equipamentos por Tipo
def consultar_por_tipo(inventario):
    tipo_consulta = input("Digite o tipo de equipamento que deseja consultar: ")
    encontrado = False
    for equipamento in inventario:
        if tipo_consulta in equipamento["TAG"]:
            print("\n--- Informações do Equipamento ---")
            print("Nome:", equipamento["Nome"])
            print("Local de Uso:", equipamento["Local"])
            print("TAG:", equipamento["TAG"])
            encontrado = True
    if not encontrado:
        print("Nenhum equipamento desse tipo encontrado!")

# Função para consultar equipamentos por Local
def consultar_por_local(inventario):
    local_consulta = input("Digite o local de uso que deseja consultar: ")
    encontrado = False
    for equipamento in inventario:
        if equipamento["Local"].lower() == local_consulta.lower():
            print("\n--- Informações do Equipamento ---")
            print("Nome:", equipamento["Nome"])
            print("Local de Uso:", equipamento["Local"])
            print("TAG:", equipamento["TAG"])
            encontrado = True
    if not encontrado:
        print("Nenhum equipamento encontrado nesse local!")

# Função para exibir o menu principal
def exibir_menu():
    print("\n--- Menu Principal ---")
    print("1. Cadastrar Equipamento")
    print("2. Consultar Equipamentos")
    print("3. Sair")

# Lista para armazenar os equipamentos cadastrados
inventario = []

# Loop principal do programa
while True:
    exibir_menu()
    opcao = input("Escolha uma opção: ")

    if opcao == "1":
        cadastrar_equipamento(inventario)
    elif opcao == "2":
        print("\n--- Opções de Consulta ---")
        print("1. Por TAG")
        print("2. Por Tipo de Equipamento")
        print("3. Por Local de Uso")
        consulta_opcao = input("Escolha uma opção de consulta: ")
        if consulta_opcao == "1":
            consultar_por_tag(inventario)
        elif consulta_opcao == "2":
            consultar_por_tipo(inventario)
        elif consulta_opcao == "3":
            consultar_por_local(inventario)
        else:
            print("Opção de consulta inválida!")
    elif opcao == "3":
        print("Saindo do programa...")
        break
    else:
        print("Opção inválida! Por favor, escolha uma opção válida.")

In [ ]:

 
Analise de Circuito
Atividade 1 – Analise de Circuito

Atividade 1 de Analise de Circuito

1 – O desenho abaixo representa um circuito elétrico composto por resistores ôhmicos, um gerador ideal e um receptor ideal. Qual a potência elétrica dissipada no resistor de 4 Ω?

Segunda lei de Kirchhoff.

8 + 3.i + (-6) + 4.i + 3.i = 0

8 -6 + 3i +4i +3i = 0

10i = -2

i = -0.2A

(Sentido Invertido )

2- Determine os valores das correntes elétricas i1, i2 e i3.

Selecionando a nó.

Malha 1 => -6 +5i -4 =0 => -10 = -5i => 5i = 10 => i = 2A

Malha 2 => 4 + 4i -8 = 0 => -4i = -4 => 4i = 4 => i = 1A

Soma das correntes itotal = 2 + 1 => iTotal = 3A

Python
Debugando em Python

O debug de script em python é bem simples.

Entre o seguinte import, no bloco que quer debugar.

import pdb

Para inserir um ponto de parada use o comando.

pdb.set_trace()

Desta forma é possível realizar um debug por linha de comando semelhante ao gdb do c.

Para rodar o python em modo debug use o comando:,

python -m pdb [script.py]

Irei em momento oportuno mostrar maiores detalhes desta técnica.

Ciência de Dados IA
Kaggle: Uma Plataforma para Obter Dados de Diversas Fontes

Vivemos em uma era em que a quantidade de dados gerados diariamente é imensa. Empresas, organizações e até mesmo indivíduos têm acesso a uma quantidade sem precedentes de informações. No entanto, a grande questão é: como podemos aproveitar ao máximo esses dados para obter insights valiosos?

É aí que entra o Kaggle, uma plataforma online que se tornou referência quando se trata de análise de dados. O Kaggle é um verdadeiro tesouro para cientistas de dados, entusiastas e profissionais que buscam dados confiáveis e diversificados.

O que é o Kaggle?

O Kaggle é uma comunidade online que reúne cientistas de dados e entusiastas de todo o mundo. Seu principal objetivo é fornecer um espaço onde as pessoas possam compartilhar, colaborar e competir em projetos de análise de dados.

Uma das características mais interessantes do Kaggle é a sua vasta coleção de conjuntos de dados. Esses conjuntos são disponibilizados por empresas, organizações governamentais e até mesmo por outros membros da comunidade. Isso significa que você pode encontrar dados sobre praticamente qualquer assunto que possa imaginar.

Como usar o Kaggle?

Para começar a usar o Kaggle, basta visitar o site https://www.kaggle.com/ e criar uma conta gratuita. Depois de fazer isso, você terá acesso a uma variedade de recursos e ferramentas.

Uma das principais vantagens de usar o Kaggle é a capacidade de participar de competições de análise de dados. Essas competições são uma ótima maneira de testar suas habilidades e aprender com outros membros da comunidade. Além disso, elas muitas vezes oferecem prêmios em dinheiro ou oportunidades de emprego para os melhores colocados.

Outro recurso interessante do Kaggle é o Kernels. Os Kernels são notebooks interativos que permitem que você crie, execute e compartilhe código Python. Isso é especialmente útil para aqueles que estão começando na área de análise de dados e desejam aprender com exemplos práticos.

Por que usar o Kaggle?

O Kaggle é uma ferramenta poderosa para qualquer pessoa interessada em análise de dados. Aqui estão algumas razões para considerar o uso dessa plataforma:

  • Ampla variedade de conjuntos de dados: o Kaggle oferece uma enorme quantidade de dados sobre os mais diversos temas, permitindo que você encontre exatamente o que precisa para o seu projeto.
  • Comunidade ativa: o Kaggle é frequentado por uma comunidade de cientistas de dados e entusiastas que estão sempre dispostos a compartilhar conhecimento e ajudar uns aos outros.
  • Recursos educacionais: além das competições e Kernels, o Kaggle também oferece cursos e tutoriais gratuitos para quem deseja aprender mais sobre análise de dados.

Em resumo, o Kaggle é uma plataforma essencial para quem trabalha com análise de dados. Seja você um cientista de dados experiente ou apenas um entusiasta, o Kaggle oferece uma infinidade de recursos e oportunidades para aprimorar suas habilidades e encontrar os dados necessários para seus projetos.

IA Python
Keras – Topologia

Topologia baseada em empilhamento

Modelo sequencial

  • Densa – Totalmente conectada
  • Embedding –
  • Dropout – Remove conexões aleatórias

Função de ativação

Cada camada tem uma função de ativação.

Entre elas:

  • relu – camadas intermediarias ou ocultas, pois mostra os valores reais.
  • sigmoid – Te da um valor de probabilidade 0-1

Hiper parâmetros

Afeta a performace da rede.

  • LOSS – função de perda (mean_squared_error)
  • Optimizer – Otimizador de ajuste de pesos da rede. ADAM (stochastic gradient descent)
  • Metrics – Metrica de previsão para apurar se esta certo.

Exemplo de modelo

modelo = Sequental()

modelo.add(tipo)

modelo.add(Dropout(0.2))

modelo.add(tipo)

modelo.add(Dropout(0.2))

modelo.add(tipo)

modelo.add(Dropout(0.2))

Tipos:

#camadas intermediarias

Dense(output_dim=10, input_dim=X_train.shape[1], activation=’relu’))

#Camada de finalização

Dense(output_dim=10, input_dim=X_train.shape[1], activation=’sigmoid’))

C/C++ Desenvolvimento de Software Python
Desenvolvimento com KINECT

No primeiro artigo, apresentei a instalação do kinect no ubuntu.

Artigo tratando o kinect no ubuntu

Agora iremos falar e mostrar um pouco sobre seu desenvolvimento.

GITHUB do Projeto

O projeto do libfreenect fica neste repositório.

https://github.com/OpenKinect/libfreenect.git

Site do Projeto

https://openkinect.org/wiki/Low_Level

Meu GITHUB

Ja os meus conjuntos de testes, inclusive os apresentados nos artigos relacionados, podem ser vistos, neste repositório.

https://github.com/marcelomaurin/kinect

Instalação de desenvolvimento

O processo de instalação completo foi visto no artigo anterior, porem para efeito de desenvolvimento os pacotes necessários são:

sudo apt install libudev-dev
sudo apt install libglfw3-dev
sudo apt install freeglut3-dev
sudo apt install libfreenect-dev

Sendo os 3 pacotes iniciais, apenas apoio, e o libfreenect-dev realmente a lib necessária.

Hello World da Biblioteca

Neste primeiro projeto, pouca coisa faremos, apenas iremos compilar identificando o device.

#include <stdio.h>
#include <stdlib.h>
#include <libfreenect.h>

freenect_context *f_ctx;
freenect_device *f_dev;
int user_device_number = 0; // Normalmente 0 se você tiver apenas um Kinect

void depth_cb(freenect_device *dev, void *v_depth, uint32_t timestamp) {
    // Callback para dados de profundidade - não usado neste exemplo
}

void rgb_cb(freenect_device *dev, void *rgb, uint32_t timestamp) {
    // Salva uma imagem RGB capturada pelo Kinect
    FILE *image = fopen("output_image.ppm", "wb");
    if (image == NULL) {
        printf("Erro ao abrir o arquivo para escrita\n");
        return;
    }
    fprintf(image, "P6\n# Kinect RGB test\n640 480\n255\n");
    fwrite(rgb, 640*480*3, 1, image);
    fclose(image);
    printf("Imagem salva como output_image.ppm\n");

    // Depois de salvar a imagem, podemos sair do loop principal
    freenect_stop_video(dev);
    freenect_close_device(dev);
    freenect_shutdown(f_ctx);
    exit(0);
}

int main() {
    if (freenect_init(&f_ctx, NULL) < 0) {
        printf("freenect_init() falhou\n");
        return 1;
    }

    if (freenect_open_device(f_ctx, &f_dev, user_device_number) < 0) {
        printf("Não foi possível abrir o dispositivo\n");
        freenect_shutdown(f_ctx);
        return 1;
    }

    freenect_set_depth_callback(f_dev, depth_cb);
    freenect_set_video_callback(f_dev, rgb_cb);
    freenect_set_video_mode(f_dev, freenect_find_video_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_VIDEO_RGB));

    freenect_start_video(f_dev);

    while (freenect_process_events(f_ctx) >= 0) {
        // Processa eventos do Kinect até que a captura de imagem seja concluída
    }

    return 0;
}

Neste exemplo o programa pega o kinect e tira uma foto, salvando na maquina local.

Vamos entender o código.

A freenect_init inicia a api.

A próxima função freenect_open_device, abre o device conforme o número que estiver descrito. Isso permite abrir mais de um kinect na mesma maquina.

As funções freenect_set_depth_callback e freenect_set_video_callback criam funções de callback, para controle, se voce não sabe o que é leia este artigo:

A função freenect_set_video_mode indica os parâmetros de resolução.

Por ultimo a função freenect_start_video, dá inicio ao kinect que aciona o callback quando pronto.

Makefile

Criamos aqui o arquivo de compilação do projeto.

CC=gcc
CFLAGS=-c -Wall -I/usr/include/libfreenect
LDFLAGS=-L/usr/lib/x86_64-linux-gnu -lfreenect
SOURCES=kinect.c
OBJECTS=$(SOURCES:.c=.o)
EXECUTABLE=kinect

all: $(SOURCES) $(EXECUTABLE)

$(EXECUTABLE): $(OBJECTS) 
	$(CC) $(OBJECTS) -o $@ $(LDFLAGS)

.c.o:
	$(CC) $(CFLAGS) $< -o $@

clean:
	rm -f $(OBJECTS) $(EXECUTABLE)

Perceba aqui que o pulo do gato neste makefile, é a inclusão da pasta /usr/lib/x86_64-linux-gnu que é onde a lib se encontra. Bem como a /usr/include/libfreenect que é onde o header se encontra.

Compilando o projeto

Para compilar esse projeto, é necessário apenas rodar o script na pasta src do ubuntu:

make all

Compilando o projeto

Rodando o programa

Agora iremos rodar o programa, isso é a parte mais simples.

Ao rodar, ele captura uma foto, e salva, conforme apresentado.

Foto capturada pelo kinect.

C/C++ srvOuve
Reconhecimento de Voz ONLINE no srvOuve
Reconhecimento de voz usando o srvOuve, permite ouvir o que se diz.

O srvOuve, é um projeto de minha autoria, que permite criar aplicação de Voz para Texto. Neste projeto, iremos utilizar várias abordagens diferentes, para criar uma aplicação para atender essa finalidade.

Neste primeiro projeto finalizado, criamos um serviço de voz para texto que precisa ser online.

GITHUB

https://github.com/marcelomaurin/srvOuve

Vantagem

O projeto srvOuve, permite utilizar diversos serviços diferentes, ouvindo tanto online como offline, unificando assim a forma de obter esses serviços em um único canal.

Permitindo criar integrações mais ageis.

No exemplo do vídeo usamos o MNote como ferramenta de integração. Onde ele recebe o texto “escutado” pelo srvOuve e repassa ao CHATGPT, permitindo assim que esse responda, e depois convertendo em texto de voz, através do srvFalar, outro projeto de minha autoria.

pt_BRPortuguese