Programación archivos - Página 5 de 24

Estructuras Union de C / Arduino

30 Mar 201328 agosto 2013 giltesa 5 comentarios

/**
 * Author:     giltesa
 * WebSite:    http://giltesa.com
 * License:    CC BY-NC-SA 3.0
 * 
 * Esta estructura, de tipo union y no struct, permite guardar un dato del tipo que queramos, y hacerlo accesible de dos formas distintas.
 *    - La primera de ellas es accediendo al dato directamente como una variable mas.
 *    - La segunda forma es accediendo a su memoria, en el caso del float este tiene un tamaño de 4 bytes, eso hace que podamos acceder a sus 4 bytes por separado.
 * Esto aparentemente no tiene ninguna utilidad, salvo que queramos transmitirlo entre dos Arduinos inalambricamente ya que para ello han de ser enviados los bytes uno a uno. Despues se recogen uno a uno y se restauran en otra estructura union:
 */
 
union miDato{
   float fval;
   byte  b[4];     // Array de bytes de tamaño igual al tamaño de la primera variable: int = 2 bytes, float = 4 bytes
} origen, destino; // Se crean dos estructuras Union, cada una es independiente de la otra y guardan distintos datos.

void setup()
{
   Serial.begin(9600);
   delay(1000);

   // A la estructura de origen se le da un valor float, una temperatura por ejemplo.
   origen.fval = -103.36;

   // Se imprime para comprobar que se ha guardado bien:
   Serial.print("Origen=  ");
   Serial.print(origen.fval);

   // Ahora se copia byte a byte la estructura de origen en la estructura de destino:
   for(int i=0 ; i < sizeof(origen.fval) ; i++)
      destino.b[i] = origen.b[i];

   // Y se imprime el float de la estructura de destino, es el mismo dato que el de origen!
   Serial.print("\nDestino= ");
   Serial.print(destino.fval);
}

void loop()
{
}

/**

* Author: giltesa

* WebSite: http://giltesa.com

* License: CC BY-NC-SA 3.0

* Esta estructura, de tipo union y no struct, permite guardar un dato del tipo que queramos, y hacerlo accesible de dos formas distintas.

* - La primera de ellas es accediendo al dato directamente como una variable mas.

* - La segunda forma es accediendo a su memoria, en el caso del float este tiene un tamaño de 4 bytes, eso hace que podamos acceder a sus 4 bytes por separado.

* Esto aparentemente no tiene ninguna utilidad, salvo que queramos transmitirlo entre dos Arduinos inalambricamente ya que para ello han de ser enviados los bytes uno a uno. Despues se recogen uno a uno y se restauran en otra estructura union:

union miDato{

float fval;

byte b[4]; // Array de bytes de tamaño igual al tamaño de la primera variable: int = 2 bytes, float = 4 bytes

} origen, destino; // Se crean dos estructuras Union, cada una es independiente de la otra y guardan distintos datos.

void setup()

{

Serial.begin(9600);

delay(1000);

// A la estructura de origen se le da un valor float, una temperatura por ejemplo.

origen.fval = -103.36;

// Se imprime para comprobar que se ha guardado bien:

Serial.print("Origen= ");

Serial.print(origen.fval);

// Ahora se copia byte a byte la estructura de origen en la estructura de destino:

for(int i=0 ; i < sizeof(origen.fval) ; i++)

destino.b[i] = origen.b[i];

// Y se imprime el float de la estructura de destino, es el mismo dato que el de origen!

Serial.print("\nDestino= ");

Serial.print(destino.fval);

}

void loop()

{

}

Eclipse – Python

17 Mar 2013 giltesa Deja un comentario

Para finalizar con los lenguajes que añadiremos a Eclipse lo haremos con Python, recordemos que ya vimos Java, PHP, Android y C/C++. Este al igual que el de C se hace en un momento.

(más…)

Eclipse – C / C++

17 Mar 20132 septiembre 2014 giltesa 4 comentarios

Ya hemos visto como añadir soporte para PHP y Android, esta vez se lo daremos a C y C++ con el plugin CDT.

Al tratarse de un nuevo lenguaje y no de un simple plugin vamos a necesitar mas cosas como el compilador gcc, pero vamos por pasos.

(más…)

Eclipse – Windows Builder, ayudante para crear interfaces gráficas en Java con SWT o Swing

17 Mar 201322 noviembre 2015 giltesa 16 comentarios

Una vez nos pongamos a programar en Java seguramente echemos en falta algún ayudante o interfaz que nos facilite el trabajo de crear interfaces gráficas en Java, algo así a lo que facilita el IDE de Microsoft con Visual Studio.

Para solucionar este inconveniente solo tenemos que instalar el plugin WindowsBuilder, este es el mismo que se usa en el plugin de Google para programar en Android, que nos permitirá crear una interfaz con Swing arrastrando componentes sobre la ventana.

(más…)

Cifrar y descifrar datos con el sistema criptográfico RSA

27 Feb 2013 giltesa 3 comentarios

/*
    Author:     Alberto Gil Tesa
    WebSite:    http://giltesa.com
    License:    CC BY-NC-SA 3.0
                http://goo.gl/CTYnN

    File:       Rsa.java
    Date:       26/02/2013
    
    NOTAS:
        http://es.wikipedia.org/wiki/RSA
*/


import java.math.BigInteger;
import java.security.SecureRandom;


public class Rsa
{
    private BigInteger n; // Clave compartida
    private BigInteger d; // Clave privada (no se comparte)
    private BigInteger k; // Clave publica para la otra parte
    private final int  K = 0, D = 0, N = 1;


    /**
     * Constructor que genera las claves publica y privada de tamaño bitlen indicado.
     * 
     * @param bitlen
     */
    public Rsa(int bitlen)
    {
        // Calculamos los dos numeros primos p y q:
        SecureRandom r = new SecureRandom();
        BigInteger p = new BigInteger(bitlen / 2, 100, r);
        BigInteger q = new BigInteger(bitlen / 2, 100, r);

        //n = p*q, v= (p-1)*(q-1)
        n = p.multiply(q);
        BigInteger v = ( p.subtract(BigInteger.ONE) ).multiply(q.subtract(BigInteger.ONE));

        // Calculamos k como el numero impar mas pequeño relativamente primo con v
        k = new BigInteger("3");
        while( v.gcd(k).intValue() > 1 )
            k = k.add(new BigInteger("2"));

        // Calculamos d de modo que (d * k) MOD V = 1
        d = k.modInverse(v);
    }


    /**
     * Pasa el BigInteger normal a cifrado usando la clave publica.
     * 
     * @param message
     * @return
     */
    public BigInteger encrypt(BigInteger message)
    {
        return message.modPow(k, n);
    }


    /**
     * Pasa el BigInteger normal a cifrado usando la clave publica recibida.
     * 
     * @param message
     * @param key
     * @return
     */
    public BigInteger encrypt(BigInteger message, BigInteger[] key)
    {
        return message.modPow(key[K], key[N]);
    }


    /**
     * Pasa el BigInteger de cifrado a normal usando la clave privada.
     * 
     * @param message
     * @return
     */
    public BigInteger decrypt(BigInteger message)
    {
        return message.modPow(d, n);
    }


    /**
     * Pasa el BigInteger de cifrado a normal usando la clave privada recibida.
     * 
     * @param message
     * @return
     */
    public BigInteger decrypt(BigInteger message, BigInteger[] key)
    {
        return message.modPow(key[D], key[N]);
    }


    /**
     * Devuelve la clave publica.
     * 
     * @return
     */
    public BigInteger[] getPublicKey()
    {
        return new BigInteger[] { k, n };
    }


    /**
     * Devuelve la clave privada.
     * 
     * @return
     */
    public BigInteger[] getPrivateKey()
    {
        return new BigInteger[] { d, n };
    }


}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

Author: Alberto Gil Tesa

WebSite: http://giltesa.com

License: CC BY-NC-SA 3.0

http://goo.gl/CTYnN

File: Rsa.java

Date: 26/02/2013

NOTAS:

http://es.wikipedia.org/wiki/RSA

import java.math.BigInteger;

import java.security.SecureRandom;

public class Rsa

{

private BigInteger n; // Clave compartida

private BigInteger d; // Clave privada (no se comparte)

private BigInteger k; // Clave publica para la otra parte

private final int K = 0, D = 0, N = 1;

/**

* Constructor que genera las claves publica y privada de tamaño bitlen indicado.

* @param bitlen

public Rsa(int bitlen)

{

// Calculamos los dos numeros primos p y q:

SecureRandom r = new SecureRandom();

BigInteger p = new BigInteger(bitlen / 2, 100, r);

BigInteger q = new BigInteger(bitlen / 2, 100, r);

//n = p*q, v= (p-1)*(q-1)

n = p.multiply(q);

BigInteger v = ( p.subtract(BigInteger.ONE) ).multiply(q.subtract(BigInteger.ONE));

// Calculamos k como el numero impar mas pequeño relativamente primo con v

k = new BigInteger("3");

while( v.gcd(k).intValue() > 1 )

k = k.add(new BigInteger("2"));

// Calculamos d de modo que (d * k) MOD V = 1

d = k.modInverse(v);

}

/**

* Pasa el BigInteger normal a cifrado usando la clave publica.

* @param message

* @return

public BigInteger encrypt(BigInteger message)

{

return message.modPow(k, n);

}

/**

* Pasa el BigInteger normal a cifrado usando la clave publica recibida.

* @param message

* @param key

* @return

public BigInteger encrypt(BigInteger message, BigInteger[] key)

{

return message.modPow(key[K], key[N]);

}

/**

* Pasa el BigInteger de cifrado a normal usando la clave privada.

* @param message

* @return

public BigInteger decrypt(BigInteger message)

{

return message.modPow(d, n);

}

/**

* Pasa el BigInteger de cifrado a normal usando la clave privada recibida.

* @param message

* @return

public BigInteger decrypt(BigInteger message, BigInteger[] key)

{

return message.modPow(key[D], key[N]);

}

/**

* Devuelve la clave publica.

* @return

public BigInteger[] getPublicKey()

{

return new BigInteger[] { k, n };

}

/**

* Devuelve la clave privada.

* @return

public BigInteger[] getPrivateKey()

{

return new BigInteger[] { d, n };

}

(más…)

Eclipse – Android SDK

20 Dic 201222 diciembre 2012 giltesa Deja un comentario

Eclipse-Android_8

Ya vimos con anterioridad como instalar Eclipse y configurarlo para programar en PHP. Esta vez toca ver los pasos que debemos de seguir para poder programar en Android y crear la primera aplicación de ¡Hola mundo! (más…)

Mi primera APP para Android: Calculadora Básica

1 Dic 201224 diciembre 2014 giltesa 6 comentarios

La finalidad de esta aplicación no era realizar una calculadora indestructible que realizara todas las operaciones correctamente, si no iniciarse en la programación en Android probando e implementando las diferentes herramientas que se ofrecen para desarrollar aplicaciones. Por ello esta calculadora no es perfecta, ya hay en el market suficientes calculadoras denigrantes como para subir otra mas.

(más…)