Xwork's Blog

Bienvenido el 2021

 Hola de nuevo a todos, el dia de hoy solo escribo para desearles a todos un buen año 2021, es cierto que el 2020 fue un año complicado, pero si nos sirve de consuelo a todos, el 2021 podrá ser peor (o no). Cómo es costumbre, continua visitando el blog de XWork y disfrutemos del tiempo que tenemos porque en un instante se puede acabar.

Vamos a programar #92 - El triangulo de Pascal (ver. C)

 Hola de nuevo a todos, el día de hoy vamos a ver cómo hacer un programa en C que calcule el triangulo de Pascal.

Cómo podrás recordar, hace unos día publiqué una version en Python; y tal cómo lo prometí justo antes de acabar el 2020, les traigo la versión en C. Cómo la explicación de que es el triangulo de Pascal se incluye en ese post (además de cómo hacer los cálculos a mano), simplemente pasaremos al código fuente. Al igual que el código en Python, vamos a calcular el triangulo de Pascal de manera recursiva y si surgen dudas las resolveremos en los próximos post

El código en C que sirve para calcular el triangulo de Pascal es el siguiente ():

// Prueba del triangulo de pascal en C

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

int *CalculateLevel(int Level)
{
    int *Result;
    Result  = (int *)malloc(Level * sizeof(int));
        
    if (Level == 0)
         *Result = 1;
    if (Level == 1)
    {
        *Result = 1;
        *(Result + 1) = 1;
    }
    if (Level > 1)
    {
        int *ResultP = CalculateLevel(Level - 1);
        for (int i = 0; i < Level; i++)
        {
            if (i == 0 || i == Level - 1)
                *(Result + i) = 1;
            else
                *(Result + i) = *(ResultP + i) + *(ResultP + i - 1);
        }
    }
    return(Result);
    
}

void DrawPascalTriangle(int Number)
{

    if (Number > 20)
    {
        printf("Solo se admiten 20 niveles");
    }
    else
    {
        for (int i = 0; i < (Number + 1); i++)
        {
            int *Result = CalculateLevel(i);
            for (int j = 0; j < i; j++)
            {
                printf( " %5d ", *(Result + j));
            }
        printf("\n");
        }

    }
}


int main()
{
    int Levels;
    printf("Numero de niveles\n");
    scanf("%d", &Levels);
    DrawPascalTriangle(Levels);

    return 0;
}

Vamos a programar #91 - EL triangulo de Pascal (ver. Python)

 Hola de nuevo a todos, el día de hoy vamos a ver cómo hacer el triangulo de pascal usando Python.

Hace unos días mientras leía los comentarios, alguien sugirió que hiciera un programa que calculara el triangulo de pascal y ya que ando un poco corto de ideas, decidí hacerlo. Pero antes de continuar, veamos que es el triangulo de pascal.

En las matemáticas, el triángulo de Pascal es una representación de los coeficientes binomiales ordenados en forma de triángulo. Es llamado así en honor al filósofo y matemático francés Blaise Pascal, quien introdujo esta notación en 1654, en su Traité du triangle arithmétique.1​ Si bien las propiedades y aplicaciones del triángulo fueron conocidas con anterioridad al tratado de Pascal por matemáticos indios, chinos, persas, alemanes e italianos, fue Pascal quien desarrolló muchas de sus aplicaciones y el primero en organizar la información de manera conjunta.2​

El triángulo de Pascal se puede generalizar a dimensiones mayores. La versión de tres dimensiones se llama pirámide de Pascal o tetraedro de Pascal, mientras que las versiones más generales son llamadas simplex de Pascal.

Wikipedia/Triangulo De Pascal

 La composición del triangulo de pascal es realmente simple, en la cima del triangulo, siempre ubicaremos un uno, de hecho en todas las orillas pondremos un uno de modo que en cada nivel haya tantos número cómo el nivel en el que estamos. Para el nivel dos, ya que solo hay extremos en ambos se pondrá un uno.

Para calcular los números del tercer nivel, imaginemos que tenemos tres lugares, los extremos deben de llevar el número uno, por lo que solo nos hace falta determinar el que esta en el lugar dos. Para hacerlo de manera "sencilla" debemos de revisar el nivel anterior y debemos de sumar el numero que esta en la misma posición que el numero que queremos saber (DEL NIVEL ANTERIOR), y sumarlo con el que inmediatamente antes. Para darnos una idea, miremos la siguiente imagen.

Si revisamos bien, nos ubicamos en el nivel tres, pero el numero que queremos saber es el que esta en el segundo lugar del tercer nivel (marcado con una X), entonces tenemos que tomar el numero del nivel anterior que esta en las misma posición que nuestro numero, en la imagen podemos apreciar que el número que esta en la segunda posición del nivel dos es uno y el numero que esta antes en el nivel dos, también es uno, por lo que tendríamos que el segundo numero del tercer nivel es igual a uno mas uno, por lo tanto su valor es dos.

Ahora a manera de ejemplo calculemos el valor de los números en el nivel 4, para eso imaginemos que tenemos algo cómo la imagen que sigue.

Para calcular el numero Y, simplemente hacemos lo mismo. Tomamos el tercer y segundo número del nivel tres y simplemente lo sumamos obteniendo otro tres.

Así podemos calcular cualquier nivel.

Entonces en python podemos crear código cómo el que sigue:

# Prueba del triangulo de pascal en python
def CalculateLevel(Level):
    Result = {}
    if Level == 1:
        Result[0] = 1
    if Level == 2:
        Result[0] = 1
        Result[1] = 1
    if Level > 2:
        ResultP = CalculateLevel(Level - 1)
        for i in range(Level):
            if (i == 0) or (i == Level - 1):
                Result[i] = 1
            else:
                Result[i] = ResultP[i - 1] + ResultP[i]
    return Result
 
def DrawPascalTriangle(Number):
    if Number > 20:
        print("Solo se admiten 20 Niveles")
    else:
        for i in range(Number + 1):
            Result = CalculateLevel(i)
            for j in range(len(Result)):
                print(Result[j], end = '  ')
            print()
    


if __name__ == "__main__":
    import sys
    DrawPascalTriangle(int(sys.argv[1]));

pascaltri.py 20

Vamos a programar #90 - La sucesión de Fibonacci y la función de Ackerman (ver. Python)

 Hola de nuevo a toos, el dia de hoy vamos a ver un poco de Python. En días anteriores, mientras revisaba algunos comentarios en twitter, aalgunas personas me preguntaron sobre el estado del blog, pese al que el estado actual ha empeorado un poco debido a cierto bicho, el hecho fue que un par de "accidentes" me impidieron crear nuevos post. Pero dejando eso de lado, mucha gente pidio que si les podia ayudar con python (si hacemos memoria, casi no hay programas hechos en éste lenguaje), y la razon principal es debido a que simplemente lo olvide (conste que ya lo habia mencionado en algun post). Para probar que aun estoy al pendiente, decidi hacer un par de programas con (segun google) las busquedas mas gfrecuentes relacionadas a python que conducian a mi blog.

Los números de Fibonacci.

def CalcFibonacci(Number):
    v1 = 0
    v2 = 1
    v3 = 0
    
    while v1 < Number:
        print(v1)
        v3 = v1 + v2
        v1 = v2
        v2 = v3


if __name__ == "__main__":
    import sys
    CalcFibonacci(int(sys.argv[1]))

Fibonacci.py 200

La funcion de Ackerman.

def AckermanFunction(Number1, Number2):
    if Number1 == 0:
        return Number2 + 1
    else:
        if Number2 == 0:
            return (AckermanFunction(Number1 - 1, 1))
        return (AckermanFunction(Number1 - 1, AckermanFunction(Number1, Number2 - 1)))

if __name__ == "__main__":
    import sys
    try:
        for i in range(4):
            for j in range(5):
                print(AckermanFunction(i, j),end='  ')
            print()
    except RecursionError:
        print("Error: Se alcanzo el maximo de recursion permitido")

Back to basics #10 - Control de LED's (con transistores) - Camino a Spedometer v. Final

 Hola de nuevo a todos, el día de hoy vamos a ver cómo instalar una mejora a las luces del velocímetro y además, veremos cómo es que los transistores nos pueden ayudar a manejar algunas cosas que no podríamos directamente desde el arduino.

Cuando controlamos los diodos LED directamente desde el arduino, disponemos de una cantidad limitada de potencia. Normalmente el arduino UNO es capaz de suministrar un voltaje de 5v en los pines, pero tienen un limite de corriente de solo 40mA, si conectamos algo que requiera más corriente las cosas pueden ponerse feas.

Por los lugares que suelo andar en bicicleta, los diodos antes mencionados cumplen con su trabajo, pero me llegaron algunas peticiones a mi twitter preguntando por la posibilidad de agregar algo mas fuerte. La mayoría quería agregar los módulos que consisten de tres (o seis) diodos LED 5050.

Si conectamos uno de estos módulos al arduino, simplemente nada pasará, ya que requieren un voltaje de 12V (si hago bien memoria cuando es un solo led 5050 de color blanco consume 60mA a 3.2v), para poder agregar uno de estos módulos, primero que nada, necesitaremos agregar un elevador de voltaje y para controlarlas el transistor.

Para este caso voy a usar un transistor TIP31c (que era lo que tenía a la mano) pero el siguiente diagrama aplica a cualquier transistor NPN. Pero primero que nada ¿Que es un transistor?.

El transistor es un dispositivo electrónico semiconductor utilizado para entregar una señal de salida en respuesta a una señal de entrada. Cumple funciones de amplificador, oscilador, conmutador o rectificador. El término «transistor» es la contracción en inglés de transfer resistor («resistor de transferencia»). Actualmente se encuentra prácticamente en todos los aparatos electrónicos de uso diario tales como radios, televisores, reproductores de audio y video, relojes de cuarzo, computadoras, lámparas fluorescentes, tomógrafos, teléfonos celulares, aunque casi siempre dentro de los llamados circuitos integrados.

https://es.wikipedia.org/wiki/Transistor

Tal y cómo lo dice la definición, necesitamos una señal de entrada para obtener una señal de salida, por lo que en este ejemplo el transistor lo usaremos cómo un apagador (se puede usar para más muchas más aplicaciones pero por ahora solo esto). Antes de continuar, quiero resaltar que usaremos un transistor NPN, existen de más tipos (que eventualmente veremos) pero por ahora y cómo el objetivo no es aprender a usarlos, bastará con usar un transitor del mismo tipo y con las caracteristicas que veremos un poco más adelante.

Para el transistor TIP31c los pines son de la siguiente manera:

1. Base
2. Colector
3. Emisor

.Para hacer las conexiones solo deberás de identificar cual corresponde a cada pin del transistor que elijas y todo debería de funcionar.

Y el diagrama correspondiente sería:

SI todo salió bien las luces deberían de encender cuando el PIN de arduino este en "HIGH".

Cabe aclarar que lo mas recomendable para está situación, sería usar una fuente de energía adicional, puesto que el velocímetro es alimentado por una pila, agregar dos elevadores de voltaje podría reducir la durabilidad de esta de forma drástica. En cambio si agregamos otra pila aparte si se agota el velocímetro podría seguir operando con normalidad.

Aunque la idea me agrado, está no es la solución que agregué a mi bicicleta, la solución que yo le puse la veremos en el siguiente post. Por cierto, se que al inicio del año prometí post cada quincena, pero por razones que son difíciles de entender (aun para mi) los post saldrán pero no de forma periódica.

Los leo luego.

Vamos a programar #89 - Midiendo voltajes con arduino - Camino a Spedometer v. Final

El primero de los problemas es que no tenemos una lectura precisa del nivel de la batería, anteriormente ya habíamos hecho un post en el cual mostraba cómo es que se hace la lectura de un voltaje, pero ¿podemos ser mas precisos? Para entender cómo podemos ganar precision, primero hay que recordar cómo es que se hacen las lecturas (y recomiendo que leas un post donde hablamos un poco).

Para medir el voltaje, lo que hacemos es ingresarlo por un pin del arduino, internamente, este posee un mecanismo que traslada el voltaje un valor digital. Cuando conectamos 0v a un pin analogo del arduino y hacemos la lectura con "analogread()" está devolverá un valor de 0. EN cambio si conectamos 5v esta devolverá un valor de 1023. ¿Por que ocurre esto? Simple arduino cuenta con convertidor análogo-digital con una resolución de 8 bits por lo que cada valor entre 0 y 1023 sera igual a un valor de 0v a 5v. Para saber que valor le corresponde a cada voltaje, bastará con mirar la siguiente formula:

donde "n" es el valor de la lectura que "analogread()" regresa . Para entender un poco lo que pasa, supongamos que toamos la lectura usando arduino y este nos regreso un valor de 155.

al sustituirlo tenemos:

Y si lo medimos usando un multimetro tenemos:

Que es bastante acertado. Pero ahora lo que nos interesa hacer es ganar mas definición. Cuando arduino "mide" un voltaje en realidad lo que hace es compararlo con otro, por default este es de 5v, pero se puede elegir otro.

Para indicar que queremos usar un voltaje externo de referencia, podemos usar la función "analogReference()" que recibe un parámetro que puede ser cualquiera de los siguientes:

• DEFAULT (el valor de la alimentación, si se usan 5v, esta sera la referencia, si se usan 3.3v esta lo será).
• INTERNAL (Usa un voltaje interno de 1.1v pero solo en el modelo uno, en otros modelos es de 2.56v y elgunos no esta disponible).
• EXTERNAL (Usa el PIN AREF y se puede usar un valor mayor a cero y menor o igual a 5v)

Existen otros parámetros, pero por ahora nos centraremos en estos.

Primero usaremos el parámetro "INTERNAL" y para que pruebes, puedes usar el siguiente código:

int ValIn = 0;
int CurVal = 0;
float CurVolt =0;

void setup()
{
	analogReference(INTERNAL);
	Serial.begin(9600);
}

void loop()
{
	CurVal=analogRead(ValIn);
	Serial.println(CurVal);
	CurVolt=CurVal*1.1; 
	Serial.print("Valor");
	Serial.print(CurVal);
	Serial.print("mV:");
	Serial.println(CurVolt);
	Serial.println("Done");
	delay(2000);
}

Una vez que lo subas a tu arduino, deberás de conectar el voltaje positivo de tu voltaje (una pila por ejemplo) al pin A0 y el voltaje negativo a tierra. Yo al hacer la medición de la misma pila me da un valor de 710 que al reemplazarlo en la formula (actualizando los valores) no da:

Que es un valor mas cercano al que nos dio el multímetro.

Y sabiendo lo anterior ahora podemos hacer que la referencia sea la indicada para el nivel de la batería. Primero modificaremos un poco el código para hacer uso de la referencia externa, para eso prueba copiar el siguiente código:

int ValIn = 0;
int CurVal = 0;
float CurVolt =0;

void setup()
{
	analogReference(EXTERNAL);
	Serial.begin(9600);
}

void loop()
{
	CurVal=analogRead(ValIn);
	Serial.println(CurVal);
	CurVolt=CurVal*1.1; 
	Serial.print("Valor");
	Serial.print(CurVal);
	Serial.print("mV:");
	Serial.println(CurVolt);
	Serial.println("Done");
	delay(2000);
}

Ahora deberás de conectar un voltaje de 4.2v al pin "AREF" del arduino y conectar el lado positivo de la pila al pin "A0" y el negativo a tierra. Es importante tener nuestro voltaje de referencia estable. Si has seguido los post sobre el velocímetro, sabrás que hacemos uso de un boost converter para obtener un voltaje estable de 5v, si no te quieres complicar la vida, simplemente puedes usar un divisor resistivo con una resistencia de 1.2 kohm junto co una de 6.3 kohm (si tienes 5v exactos te dará 4.2v a la salida).

Algo que es importante aclarar para finalizar el post, es que para mostrar el porcentaje de batería no podemos simplemente usar la formula del porcentaje ya que todas las pilas son diferentes y a pesar de que la capacidad de una pila se puede medir de acuerdo al voltaje que esta nos da, depende meramente del fabricante cómo es "la curva de descarga" (que veremos en otro post) cómo dije al inicio, en el caso del velocímetro, los iconos son meramente ilustrativos de "la pila recien se cargo", "Está medio vacía" y "ya hace falta una recarga".

Y bien, por ahora es todo, lo ejemplos de código cómo son sencillos puedes simplemente copiarlos y pegarlos para probarlos y hago énfasis en que al pin "AREF" del arduino SIEMPRE se le debe aplicar un voltaje mayor a cero y menor o igual a 5.

Los leo luego.

Vamos a programar #88 - KeyRemap M (beta)

Vamos a programar #87 - Camino a KeyRemap, MessageTextBox .

		private void MsCboKeyOut_KeyDown(object sender, KeyEventArgs e)
		{
			MessageBox.Show(e.KeyCode.ToString());
			e.SuppressKeyPress = true;
		}

using System;
using System.Windows.Forms;

namespace KeyRemap
{
	class MessageTextBox : TextBox
	{
		public const int WM_KEYDOWN = 0x0100;
		private uint TheValue = 0;

		public string GetHexValue
		{
			get
			{
				return Convert.ToString(TheValue, toBase: 16);
			}
		}
		public uint ShowKeyCode(uint TheNumber)
		{
			uint KeyValue = TheNumber;
			uint KeyCode = ((KeyValue >> 16) % 256);
			uint IsExtendedKey = ((KeyValue >> 24) % 2);
			if (IsExtendedKey == 1)
			{
				KeyCode = FrmMain.EXTENDED_KEY_VALUE | KeyCode;
				return KeyCode;
			}
			else
				return KeyCode;
		}

		[System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")]
		protected override void WndProc(ref Message m)
		{
			switch (m.Msg)
			{
				case WM_KEYDOWN:
					base.Text = "";
					base.Text = Convert.ToString(ShowKeyCode((uint)m.LParam));
					TheValue = (uint)m.LParam;
					break;
			}
			base.WndProc(ref m);
		}
	}
}

Vamos a programar #86 - Reasignando teclas del teclado.

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,02,00,00,00,20,E0,49,E0,00,00,00,00

Cumplimos 4 Años!!!!!!

Learning machine #15 - Operaciones a nivel del bits.

Operadores de desplazamiento (<< y >>)

Operador Not (~).

Operador AND (&).

Operador Or (|).

Back to basics #10 - Reguladores de voltaje

Este tipo de eliminador es bastante barato.

Las cosas se pueden poner "calientes" si la disipacion adecuda