UNIVERSIDAD DE LAS FUERZAS ARMADAS ESPE

INGENIERÍA MECATRÓNICA
Tecnologías de Software Aplicadas a Sistemas Mecatrónicos
PRUEBA PARCIAL
Integrantes:
• Curipallo Yanque Deysi Geomara
• Semblantes Aguirre Javier Eduardo
• Evelin Katherine Quishpe Sangoquiza
• Chuqui Llamba Alex Fabricio
Docente: Ing. Edwin Alejandro Caizalitin Quinaluisa
Nrc: 3186

1) Elabore un SDTR a través de programación por hilos(threading) en el que se

muestre el desarrollo de 5 funciones distintas que trabajen al mismo tiempo
- Contador que empiece en 0 hasta 15 (thread 1)
- Transformación de a binario del contador (thread 2)
- Si el número es par elevar al cuadrado, caso contrario mostrar 0 (thread 3)
- Factorial de los números entre 1 y 15
- La palabra de los números del 1- 15
CÓDIGO:
import time
import threading

def contar_normal():
'NORMAL'
contador = 0
while contador<15:
contador+=1
print(contador)
time.sleep(0.2)

def transformacion():
'decimal a binario'
contador = 0
while contador<15:
contador+=1
binario=bin(contador)
print(' ',format(contador,'0b'))
time.sleep(0.2)

def par():
contador = 0
while contador<15:
contador+=1
 resto= contador%2
if resto==0:
print(' ',contador**(2))
time.sleep(0.2)
else:
print(' ',0)
time.sleep(0.2)

def contar_factorial():
'Factorial'
contador = 1
contador2 = 1
mul=1
while True:
while contador2 <= 15:
mul*=contador2
print(' ',mul)
time.sleep(0.2)
contador2+=1
contador+=1

def letras():
contador = 0
while contador<=15:
contador+=1
if contador== 1:
print('
',"UNO")
if contador== 2:
print('
',"DOS")
if contador== 3:
print('
',"TRES")
if contador== 4:
print('
',"CUATRO")
if contador== 5:
print('
',"CINCO")
if contador== 6:
print('
',"SEIS")
if contador== 7:
 print('
',"SIETE")
if contador== 8:
print('
',"OCHO")
if contador== 9:
print('
',"NUEVE")
if contador== 10:
print('
',"DIEZ")
if contador== 11:
print('
',"ONCE")
if contador== 12:
print('
',"DOCE")
if contador== 13:
print('
',"TRECE")
if contador== 14:
print('
',"CATORCE")
if contador== 15:
print('
',"QUINCE")
time.sleep(0.2)

p1 = threading.Thread(name='HILO 1', target=contar_normal)

p2 = threading.Thread(name='HILO 2', target=transformacion)
p3 = threading.Thread(name='HILO 3', target=par)
p4 = threading.Thread(name='HILO 4', target= contar_factorial)
p5 = threading.Thread(name='HILO 5', target=letras)

p1.start()
p2.start()
p3.start()
p4.start()
p5.start()

p1.join()
p2.join()
p3.join()
p4.join()
p5.join()

SALIDA DE PANTALLA
EXPLICACIÓN:
Para poder realizar una programación por hilos debemos importar las librerías de nombre
time y threading, para el contador de 0 a 15 creamos un método de nombre contar norma
donde debemos inicializar la variable contador en 0 pues esta ingresara a un ciclo while hasta
conseguir el valor de 15, los mismos que se verán reflejados en la salida de pantalla, para la
transformación de decimal a binario declaramos el mismo contador y ciclo while de 0 a 15
para obtener los datos necesitados utilizamos el comando “ bin” que automáticamente nos
entrega el equivalente binario del número deseado, para detectar números pares e impares a
los valores del contador dividimos para 0 y si su resto es 0 es un valor par y para que se
refleje en la pantalla debe estar elevado al cuadrado y en caso de que la condición no se
cumpla en su lugar aparecerá un 0, para los números factoriales declaramos dos contadores y
una variable mul inicializados en 1 los cuales utilizamos un while True, después empleamos
un contador hasta 15 mientras que la variable mul se multiplicará con el contador 2 y de esta
manera imprimimos los valores factoriales, después de cada proceso de va aumentando en
uno cada contador para cumplir la condición, por último para ver los nombre de los números
creamos un contador con un ciclo while hasta 15 y creamos las condición de que si el valor
de contador es igual a 1 se imprime el nombre del número, el mismo proceso se aplicó para el
resto de números, cada uno de estos procesos representan un hilo independiente en su
funcionamiento.

2) Utilice Arduino y programe tres procesos diferentes

- Movimiento de un servomotor desde 0º hasta 180º en un ciclo repetitivo
- Recepción y escalado de datos de un sensor cualquiera
- Conteo en números binarios representados en LED’s entre 0 y 15
CÓDIGO:

#include <pt.h>
#include <Servo.h>
Servo servomotor;

float pot;
float sensorValorGrados =0;

struct pt hilo1;
struct pt hilo2;
struct pt hilo3;

void setup() {
PT_INIT(&hilo1);
PT_INIT(&hilo2);
PT_INIT(&hilo3);

}
void loop() {
proceso1(&hilo1);
proceso2(&hilo2);
proceso3(&hilo3);

void proceso1(struct pt *pt) {

PT_BEGIN(pt);
Serial.begin(9600);
servomotor.attach(7);
static long t = 0;
do {

t = millis();
servomotor.write(0);
Serial.println(0);
PT_WAIT_UNTIL(pt, (millis()-t)>=1500);
servomotor.write(180);
Serial.print(180);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1500);

} while(true);
PT_END(pt)
}

void proceso2(struct pt *pt) {

PT_BEGIN(pt);
pot= analogRead(A0);
pot= pot*100/932;
sensorValorGrados = map(pot, 0, 100, 0, 310);
Serial.println("Potenciometro");
Serial.println(sensorValorGrados);
Serial.print("Porcentaje de Giro: ");
Serial.print(pot);
Serial.println("%");
Serial.print("Porcentaje de Grados: ");
Serial.println(sensorValorGrados);
delay(1000);
Serial.println("------------------------------------");
PT_END(pt)
}
void proceso3(struct pt *pt) {
PT_BEGIN(pt);
static long t = 0;
pinMode (8, OUTPUT);
pinMode (9, OUTPUT);
pinMode (10, OUTPUT);
pinMode (11, OUTPUT);

do {

t = millis(); //0
digitalWrite(8, LOW);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
/////1 1000
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////2 0100
digitalWrite(8, LOW);
digitalWrite(9, HIGH);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
///3 1100
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////4 0010
digitalWrite(8, LOW);
digitalWrite(9, LOW);
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////5 1010
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////6 0110
digitalWrite(8, LOW);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////7 1110
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////8 0001
digitalWrite(8, LOW);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////9 1001
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////10 0101
digitalWrite(8, LOW);
digitalWrite(9, HIGH);
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////11 1101
 digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////12 0011
digitalWrite(8, LOW);
digitalWrite(9, LOW);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////13 1011
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////14 0111
digitalWrite(8, LOW);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1000);
////15 1111
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
t = millis();
PT_WAIT_UNTIL(pt, (millis()-t)>=1500);
} while(true);

PT_END(pt)
}

CIRCUITO
Potenciómetro
FUNCIONAMIENTO
El circuito implementado consta de un potenciómetro, un servomotor y un circuito de leds
que nos entrega un número binario, cuya programación fue realizada en arduino mediante
threading o programación por hilos, por lo cual fueron instaurados tres hilos, cada proceso
tiene su funcionamiento independiente del resto, mediante la librería pt.h.
El primer hilo consta del funcionamiento de un servomotor que gira de 0 a 180, se
implementó el circuito en físico y en arduino mediante la librería Servo.h, el segundo hilo
consta de un sensor para lo cual se colocó un potenciómetro escalado, de tal forma que solo
se imprimen los datos en el serial, y finalmente el tercer hilo con un circuito que consta de led
en los cuales podemos observar una secuencia de 1 a 15 en binario, al finalizar se reinicia al
igual que el servomotor.

3) Elabore mediante programación por hilos una representación de un SDTR

aplicado a los sistemas mecatrónicos

CÓDIGO:

# SDTR LDR
import threading
import time

#enteros de 0 a 1023
def enteros():
contador = 0
while True:
for contador in range (1, 1024):
print(contador, ' ')
contador+=1
time.sleep(0.1)

#escalamiento a voltaje
def voltaje():
contador = 0
while True:
for contador in range (1, 1024):
print(' ', round(0.0049 * contador), 'V', ' ')
contador+=1
time.sleep(0.1)

#Escalamiento a porcentaje de luminosidad

def luminosidad():
contador = 0
while True:
for contador in range (1, 1024):
print(' ', round(0.0978 * contador), '%', '
')
contador+=1
time.sleep(0.1)

p1 = threading.Thread(name='HILO 1', target=enteros)

p2 = threading.Thread(name='HILO 2', target=voltaje)
p3 = threading.Thread(name='HILO 3', target=luminosidad)

p1.start()
p2.start()
p3.start()

p1.join()
p2.join()
p3.join()

SALIDA DE PANTALLA:
EXPLICACIÓN:
Para este ejercicio se escogió simular la lectura de datos de un LDR y su porcentaje de
luminosidad dependiendo del voltaje que recibe.

Para la lectura de los enteros entre 0 y 1023 se usó un ciclo for dentro de un while para que la
acción se repita cuantas veces sea necesario.

while True:
for contador in range (1, 1024):
print(contador, ' ')
contador+=1
time.sleep(0.1)
Mediante una adquisición de datos se logró escalar los valores hasta obtener una ecuación
característica 𝑦 = 0. 0049 𝑥 la cual fue usada en el código para obtener los valores del
voltaje entre 0 y 5 voltios.

print(' ', round(0.0049 * contador), 'V', ' ')

El mismo método se usó para escalar el voltaje a porcentaje de luminosidad entre 0% y

100%, como resultado se obtuvo la siguiente ecuación característica que fue usada en el
código 𝑦 = 0. 0978𝑥
print(' ', round(0.0978 * contador), '%', '

Por ultimo aqui podemos ver de qué manera se van activando los hilos en la programación:
p1 = threading.Thread(name='HILO 1', target=enteros)
p2 = threading.Thread(name='HILO 2', target=voltaje)
p3 = threading.Thread(name='HILO 3', target=luminosidad)

p1.start()
p2.start()
p3.start()

p1.join()
p2.join()
p3.join()