Electrónica

ADC STM32F4 Discovery - Parte 2

2016-01-29T00:08:00.003+01:00

Como ya comenté en la primera parte, la siguiente configuración permite solventar los fallos que presentaba la anterior además de conseguir una ejecución mas rápida al emplear el DMA (del ingles, Direct Memory Access).

Así pues, lo primero que veremos serán las modificaciones necesarias en la función de configuración del ADC para comunicarse con el DMA.

void ADC_Configure (void)
{
    ADC_InitTypeDef ADC_InitStructure;
    ADC_CommonInitTypeDef ADC_CommonInitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB2PeriphClockCmd (RCC_APB2Periph_ADC1, ENABLE);

    ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
    ADC_InitStructure.ADC_ScanConvMode = ENABLE;
    ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
    ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConvEdge_None;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_NbrOfConversion = ADCDataLength;
    ADC_Init (ADC1, &ADC_InitStructure);

    ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
    ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;
    ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
    ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
    ADC_CommonInit (&ADC_CommonInitStructure);

    ADC_TempSensorVrefintCmd (ENABLE);
    ADC_VBATCmd (ENABLE);

    ADC_RegularChannelConfig (ADC1, ADC_Channel_1, 1, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC1, ADC_Channel_16, 2, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC1, ADC_Channel_17, 3, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC1, ADC_Channel_18, 4, ADC_SampleTime_3Cycles);

    ADC_ITConfig (ADC1, ADC_IT_EOC, ENABLE);

    ADC_DMARequestAfterLastTransferCmd (ADC1, ENABLE);
    ADC_DMACmd (ADC1, ENABLE);

    NVIC_InitStructure.NVIC_IRQChannel = ADC_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
    NVIC_Init (&NVIC_InitStructure);

    ADC_Cmd (ADC1, ENABLE);
}

Se ha quitado el trigger del ADC para hacerlo mediante la función ADC_SfotwareStartConv (ejecutada en la interrupción del botón de usuario) y se han añadido las funciones ADC_DMARequestAfterLastTransferCmd (permite al ADC realizar la petición de uso del DMA, ademas se encarga de limpiar el flag ADC_FLAG_EOC, por lo que no habrá que hacerlo dentro de la rutina de atención a la interrupción) y ADC_DMACmd (habilita la comunicación entre el ADC y el DMA).
Ahora toca configurar el canal del DMA para que se comunique con el ADC. Para ello comenzaremos dando unas menciones del DMA viendo su diagrama de bloques de funcionamiento.

En la siguiente imagen se muestran otros detalles relacionados con el diagrama anterior.

El DMA permite a ciertos periféricos acceder directamente a memoria para leer y/o escribir datos sin intermediar con el procesador, de forma que se libera a este de la carga de transferencia de datos y le permite seguir atendiendo a otras tareas. Esto permite una mejor comunicación entre la memoria y los periféricos de baja velocidad que de otra forma generarían una elevada carga de interrupciones al procesador. Todo esto no quita que se necesite el uso del bus del sistema (AHB en este caso), de forma que se existen distintas estrategias que consiguen que el DMA no acapare por completo el uso de este. De entre estas estrategias o protocolos interesa conocer estos tres:

Burst mode (modo ráfaga): el DMA toma el control del bus del sistema y no lo libera hasta que completa la transferencia. Es el modo mas rápido de transferir los datos pero por el contrario el que mas efecto negativo produce sobre el procesador al acaparar por completo el control del bus. Este modo se puede usar con mayor eficacia en procesadores que cuenten con memoria cache para que este pueda seguir trabajando.
Cycle stealing mode (modo robo de ciclo): el DMA genera una petición de control del bus al procesador y cuando este se lo asigna, envía un byte de datos y devuelve el control al procesador. Este juego continua hasta que se completa la transferencia. De esta forma se permite al procesador continuar con sus tareas (ademas también de atender las peticiones de control del bus), pero por contra, la transferencia de datos resulta mas lenta.
Transparent mode (modo transparente): el DMA hace uso del bus del sistema cuando este se encuentra disponible, de forma que no interrumpe en ningún momento al procesador. Este modo es el mejor en cuanto a términos de rendimiento del sistema, pero por el contrario necesita determinar cuando el bus se encuentra libre, lo cual resulta complejo

Para mas información, visitar Direct memory access.

Tras esto, vemos la configuración del DMA y se podrán relacionar ciertos parámetros con los diagramas anteriores.

void DMA_Configure (void)
{
    DMA_InitTypeDef DMA_InitStructure;

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);

    DMA_InitStructure.DMA_Channel = DMA_Channel_0;
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) &ADC1->DR;
    DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t) ADCData;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
    DMA_InitStructure.DMA_BufferSize = ADCDataLength;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
    DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
    DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
    DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
    DMA_Init (DMA2_Stream0, &DMA_InitStructure);

    DMA_Cmd (DMA2_Stream0, ENABLE);
}

Lo primero, como siempre, será activare el reloj para el periférico. Tras esto, escogemos el canal por el cual serán recogidos los datos. Para verificar esto nos remitiremos a la tabla 43 del archivo RM0090 Reference Manual, en la cual se puede ver que es el DMA2 el que permite la petición del ADC1.

Especificaremos la dirección del registro de donde se obtendrán los datos y la dirección donde serán almacenados. Indicamos la sentido del flujo de datos, desde el ADC a la memoria y la cantidad de datos a transmitir. El incremento de dirección en el periférico se desactiva (leemos siempre del mismo) pero no la de la memoria, puesto que hay mas de un dato que guardar. El tamaño de los datos a transmitir es de 16 bits y se activará el modo circular, de forma que cuando se reciben todos los datos, el puntero de dirección se reinicia en el valor configurado y guarda de nuevo los datos en la misma ubicación (para no perder los anteriores se tendrán que extraer durante la interrupción de fin de conversión del ADC). Establecemos la prioridad para la transferencia del ADC y se desactiva el modo FIFO. La transferencia de datos sera en ráfaga simple. Finalmente escogemos el stream correspondiente de la tabla ya comentada e inicializamos el modulo DMA.
Como se comentó mas arriba, dado que la función ADC_DMARequestAfterLastTransferCmd limpia el flag de la interrupcion de fin de conversión, en dicha interrupción no quedaría mas que hacer un backup de los datos actuales para no perderlos con la siguiente conversión.
En el main se mantiene el funcionamiento inicial, pero hay que modificar el origen de los datos convertidos, siendo este ADCData.

int main (void)
{
    float vTempSensor = 0, temp = 0, Vbat = 0;

    GPIO_Configure ();
    ADC_Configure ();
    EXTI_Configure ();
    DMA_Configure ();

    while (1)
    {
        if (ADCData [0] == 0)
        {
            GPIO_ResetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
        }
        else if (ADCData [0] > 0 && ADCData [0] < 1024)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_13);
            GPIO_ResetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15);
        }
            else if (ADCData [0] >= 1024 && ADCData [0] < 2048)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_13 | GPIO_Pin_14);
            GPIO_ResetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_15);
        }
        else if (ADCData [0] >= 2048 && ADCData [0] < 3072)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
            GPIO_ResetBits (GPIOD, GPIO_Pin_12);
        }
        else if (ADCData [0] >= 3072 && ADCData [0] < 4096)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
        }

        vTempSensor = (float) ADCData [1] / 4095;    // vTempSensor (mV) = 3300 * (TempSensor_ConvertedValue / 4095)
        vTempSensor *= 3300;
        temp = vTempSensor - 760;                // temp (ºC) = ((Vsense - V25) / Average_slope) + 25
        temp /= 2.5;
        temp += 25;

        Vbat = (float) ADCData [3] * 2;    // Internal bridge divider by 2
        Vbat /= 4095;                    // Vbat (mV) = 3300 * ((Vbat_ConvertedValue * 2) / 4095)
        Vbat *= 3300;
    }
}

Una sencilla e interesante modificación seria que tras la interrupción del botón de usuario y activación de la conversión, esta continuara automáticamente, para lo cual simplemente habría que habilitar el modo continuo del ADC.
Hasta aquí el sustito al último ejemplo de la primera parte que no funcionó correctamente y el proyecto listo en el siguiente enlace: ADC DMA STM32F4 Discovery Dropbox

Dado que todo este tiempo hemos trabajado con un solo ADC, a continuación vemos como podemos usar los tres ADCs junto con el DMA.
Inicialmente escogeremos los canales que queremos convertir, en definitiva, configurar los pines de entrada correspondientes. En mi caso escogi desde el pin PA1 hasta el PA6, que se corresponden con los canales 1 a 6: los canales 1 y 2 se usaran con el ADC3, los canales 3 y 4 con el ADC2 y los canales 5 y 6 con el ADC1, como se ve a continuación en la configuración del ADC.

void ADC_Configure (void)
{
    ADC_InitTypeDef ADC_InitStructure;
    ADC_CommonInitTypeDef ADC_CommonInitStructure;

    RCC_APB2PeriphClockCmd (RCC_APB2Periph_ADC1, ENABLE);
    RCC_APB2PeriphClockCmd (RCC_APB2Periph_ADC2, ENABLE);
    RCC_APB2PeriphClockCmd (RCC_APB2Periph_ADC3, ENABLE);

    ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
    ADC_InitStructure.ADC_ScanConvMode = ENABLE;
    ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
    ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConvEdge_None;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_NbrOfConversion = 2;
    ADC_Init (ADC1, &ADC_InitStructure);
    ADC_Init (ADC2, &ADC_InitStructure);
    ADC_Init (ADC3, &ADC_InitStructure);

    ADC_CommonInitStructure.ADC_Mode = ADC_TripleMode_RegSimult;
    ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;
    ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1;
    ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
    ADC_CommonInit (&ADC_CommonInitStructure);

    ADC_RegularChannelConfig (ADC3, ADC_Channel_1, 1, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC3, ADC_Channel_2, 2, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC2, ADC_Channel_3, 1, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC2, ADC_Channel_4, 2, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC1, ADC_Channel_5, 1, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC1, ADC_Channel_6, 2, ADC_SampleTime_3Cycles);

    ADC_MultiModeDMARequestAfterLastTransferCmd (ENABLE);
    ADC_DMACmd (ADC1, ENABLE);

    ADC_Cmd (ADC1, ENABLE);
    ADC_Cmd (ADC2, ENABLE);
    ADC_Cmd (ADC3, ENABLE);
}

Lo primero será activar los relojes de los ADC2 y ADC3 y a continuación estableceremos la misma configuración de funcionamiento para los tres. En la estructura de configuración común es donde se introducen los cambios mas importantes. El primero de ellos es la elección del modo triple simultaneo para canales regulares, que junto con la elección del modo de acceso 1 del DMA determinan el siguiente funcionamiento:

El flujo de las conversiones va desde el ADC1 al ADC3. En la imagen anterior se obtendrían los datos en el siguiente orden: ADC1-CH0, ADC2-CH15, ADC3-CH10, ADC1-CH1... Finalmente activamos la petición del DMA y lo inicializamos desde el ADC1, puesto que este actúa como master cuando trabajamos en modo multiADC.

Una vez configurado correctamente los ADCs, pasamos al DMA.

void DMA_Configure (void)
{
    DMA_InitTypeDef DMA_InitStructure;

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);

    DMA_InitStructure.DMA_Channel = DMA_Channel_0;
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) ADC_CDR_ADDRESS;
    DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t) ADCData;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
    DMA_InitStructure.DMA_BufferSize = ADCDataLength;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
    DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
    DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
    DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
    DMA_Init (DMA2_Stream0, &DMA_InitStructure);

    DMA_Cmd (DMA2_Stream0, ENABLE);
}

El aspecto mas importante aquí es el registro de donde se leerán en este caso los datos, ADC_CDR, siendo el valor de su dirección

1	#define ADC_CDR_ADDRESS ((uint32_t)0x40012308)

Como se ha podido ver, en este caso no se necesita de ninguna interrupción, salvo la del botón de usuario para iniciar la conversión.
Finalmente, en el main se hará otra decodificación simple para verificar que los datos que lee el ADC corresponden con los que esperamos.

int main (void)
{
    GPIO_Configure ();
    ADC_Configure ();
    EXTI_Configure ();
    DMA_Configure ();

    while (1)
    {
        if (ADCData [0] < 4000)
            GPIO_ResetBits (GPIOD, GPIO_Pin_13);
        else
            GPIO_SetBits (GPIOD, GPIO_Pin_13);

        if (ADCData [1] < 4000)
            GPIO_ResetBits (GPIOD, GPIO_Pin_14);
        else
            GPIO_SetBits (GPIOD, GPIO_Pin_14);

        if (ADCData [2] < 4000)
            GPIO_ResetBits (GPIOD, GPIO_Pin_15);
        else
            GPIO_SetBits (GPIOD, GPIO_Pin_15);

        if (ADCData [3] < 4000)
            GPIO_ResetBits (GPIOD, GPIO_Pin_12);
        else
            GPIO_SetBits (GPIOD, GPIO_Pin_12);
    }
}

Se compara el valor leído para determinar si los canales 1 a 4 (no hay leds para los otros dos canales) están a nivel alto. En el siguiente enlace se encuentra disponible la configuración expuesta: ADC Triple Mode STM32F4 Discovery Dropbox.

Por ultimo, para terminar con el ADC, veremos como usar el analog watchdog disponible. Este "vigila" si el valor convertido esta fuera del rango establecido por dos umbrales programables. Para demostrar esto configuraremos el ADC1 para que convierta continuamente un canal y estableceremos los umbrales en 0.5 y 2.5 V, de forma que si estamos fuera del rango se encenderá un led.

void ADC_Configure (void)
{
    ADC_InitTypeDef ADC_InitStructure;
    ADC_CommonInitTypeDef ADC_CommonInitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB2PeriphClockCmd (RCC_APB2Periph_ADC1, ENABLE);

    ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
    ADC_InitStructure.ADC_ScanConvMode = DISABLE;
    ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
    ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConvEdge_None;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_NbrOfConversion = 1;
    ADC_Init (ADC1, &ADC_InitStructure);

    ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
    ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;
    ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
    ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
    ADC_CommonInit (&ADC_CommonInitStructure);

    ADC_RegularChannelConfig (ADC1, ADC_Channel_1, 1, ADC_SampleTime_3Cycles);

    ADC_ITConfig (ADC1, ADC_IT_AWD, ENABLE);

    NVIC_InitStructure.NVIC_IRQChannel = ADC_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x2;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x2;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init (&NVIC_InitStructure);

    ADC_AnalogWatchdogSingleChannelConfig (ADC1, ADC_Channel_1);
    ADC_AnalogWatchdogThresholdsConfig (ADC1, (uint16_t) ((2500 * 4095) / 3300), (uint16_t) ((500 * 4095) / 3300));
    ADC_AnalogWatchdogCmd (ADC1, ADC_AnalogWatchdog_SingleRegEnable);

    ADC_Cmd (ADC1, ENABLE);
}

Las funciones de configuración del analog watchdog son muy sencillas, por lo que no requieren comentarios adicionales.
Y la rutina de atención a la interrupción donde se enciende el led.

void ADC_IRQHandler (void)
{
    if (ADC_GetITStatus (ADC1, ADC_IT_AWD) != RESET)
    {
        GPIO_SetBits (GPIOD, GPIO_Pin_13);
        ADC_ClearITPendingBit (ADC1, ADC_IT_AWD);
    }
}

Este ejemplo resultaría interesante para crear una alarma a partir del canal del sensor de temperatura. También dejo a continuación el archivo con la configuración del analog watchdog vista: ADC Analog Watchdog STM32F4 Discovery Dropbox.

ADC STM32F4 Discovery - Parte 1

2016-01-24T00:39:00.000+01:00

Anteriormente veíamos lo importante que resultaban los temporizadores en los sistemas electrónicos actuales. Al igual que estos, existen otros periféricos, que debido a su interacción con el medio, también resultan de gran interés para el desarrollo de aplicaciones.

Por ello, el siguiente periférico con el que trabajaremos será el convertidor analógico a digital (ADC, del inglés, Analog to Digital Converter), que se encarga de convertir una señal en tensión de naturaleza analógica a un valor digital con el que es posible realizar el procesamiento de dicha señal.

Antes de mostrar ejemplos sencillos de las distintas configuraciones del ADC de nuestra placa, veremos una pequeña introducción (mas información en Analog to digital converter, Wikipedia) a los convertidores analógicos a digital para tratar unos aspectos interesantes.

Cuando realizamos la conversión de analógico a digital, debemos tener en cuenta dos aspectos principales, el muestreo y la cuantificación y codificación de dicha señal, lo cual, en simples palabras, significa que la conversión de analógico a digital produce una discretización de la señal en tiempo y amplitud.

El muestreo consiste en tomar una muestra (un valor) de la señal monitorizada en un instante de tiempo. Dado que el sistema electrónico que se encargue de esto no tiene la capacidad de capturar los infinitos valores que toma la señal en el tiempo, estaremos discretizando la señal en el tiempo. De aquí se deriva el término frecuencia de muestreo, que indica el intervalo de tiempo entre cada muestra de la señal analógica. Entrando aun mas en teoría, conviene saber que para muestrear "correctamente" una señal analógica, la frecuencia escogida ha de ser mayor que el doble de la frecuencia máxima de dicha señal. Dicho valor es conocido como frecuencia de Nyquist (Teorema de Nyquist, Wikipedia).

Una vez obtenidas las muestras necesarias de la señal, se procede a cuantificar y codificar dichos valores. Aquí entra en juego la resolución, en bits, del conversor que se este utilizando. En nuestro caso, como se verá a continuación, disponemos de un ADC de 12 bits de resolución, lo que nos permite codificar una medida desde 0 hasta 4095 (cuantificación de 4096 valores codificados desde 0 a 4095). Aquí nuevamente volvemos a ver el efecto de la discretización, en este caso en amplitud, y al igual que la discretización en el tiempo, es muy importante, ya que una elección incorrecta de la resolución del convertidor derivará en una reducción de la relación señal ruido (SNR, del inglés, Signal Noise Ratio).

Visto esto, pasamos a ver detalles específicos del ADC (en realidad dispone de 3, según podemos leer en su datasheet) disponible en la placa STM32F4 Discovery.

Sus características mas interesantes son (ver RM0090 Reference Manual):

Resolución configurable: 6, 8, 10 y 12 bits.
19 canales multiplexados: 16 de ellos conectados a los puertos de entrada/salida, 2 canales internos conectados a un sensor de temperatura y para medir la tensión de referencia del ADC y un tercero para el canal de la batería para RTC (del inglés, Real Time Clock).
Configuración de lectura: conversión única o continua sobre uno o varios canales y modos scan para conversión automática desde el canal 0 al canal 'n' o discontinuo.
Alineación a izquierda o derecha en registro de 16 bits del valor convertido.
Almacenamiento a través de DMA (del inglés, Direct Memory Access).

A continuación, y como es de costumbre, vemos el diagrama de bloques del microcontrolador para identificar el bus de conexión del ADC.

Como se puede apreciar, se encuentra conectado al APB2 y también podemos identificar los 3 ADC a los que se hacia referencia mas arriba.

Y en la siguiente imagen podemos ver el diagrama de bloques del ADC.

Tras esto veremos una tabla resumen de los canales del ADC para conocer su asignación a cada pin de entrada/salida de la placa y conexiones internas.

ADC Channel	I/O Pin	Internal
ADC123_IN0	PA0	-
ADC123_IN1	PA1	-
ADC123_IN2	PA2	-
ADC123_IN3	PA3	-
ADC12_IN4	PA4	-
ADC12_IN5	PA5	-
ADC12_IN6	PA6	-
ADC12_IN7	PA7	-
ADC12_IN8	PB0	-
ADC12_IN9	PB1	-
ADC123_IN10	PC10	-
ADC123_IN11	PC11	-
ADC123_IN12	PC12	-
ADC123_IN13	PC13	-
ADC12_IN14	PC14	-
ADC12_IN15	PC15	-
ADC1_IN16	-	Temperature sensor
ADC1_IN17	-	V_ref
ADC1_IN18	-	V_bat

Como se aprecia, no todos los canales de los ADC disponibles están asignados, en concreto algunos del ADC3. Para seleccionar un puerto de entrada/salida antes debemos cerciorarnos de que este no esta siendo usado por otro periférico, lo cual podemos comprobar en UM1472 User Manual.

Visto esto, pasaremos a realizar algunos ejemplos de programación del ADC.

Inicialmente configuraremos un solo canal y realizaremos la lectura, primero por software, y a continuación mediante trigger (pin de entrada/salida o timer).

Lo primero que haremos, como siempre, será configurar el pin de entrada/salida. En este caso elegiremos el pin PA1, pues el PA0 esta conectado al botón de usuario. También haremos lo mismo con los pines de los leds para generar una visualización que varie con el valor medido.

void GPIO_Configure (void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_AHB1PeriphClockCmd (RCC_AHB1Periph_GPIOA, ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
//    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;

//    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init (GPIOA, &GPIO_InitStructure);

    /* Leds */
    RCC_AHB1PeriphClockCmd (RCC_AHB1Periph_GPIOD, ENABLE);

                                /* LED4 Green | LED3 Orange |  LED5 Red   | LED6  Blue */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init (GPIOD, &GPIO_InitStructure);
}

La configuración del ADC es algo mas larga pero igualmente sencilla. A continuación la vemos y se detallan algunos parámetros.

void ADC_Configure (void)
{
    ADC_InitTypeDef ADC_InitStructure;
    ADC_CommonInitTypeDef ADC_CommonInitStructure;

    RCC_APB2PeriphClockCmd (RCC_APB2Periph_ADC1, ENABLE);

    ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
    ADC_InitStructure.ADC_ScanConvMode = DISABLE;
    ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
    ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConvEdge_None;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_NbrOfConversion = 1;
    ADC_Init (ADC1, &ADC_InitStructure);

    ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
    ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;
    ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
    ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
    ADC_CommonInit (&ADC_CommonInitStructure);

    ADC_RegularChannelConfig (ADC1, ADC_Channel_1, 1, ADC_SampleTime_3Cycles);

    ADC_Cmd (ADC1, ENABLE);
}

Seleccionamos la máxima resolución del ADC, puesto que no tenemos ningún tipo de restricción temporal que nos obligue a reducir esta y desactivamos los modos scan y continuo, ya que vamos a usar un único canal (ADC_ScanConvMode = DISABLE) y el bucle principal será quien haga la petición de conversión (ADC_ContinuousConvMode = DISABLE). Como vamos a realizar la conversion por software, no estableceremos el flanco del trgigger (ADC_ExternalTrigConvEdge = AD_ExternalTrigConvEdge_None), de forma que el siguiente valor no tiene efecto. Los datos estarán justificados a la derecha (el bit menos significativo del valor obtenido coincide con el bit menos significativo del registro que lo contenga). Para que el ADC pueda realizar una única conversión deberá estar en modo independiente. Con intención de obtener una alta tasa de muestreo, se ha divido el reloj del APB2 por 2 para que el reloj del ADC sea de 42 MHz. Se ha desactivado el modo DMA e igualmente se ha escogido el valor mas pequeño para el intervalo de tiempo entre conversiones del ADC.

El cálculo de la tasa de muestreo del ADC en este caso es muy sencilla. Tan solo se ha de conocer el numero de ciclos de reloj que requiere la conversión con una resolución de 12 bits, siendo este igual a 12. A esto hay que añadirle ADC_SampleTime_3Cycles de la configuración del canal y la mitad de los ciclos entre conversiones, es decir, 2.5 ciclos (no tiene sentido hablar de medio ciclo). Con esto nos queda lo siguiente:

$$\frac { 12+3+2.5 }{ 42 } =0.416667us\rightarrow \frac { 1 }{ 0.416667 } =2.4Msps$$

Se obtiene una tasa de muestreo de 2.4 Msps, que coincide con el valor dado en el datasheet de este.

Por último, la función que se encarga de realizar la conversión es la siguiente.

uint16_t ADC_Read (void)
{
    ADC_SoftwareStartConv (ADC1);
    while (ADC_GetFlagStatus (ADC1, ADC_FLAG_EOC) == RESET);
    return ADC_GetConversionValue (ADC1);
}

Simplemente llama a la función de librería ADC_SoftwareStartConv y espera a que termine la conversión para devolver el valor obtenido, en este caso a una variable local del main como se ve a continuación:

int main (void)
{
    uint16_t ADC_ConvertedValue = 0;

    GPIO_Configure ();
    ADC_Configure ();

    while (1)
    {
        ADC_ConvertedValue = ADC_Read ();

        if (ADC_ConvertedValue == 0)
        {
            GPIO_ResetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
        }
        else if (ADC_ConvertedValue > 0 && ADC_ConvertedValue < 1024)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_13);
            GPIO_ResetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15);
        }
        else if (ADC_ConvertedValue >= 1024 && ADC_ConvertedValue < 2048)
        {
            GPIO_Pin_13 | GPIO_Pin_14);
            GPIO_ResetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_15);
        }
        else if (ADC_ConvertedValue >= 2048 && ADC_ConvertedValue < 3072)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
            GPIO_ResetBits (GPIOD, GPIO_Pin_12);
        }
        else if (ADC_ConvertedValue >= 3072 && ADC_ConvertedValue < 4096)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
        }
    }
}

Aquí, a parte de la lectura del valor convertido, se hace una pequeña decodificación, de forma que mientras mayor sea el valor leído, mas leds se encenderán. Si intentamos sacar mayor provecho a esta programación, podemos hacer que la función de lectura ADC_Read () tenga un parámetro que sea el canal a leer. Asi pues, si además del canal ya configurado, queremos también poder leer los canales internos (sensor de temperatura, tensión de referencia y monitorización de batería), procederíamos de la siguiente forma. En ADC_Config () añadiríamos la activación de dichos canales con las siguientes lineas

1 2	ADC_TempSensorVrefintCmd (ENABLE); ADC_VBATCmd (ENABLE);

y eliminaríamos la linea de configuración del canal regular, que pasaría a la función de lectura de la siguiente forma:

uint16_t ADC_Read (uint8_t ADC_Channel)
{
    ADC_RegularChannelConfig (ADC1, ADC_Channel, 1, ADC_SampleTime_3Cycles);
    ADC_SoftwareStartConv (ADC1);
    while (ADC_GetFlagStatus (ADC1, ADC_FLAG_EOC) == RESET);
    return ADC_GetConversionValue (ADC1);
}

Para leer los valores modificaremos de la siguiente nuestro main:

int main (void)
{
    uint16_t ADC_ConvertedValue = 0, TempSensor_ConvertedValue = 0, Vref_ConvertedValue = 0, Vbat_ConvertedValue = 0;
    float vTempSensor = 0, temp = 0, Vbat = 0;

    GPIO_Configure ();
    ADC_Configure ();

    while (1)
    {
        ADC_ConvertedValue = ADC_Read (ADC_Channel_1);

        if (ADC_ConvertedValue == 0)
        {
            GPIO_ResetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
        }
        else if (ADC_ConvertedValue > 0 && ADC_ConvertedValue < 1024)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_13);
            GPIO_ResetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15);
        }
        else if (ADC_ConvertedValue >= 1024 && ADC_ConvertedValue < 2048)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_13 | GPIO_Pin_14);
            GPIO_ResetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_15);
        }
        else if (ADC_ConvertedValue >= 2048 && ADC_ConvertedValue < 3072)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
            GPIO_ResetBits (GPIOD, GPIO_Pin_12);
        }
        else if (ADC_ConvertedValue >= 3072 && ADC_ConvertedValue < 4096)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
        }

        TempSensor_ConvertedValue = ADC_Read (ADC_Channel_16);
        vTempSensor = (float) TempSensor_ConvertedValue / 4095;    // vTempSensor (mV) = 3300 * (TempSensor_ConvertedValue / 4095)
        vTempSensor *= 3300;
        temp = vTempSensor - 760;    // temp (ºC) = ((Vsense - V25) / Average_slope) + 25
        temp /= 2.5;
        temp += 25;

        Vref_ConvertedValue = ADC_Read (ADC_Channel_17);

        Vbat_ConvertedValue = ADC_Read (ADC_Channel_18);
        Vbat = (float) Vbat_ConvertedValue * 2;    // Internal bridge divider by 2
        Vbat /= 4095;    // Vbat (mV) = 3300 * ((Vbat_ConvertedValue * 2) / 4095)
        Vbat *= 3300;
    }
}

La información de las expresiones mostradas se puede ver en UM1472 User Manual.

En el siguiente vídeo se puede ver una demostración de esto.

En el siguiente enlace a dropbox se encuentra la programación de este ultimo ejemplo: ADC SoftConv STM32F4 Discovery Dropbox

Para finalizar esta primera parte de la entrada, veremos como activar la conversión del ADC mediante un trigger (pin de entrada/salida o timer). En este caso nos decantaremos por la opción de la interrupción externa, de modo que procederemos a configurar el puerto PD11 (podría ser cualquier otro puerto pero siempre el pin 11) como entrada digital y seguidamente su interrupción, como se ve a continuación:

void EXTI_Configure (void)
{
    EXTI_InitTypeDef EXTI_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB2PeriphClockCmd (RCC_APB2Periph_SYSCFG, ENABLE);

    SYSCFG_EXTILineConfig (EXTI_PortSourceGPIOD, EXTI_PinSource11);

    EXTI_InitStructure.EXTI_Line = EXTI_Line11;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    EXTI_Init (&EXTI_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x2;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x2;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init (&NVIC_InitStructure);
}

En mi caso puenteé el pin PA0 conectado al botón de usuario con el usado aquí para facilitar la generación del pulso para la interrupción.

También tendremos que modificar la configuración del ADC para que se active la conversión a partir de la interrupción programada.

void ADC_Configure (void)
{
    ADC_InitTypeDef ADC_InitStructure;
    ADC_CommonInitTypeDef ADC_CommonInitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB2PeriphClockCmd (RCC_APB2Periph_ADC1, ENABLE);

    ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
    ADC_InitStructure.ADC_ScanConvMode = ENABLE;
    ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
    ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_Rising;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_Ext_IT11;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_NbrOfConversion = 4;
    ADC_Init (ADC1, &ADC_InitStructure);

    ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
    ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;
    ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
    ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
    ADC_CommonInit (&ADC_CommonInitStructure);

    ADC_TempSensorVrefintCmd (ENABLE);
    ADC_VBATCmd (ENABLE);

    ADC_RegularChannelConfig (ADC1, ADC_Channel_1, 1, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC1, ADC_Channel_16, 2, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC1, ADC_Channel_17, 3, ADC_SampleTime_3Cycles);
    ADC_RegularChannelConfig (ADC1, ADC_Channel_18, 4, ADC_SampleTime_3Cycles);

    ADC_EOCOnEachRegularChannelCmd (ADC1, ENABLE);

    ADC_ITConfig (ADC1, ADC_IT_OVR, ENABLE);
    ADC_ITConfig (ADC1, ADC_IT_EOC, ENABLE);

    NVIC_InitStructure.NVIC_IRQChannel = ADC_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
    NVIC_Init (&NVIC_InitStructure);

    ADC_Cmd (ADC1, ENABLE);
}

El funcionamiento esperado de este código es que tras la interrupción generada en el pin PD11 se active la conversión de los canales del ADC, de forma que con cada conversión, se genera una interrupción de fin de conversión (función ADC_EOCOnEachRegularChannelCmd), y tener un contador en la interrupción que controle cual es el canal convertido.

void ADC_IRQHandler (void)
{
    if (ADC_GetITStatus (ADC1, ADC_IT_EOC) != RESET)
    {
        static int i = 0;

        if (i == 0)
        {
            ADC_ConvertedValue = ADC_GetConversionValue (ADC1);
            i++;
        }
        else if (i == 1)
        {
            TempSensor_ConvertedValue = ADC_GetConversionValue (ADC1);
            i++;
        }
        else if (i == 2)
        {
            Vref_ConvertedValue = ADC_GetConversionValue (ADC1);
            i++;
        }
        else if (i == 3)
        {
            Vbat_ConvertedValue = ADC_GetConversionValue (ADC1);
            i = 0;
        }

        ADC_ClearITPendingBit (ADC1, ADC_IT_EOC);
    }
    else if (ADC_GetITStatus (ADC1, ADC_IT_OVR) != RESET)
    {
        ADC_ClearITPendingBit (ADC1, ADC_IT_OVR);
    }
}

void EXTI15_10_IRQHandler (void)
{
    if (EXTI_GetITStatus (EXTI_Line11) != RESET)
    {
        EXTI_ClearITPendingBit (EXTI_Line11);
    }
}

Ademas, para que el ADC sepa que tiene que realizar mas de una conversión, además de modificar el valor de ADC_NbrOfConversion se deberá activar el modo Scan.

Como he dicho en el parrafo anterior, el funcionamiento esperado es el comentado. Pero al momento de probarlo no es así. El fallo (no he conseguido determinarlo) es que al inicio de la conversión, tras la detección de la interrupción, se activa el flag de Overrun (pérdida de datos de las conversiones), de forma que impide que la conversión de canales continúe. He intentado solventarlo, activando dicha interrupción y limpiando su flag, pero con la siguiente interrupción externa se vuelve a generar la comentada y no permite finalizar todas las conversiones. Si consigo dar con la solución o alguien tuviera idea de como resolverlo, bienvenida sea la ayuda para poderlo corregir.

He comentado todo esto debido a que, como expondré en la segunda parte, esta forma de convertir varios canales se prefiere usarla junto con el DMA, de forma que no se interrumpe al microcontrolador y se realiza mas rápido la transferencia de los valores convertidos a memoria. En cualquier caso, vuelvo a dejar un archivo de dropbox con esta configuración: ADC ExtTrig STM32F4 Discovery Dropbox

TIMER STM32F4 Discovery

2016-01-04T17:16:00.003+01:00

Los sistemas electrónicos digitales destacan siempre por la capacidad para trabajar con tiempos con gran precisión. Esta funcionalidad recae sobre los Timers, periféricos imprescindible en todo microcontrolador, que partiendo de su funcionalidad genérica, permite desarrollar otras como la generación de un interrupciones, control PWM, input capture (permite determinar la frecuencia y ancho de pulso de una señal de entrada) o output compare (principio del PWM, generación de formas de ondas).

En esta ocasión pasaremos a ver unos ejemplos de la generación de una interrupción y el control de PWM, ya que no requieren de hardware externo para la comprobación de su funcionamiento. Mas adelante intentaré incluir algunos ejemplos para poder ver sus otras aplicaciones.

En primer lugar vamos a ver una introducción a la arquitectura del microcontrolador STM32F407 con respecto a los Timers. Como siempre partimos del diagrama de bloques en el que se aprecian todos los periféricos de los que disponemos.

Así pues, nuestro microcontrolador dispone de 14 timers, los cuales clasificaremos en tres grupos según su capacidad funcional (mas información de esto en RM0090 - Reference manual):

Timers de control avanzado (TIM1 y TIM8): consisten en un contador de 16 bits con autorecarga controlado por un prescaler programable. Permiten realizar todas las funcionalidades que se han comentado al inicio además de otras también relacionadas con el control PWM.

Timers de propósito general (TIM2 a TIM5 y TIM9 a TIM14): consisten en un contador de 16 o 32 bits con autorecarga controlado por un prescaler programable. Realizan las mismas funcionalidades que las comentadas al inicio pero con limitaciones en otras de las que si disponen los timers anteriores.

Timers básicos (TIM6 y TIM7): consisten en un contador de 16 bits con autorecarga controlado por un prescaler programable. Ademas de la generación básica de tiempos, permiten interactuar con otros periféricos (al igual que los anteriores), para el control de estos (como ADC y DAC).

En las imágenes presentadas se puede ver claramente como la complejidad del diagrama de bloques disminuye de una clasificación a la siguiente, y por descontado, la funcionalidad de los timers.

Un aspecto en común a todos los timers es el cálculo del valor que se cargará en el registro del contador (registro de autorecarga). Este se obtiene de forma muy sencilla a partir de la siguiente expresión:

$$CK_{ cnt }=\frac { { CK }_{ psc } }{ { TIMx }_{ psc }+1 }$$

Si despejamos el tiempo a cargar en el prescaler nos queda:

$${ TIMx }_{ psc }=\frac { { CK }_{ psc } }{ CK_{ cnt } } -1$$

Ahora tenemos el contador programado para una frecuencia específica. A partir de dicha frecuencia es sencillo calcular el valor que se cargará en el registro del este, pues simplemente se habrá de buscar la relación entre el periodo que queremos para la interrupción del timer y el periodo de la frecuencia seleccionada.

Visto esto, pasamos a exponer un ejemplo de configuración de uno de estos timers, en concreto el TIM7 (dentro de los timers básicos), para generar una interrupción con la que controlaremos la secuencia de encendido de los leds disponibles en la placa.

Empezaremos por configurar los puertos de entrada/salida para comandar los leds de la placa. Esto podemos verlo en entradas anteriores, GPIO STM32F4 Discovery.
Tras esto procedemos a la configuración del TIM7 y de su interrupción.

void TIMER_Configure (void)
{
    TIM_TimeBaseInitTypeDef TIMER_TimeBaseInitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB1PeriphClockCmd (RCC_APB1Periph_TIM7, ENABLE);

    TIMER_TimeBaseInitStructure.TIM_Prescaler = 8400 - 1;
    TIMER_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIMER_TimeBaseInitStructure.TIM_Period = 10000 - 1;
    TIMER_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIMER_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit (TIM7, &TIMER_TimeBaseInitStructure);

    TIM_ITConfig (TIM7, TIM_IT_Update, ENABLE);

    NVIC_InitStructure.NVIC_IRQChannel = TIM7_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init (&NVIC_InitStructure);

    TIM_Cmd (TIM7, ENABLE);
}

Para este caso, tenemos programada la frecuencia del contador a 10 KHz (hay que tener en cuenta que este timer tiene un PLL interno que dobla la frecuencia de entrada, siendo esta de la del APB1, 42 MHz)

$${ TIMx }_{ psc }=\frac { { CK }_{ psc } }{ CK_{ cnt } } -1=\frac { 84000000 }{ 10000 } -1=8400-1$$

Para obtener una animación de los leds apreciable al ojo humano, programaremos la interrupción del timer con un periodo de 1 segundo, de modo que el valor que habremos de cargar es 10000 - 1. Para facilitar el manejo de este valor, el contador se configura en modo ascendente, de forma que cuando este llega al valor cargado vuelve automáticamente a cero y comienza de nuevo la cuenta.
Dicha animación se ejecuta en la rutina de atención a la interrupción del TIM7 como se ve a continuación (el bucle principal del microcontrolador se encuentra vacío):

void TIM7_IRQHandler (void)
{
    if (TIM_GetITStatus (TIM7, TIM_IT_Update ) != RESET)
    {
        if (GPIO_ReadOutputDataBit (GPIOD, GPIO_Pin_12) == Bit_SET)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_13);
            GPIO_ResetBits (GPIOD, GPIO_Pin_12);
        }
        else if (GPIO_ReadOutputDataBit (GPIOD, GPIO_Pin_13) == Bit_SET)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_14);
            GPIO_ResetBits (GPIOD, GPIO_Pin_13);
        }
        else if (GPIO_ReadOutputDataBit (GPIOD, GPIO_Pin_14) == Bit_SET)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_15);
            GPIO_ResetBits (GPIOD, GPIO_Pin_14);
        }
        else if (GPIO_ReadOutputDataBit (GPIOD, GPIO_Pin_15) == Bit_SET)
        {
            GPIO_SetBits (GPIOD, GPIO_Pin_12);
            GPIO_ResetBits (GPIOD, GPIO_Pin_15);
        }
    TIM_ClearITPendingBit (TIM7, TIM_IT_Update);
    }
}

Aquí simplemente se detecta que led esta encendido para pasar a activar el siguiente y apagar el actual.

A continuación podemos ver un pequeño vídeo donde se ve el efecto de esta animación.

Y finalmente, el proyecto para importar a SW4STM32: TIMER Interrupt STM32F4 Discovery Dropbox

Vista la funcionalidad genérica de los timers, pasamos a ver otro ejemplo, en este caso sobre PWM, en el que se irá variando la intensidad lumínica de un led auxiliar (se aprecia mejor que directamente sobre los leds de la placa).

Para este ejemplo haremos uso del TIM4. También nos valdremos de la interrupción programada anteriormente para variar progresivamente el ancho del pulso del PWM.
Así pues, lo primero que haremos será configurar los puertos de entrada y salida. En este caso usaremos solo el pin del led azul, GPIO_Pin_15, en modo función alternativa, como se ve a continuación:

void GPIO_Configure (void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_AHB1PeriphClockCmd (RCC_AHB1Periph_GPIOD, ENABLE);

    GPIO_PinAFConfig (GPIOD, GPIO_PinSource15 , GPIO_AF_TIM4);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init (GPIOD, &GPIO_InitStructure);
}

Con esto conseguimos que la salida output compare 4 del timer en cuestión se configure para este cometido y podemos con ello ver el efecto sobre el led conectado al mismo pin.

Lo siguiente será establecer la configuración del TIM4 para la generación del PWM. Antes de ver el codigo correspondiente a este aspecto, veremos una imagen donde se muestra el funcionamiento del output compare.

Fuente: PWM

Como podemos ver, y veremos a continuación, la linea roja de la gráfica superior se corresponde con el valor que cargaremos en el registro del contador (en nuestro caso 8400 - 1) y la linea en verde es el ancho del pulso del PWM (su valor máximo sera el anterior). El funcionamiento es muy sencillo: cuando el contador supera el valor escogido para el ancho del pulso, la salida digital cambia de estado para generar el PWM y vuelve a cambiar con el final de cuenta para completar el pulso. Seguidamente se muestra el código implementado:

void TIMER_Configure (void)
{
    TIM_TimeBaseInitTypeDef TIMER_TimeBaseInitStructure;
    TIM_OCInitTypeDef  TIMER_OCInitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB1PeriphClockCmd (RCC_APB1Periph_TIM7, ENABLE);

    TIMER_TimeBaseInitStructure.TIM_Prescaler = 8400 - 1;
    TIMER_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIMER_TimeBaseInitStructure.TIM_Period = 10000 - 1;
    TIMER_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIMER_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit (TIM7, &TIMER_TimeBaseInitStructure);

    TIM_ITConfig (TIM7, TIM_IT_Update, ENABLE);

    NVIC_InitStructure.NVIC_IRQChannel = TIM7_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init (&NVIC_InitStructure);

    TIM_Cmd (TIM7, ENABLE);

    RCC_APB1PeriphClockCmd (RCC_APB1Periph_TIM4, ENABLE);

    TIMER_TimeBaseInitStructure.TIM_Prescaler = 0;
    TIMER_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIMER_TimeBaseInitStructure.TIM_Period = 8400 - 1;
    TIMER_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIMER_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit (TIM4, &TIMER_TimeBaseInitStructure);

    TIMER_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
    TIMER_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    TIMER_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
    TIMER_OCInitStructure.TIM_Pulse = 1 - 1;
    TIM_OC4Init (TIM4, &TIMER_OCInitStructure);
    TIM_OC4PreloadConfig (TIM4, TIM_OCPreload_Enable);

    TIM_Cmd (TIM4, ENABLE);
}

Inicialmente dejaremos intacta la configuración del TIM7 para, en su interrupción, cambiar el valor del ancho del pulso. También podríamos, en vez de reutilizar la interrupción, cambiar el valor del ancho del pulso del PWM cada vez que se pulse el botón de usuario, esto se deja comentado para quien quiera probarlo.

Para el TIM4 mantenemos la frecuencia de entrada para el contador, 84 MHz, y es en el registro de este donde determinamos el ancho máximo del pulso del PWM. Tras esto configuramos el PWM. El aspecto mas interesante aquí es la elección de la polaridad de comparación, de modo que obtenemos la forma de la segunda gráfica de la imagen anterior al seleccionar TIM_OCPolarity_Low (TIM_OCPolarity_High genera la forma de la tercera gráfica). Finalmente establecemos un valor para el ancho del pulso.

Como dijimos antes, la variación del ancho del pulso lo haremos mediante la interrupción del TIM7 como se ve a continuación:

void TIM7_IRQHandler (void)
{
    static int i = 0;
    if (TIM_GetITStatus (TIM7, TIM_IT_Update ) != RESET)
    {
        TIM_SetCompare4 (TIM4, pulse [i]);

        i++;
        if (i == 9)
     i = 0;

 TIM_ClearITPendingBit (TIM7, TIM_IT_Update);
    }
}

Donde

1	uint32_t pulse [9] = {0, 1050 - 1, 2100 - 1, 3150 - 1, 4200 - 1, 5250 - 1, 6300 - 1, 7350 - 1, 8400 - 1};

Simplemente iremos incrementando el indice del vector anterior, con cada iteración de la interrupción, para conseguir la variación del PWM que podemos apreciar en el siguiente vídeo. Dado que en el led de la placa era difícil de apreciar, y mas aun en la grabación, se ha colocado un led de alta luminosidad en paralelo para poder observar el efecto.

Y de nuevo, el proyecto listo para importar: TIMER Pwm STM32F4 Discovery Dropbox

Como ya dije anteriormente, existen otras funcionalidades también interesantes que requieren de hardware externo para poderlas comprobar, así que si dispongo de estos, me gustaría continuar actualizando esta entrada. De mientras continuaré realizando estos pequeños post sobre los demás periféricos disponibles.

EXTI STM32F4 Discovery

2015-06-30T22:04:00.003+02:00

Como vimos en GPIO STM32F4 Discovery, el empleo del polling es una técnica muy sencilla, pero por contra, tiene el inconveniente de que puede generar retardos no deseados y también, que el evento o flanco no sea detectado debido a que en ese momento se esté ejecutando otra línea de código, ademas del consumo de recursos para realizar el sondeo de los periféricos.

Para solventar estos defectos, sin introducir una gran dificultad al código, recurrimos al empleo de interrupciones. Según Wikipedia una interrupción es una señal recibida por un procesador para indicarle que debe interrumpir la ejecución normal de este y pasar a ejecutar el código especifico para tratar la situación requerida por la interrupción. Dicho código se conoce como ISR (Interrupt Service Routine, rutina de atención a la interrupción).

Nuestro dispositivo en concreto, dispone de 23 lineas de interrupción externas:

16 de ellas (EXTI_Line0 a EXTI_Line15) están disponibles para direccionarlas directamente a los puertos de entrada/salida. Por ejemplo, si la interrupción se genera en el pin PA0 (botón de usuario) se usará EXTI_Line0, si la interrupción se genera en el pin PD5 se usará EXTI_Line5 y así sucesivamente.
Las restantes 7 están conectadas a periféricos específicos, según vemos en la siguiente tabla:

EXTI_Line	Periférico
EXTI_Line16	PVD Output
EXTI_Line17	RTC Alarm event
EXTI_Line18	USB OTG FS Wakeup from suspended event
EXTI_Line19	Ethernet Wakeup event
EXTI_Line20	USB OTG HS Wakeup event
EXTI_Line21	RTC Tramper and Time Stamp events
EXTI_Line22	RTC Wakeup event

A continuación nos centraremos en las lineas de interrupción EXTI_Line0 a EXTI_Line15, que son las que conciernen a los pines de entrada/salida (por usar el botón de usuario).

Una vez seleccionada la linea (PA0 en nuestro caso) se habrá de configurar el manejador de interrupciones (interrupt handler) mediante el NVIC (Nested Vector Interrupt Controller), que se encarga de seleccionar la interrupción de mayor prioridad y de activar y desactivar estas (soporta hasta 256 vectores de interrupción diferentes).

En la siguiente tabla podemos ver el manejador de las interrupciones de los pines de entrada/salida para configurar el NVIC:

EXTI_Line	IRQn	ISR
EXTI_Line0	EXTI0_IRQn	EXTI0_IRQHandler
EXTI_Line1	EXTI1_IRQn	EXTI1_IRQHandler
EXTI_Line2	EXTI2_IRQn	EXTI2_IRQHandler
EXTI_Line3	EXTI3_IRQn	EXTI3_IRQHandler
EXTI_Line4	EXTI4_IRQn	EXTI4_IRQHandler
EXTI_Line5 a EXTI_Line9	EXTI9_5_IRQn	EXTI9_5_IRQHandler
EXTI_Line10 a EXTI_Line15	EXTI15_10_IRQn	EXTI15_10_IRQHandler

Y en las siguientes imágenes podemos ver lo hasta aquí descrito:

Vista esta pequeña introducción a la configuración de las interrupciones, pasamos a ver el ejemplo en el que se alterna la iluminación de los leds.

Las funciones de configuración (GPIO_Configure y SysTick_Configure) son las mismas, ademas de las utilizadas para generar los delays (Delay y TimingDelay_Decrement). En cambio, se ha introducido una nueva función de configuración para la interrupción del botón de usuario, como podemos ver a continuación:

void EXTI_Configure (void)
{
    EXTI_InitTypeDef EXTI_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB2PeriphClockCmd (RCC_APB2Periph_SYSCFG, ENABLE);

    SYSCFG_EXTILineConfig (EXTI_PortSourceGPIOA, EXTI_PinSource0);

    EXTI_InitStructure.EXTI_Line = EXTI_Line0;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_Init (&EXTI_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init (&NVIC_InitStructure);
}

Lo primero es configurar SYSCFG para que sea consciente de que se usarán las interrupciones y a continuación especificamos la procedencia de estas. La estructura de inicialización de la interrupción externa se comenta a continuación:

Dado que usamos el pin cero, usaremos EXTI_Line0, que como se comentó, tiene correspondencia directa con el numero del pin que se escoja.
Se configura en modo interrupción (EXTI_Mode_Interrupt).
Se escoge como disparo de la interrupción el flanco de subida (EXTI_Trigger_Rising).
Se activa la linea de interrupción (ENABLE).

Seguidamente vemos la estructura del vector de interrupciones:

Se escoge el canal 0 de las interrupciones externas, que como vimos antes, corresponde en cierta medida con el pin escogido (EXTI0_IRQn).
Se escoge el nivel de prioridad (valor de 0 a 15), siendo 0 al no existir mas interrupciones.
Se escoge el nivel de subprioridad (valor de 0 a 15), que igualmente será 0 (0x0 en hexadecimal) al no existir mas interrupciones con el mismo nivel de prioridad.
Se activa el canal de interrupción (ENABLE).

Tras la configuración e inicialización de la interrupción, pasamos a ver la rutina de atención a la interrupción (ISR).

void EXTI0_IRQHandler (void)
{
    if (EXTI_GetITStatus (EXTI_Line0) != RESET)
    {
        i++;

        if (i == 3)

            i = 0;

        EXTI_ClearITPendingBit (EXTI_Line0);

}
}

Cada vez que se pulse el botón, se accederá a la rutina anterior, en la cual se comprobará que la interrupción ha sido generada en la linea que esperamos y a continuación se incrementará el valor de i, en este caso declarada como variable global en el main a la que haremos referencia de la siguiente forma:

1	extern int i;

Las lineas descritas son las que finalmente sustituyen a la funcionalidad de las siguientes lineas que aparecían en el main del programa de la entrada anterior.

if (GPIO_ReadInputDataBit (GPIOA, GPIO_Pin_0) == 1)
{
    while (GPIO_ReadInputDataBit (GPIOA, GPIO_Pin_0) == 1);

    i++;

    if (i == 3)
        i = 0;

Finalmente vuelvo a colocar un pequeño vídeo en el que esta funcionando en nuestro dispositivo el programa descrito. En este caso, se puede pulsar el botón en cualquier momento, que la rutina detectará esto e incrementará el contador i, pero si se pulsa varias veces antes de esperar a que finalice la secuencia actual de iluminación, saltará a la secuencia que indique i y no a la que iría justo después de la actual.

En la siguiente entrada hablaremos de los Timers, presentando primero su uso mas sencillo, la generación de una interrupción cada x tiempo, seguido de otros empleos habituales de estos.

Y aquí está, como será siempre, el proyecto listo para importar: EXTI STM32F4 Discovery Dropbox

GPIO STM32F4 Discovery

2015-06-28T15:22:00.000+02:00

Como dije anteriormente, me dispongo a compartir el primer ejemplo de uso de la placa STM32F4 Discovery, que como era de esperar, se trata del popular "Hola mundo!" introductorio a las clases de programación en C, pero en esta ocasión quienes "dirán hola" serán los leds de los que dispone la placa, junto con el botón también disponible en esta, para dar a conocer así la configuración de los puertos de entrada y salida. ¡Al lío!

En esta ocasión, se trata de un código corto y muy sencillo, por lo que lo pondré todo por aquí. Para cuando el código sea mas largo o tenga muchas librerías, haré hincapié en la entrada en los aspectos mas interesantes, y finalmente dejaré disponible en Dropbox o algún servidor tipo GitHub el proyecto al completo, para que simplemente haya que importarlo al IDE SW4STM32.

El main de nuestro programa se encargará, mediante polling sobre el botón de usuario, de cambiar la secuencia de iluminación de los leds.
Lo primero que haremos será configurar la interrupción SysTick_Handler que nos servirá para realizar delays que nos permitan modificar el estado de los leds y de tiempo a verlo. Aquí podemos ver la función de inicialización:

void SysTick_Configure (void)
{
    RCC_ClocksTypeDef RCC_Clocks;

    RCC_GetClocksFreq (&RCC_Clocks);
    SysTick_Config (RCC_Clocks.HCLK_Frequency / 1000);
}

Dicha interrupción llama a una función que se encarga de decrementar el valor que se le pasa por la función Delay.

void SysTick_Handler(void)
{
    TimingDelay_Decrement ();
}

Esta es la opción "por defecto" para generar delays al tener implementada esta interrupción. Otra mas sencilla seria mediante bucles while o for, pero la primera opción permite tener un control mas exacto del tiempo. En este caso la interrupción SysTick_Handler se ejecutará cada ms (esto se puede variar cambiando el valor que se le pasa a SysTic_Config, por ejemplo, dividiendo por 1000000, se ejecutaría cada us). Las funciones aquí mencionadas son:

void Delay (uint32_t nTime)
{
    TimingDelay = nTime;

    while(TimingDelay != 0);
}

void TimingDelay_Decrement (void)
{
    if (TimingDelay != 0x00)
    {

        TimingDelay--;

}
}

Tras esto realizaremos la configuración de los puertos de entrada/salida mediante la función GPIO_Configure:

void GPIO_Configure (void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    /* User button */
    RCC_AHB1PeriphClockCmd (RCC_AHB1Periph_GPIOA, ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
    GPIO_Init (GPIOA, &GPIO_InitStructure);

    /* Leds */
    RCC_AHB1PeriphClockCmd (RCC_AHB1Periph_GPIOD, ENABLE);

                  /* LED4 Green | LED3 Orange |  LED5 Red   | LED6  Blue */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init (GPIOD, &GPIO_InitStructure);
}

Para ello activamos el reloj de los periféricos GPIOA (para el botón de usuario) y GPIOD (para los leds) mediante la función RCC_xxxxPeriphClockCmd, donde "xxxx" corresponde al bus (AHB1, AHB2, AHB3, APB1, APB2). Vuelvo a colocar la imagen del núcleo del microcontrolador donde se pueden apreciar estos buses:

A continuación rellenamos las estructuras de configuración de los puertos. Los distintos modos de configuración se pueden ver en el archivo de librería stm32f4xx_gpio.h, siendo los nuestros:

Botón de usuario:

Se encuentra conectado al pin 0 del puerto A (GPIO_Pin_0).
Se ha configurado en modo entrada (GPIO_Mode_IN).
Se ha usado la velocidad mas alta (GPIO_Speed_100MHz).
La configuración de la salida no es critica, puesto que es una entrada, estando configurado en push pull (GPIO_OType_PP).
Se le ha conectado una resistencia de pull down (GPIO_PuPd_DOWN), debido a la conexión eléctrica dispuesta en la placa, como podemos ver en la siguiente imagen:

Leds:

Se encuentran conectados a los pines 12 a 15 del puerto D (GPIO_Pin_12 a GPIO_Pin_15).
Se ha configurado en modo salida (GPIO_Mode_OUT).
Se ha usado también la velocidad mas alta.
La configuración de la salida esta en modo push pull (GPIO_OType_PP).
No se le ha conectado resistencia de pull up ni pull down (GPIO_PuPd_NOPULL).

Una vez rellenadas las estructuras de configuración, se realiza la inicialización de los periféricos mediante la función GPIO_Init.

Finalmente vemos el funcionamiento del main. Tras ejecutar las funciones descritas anteriormente encenderemos uno tras otro los cuatro ledas para comprobar su funcionamiento. A continuación entraremos en un while infinito donde se comprobará en cada ejecución de este el valor del botón de usuario. Si este está activo se incrementará el contador i y cambiará la iluminación de los leds.

#include "stm32f4xx.h"
#include "stm32f4_discovery.h"
#include "functions.h"

int main (void)
{
    int i = 0;

    SysTick_Configure ();
    GPIO_Configure ();

    GPIO_SetBits (GPIOD, GPIO_Pin_12);
    Delay (500);
    GPIO_SetBits (GPIOD, GPIO_Pin_13);
    Delay (500);
    GPIO_SetBits (GPIOD, GPIO_Pin_14);
    Delay (500);
    GPIO_SetBits (GPIOD, GPIO_Pin_15);
    Delay (500);

    while (1)
    {
        if (GPIO_ReadInputDataBit (GPIOA, GPIO_Pin_0) == 1)

            while (GPIO_ReadInputDataBit (GPIOA, GPIO_Pin_0) == 1);

            i++;

            if (i == 3)

                i = 0;

        if (i == 0)

            GPIO_ToggleBits (GPIOD, GPIO_Pin_12);

            Delay (500);

            GPIO_ToggleBits (GPIOD, GPIO_Pin_13);

            Delay (500);

            GPIO_ToggleBits (GPIOD, GPIO_Pin_14);

            Delay (500);

            GPIO_ToggleBits (GPIOD, GPIO_Pin_15);

            Delay (500);

        else if (i == 1)

            GPIO_SetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);

            Delay (300);

            GPIO_ResetBits (GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);

            Delay (300);

        else if (i == 2)

            GPIO_SetBits (GPIOD, GPIO_Pin_12);

            Delay (500);

            GPIO_ResetBits (GPIOD, GPIO_Pin_12);

            Delay (200);
            GPIO_SetBits (GPIOD, GPIO_Pin_13);
            Delay (500);
            GPIO_ResetBits (GPIOD, GPIO_Pin_13);
            Delay (200);
            GPIO_SetBits (GPIOD, GPIO_Pin_14);
            Delay (500);
            GPIO_ResetBits (GPIOD, GPIO_Pin_14);
            Delay (200);
            GPIO_SetBits (GPIOD, GPIO_Pin_15);
            Delay (500);
            GPIO_ResetBits (GPIOD, GPIO_Pin_15);
            Delay (200);
        }
    }
}

Este modo de comprobar el estado del botón (o de cualquier otro periférico), denominado polling, introduce un inconveniente, pues para comprobar su estado es necesario esperar a que finalice la ejecución del bucle while y también genera una espera para comprobar que el botón ha vuelto al estado inactivo para evitar una ejecución continua no deseada. Esto se evita mediante el empleo de interrupciones, que será el tema a tratar en la siguiente entrada.

Aquí podéis ver un vídeo en el que se muestran los efectos de los leds y también como influye la técnica del polling en la ejecución del código (para asegurarme que pasa de un estado a otro he de dejar el botón pulsado hasta que finaliza el ciclo de iluminación actual).

También dejo disponible el proyecto en Dropbox para importar a SW4STM32 en el siguiente enlace: GPIO STM32F4 Discovery Dropbox

STM32F4 Discovery

2015-06-24T11:52:00.000+02:00

Hace ya varios años que tengo una placa programable de STMicroelectronics que conseguí gratis gracias a un amigo, la STM32 Value Line Discovery,

la cual ofrecían para participar en un concurso. Por entonces no tenía ni idea de como se usaba, así que tras adquirir experiencia durante la carrera, comencé a programar sobre esta, hasta que de ultimo decidí pasarme, a la que he denominado la hermana mayor, la STM32F4 Discovery, y dado que es una placa con mucho que contar, me he propuesto realizar algunos ejemplos de uso de esta.

En esta ocasión me dedicaré simplemente a ver los detalles mas importantes de esta placa, y algunos de los programas que usaré para interactuar con dicho dispositivo (STM32F4 Discovery MB997C).

Las características principales de esta placa son (sacadas del manual de usuario):

Microcontrolador STM32F407VGT6.
Programador/depurador ST-LINK V2 (conector USB mini A) y conector SWD.
Acelerómetro LIS3DSH de tres ejes.
Micrófono digital omnidireccional MP45DT02.
Decodificador de audio (DAC) de 24 bits CS43L22.
Cuatro leds y un botón de usuario.
USB OTG (conector USB micro AB).
Extensión de entradas y salidas para conexión rápida.

Las características principales del microcontrolador STM32F407VGT6 son (observar imagen, aquí se nombran las que se usarán principalmente):

Núcleo ARM Cortex M4 de 32 bits a 168 MHz (210 DMIPS) con 1 MB Flash y 192 KB RAM.
USB OTG FS.
Entradas/salidas: 8 puertos de 16 bits + 1 puerto de 12 bits con función alternativa.
14 timers, 6 USART, 3 SPI, 3 I2C, 3 ADC, 2 DAC, 2 CAN ...

Para el desarrollo del código usé Atollic True Studio (lo tuve que dejar debido a la limitación de los 32 KB de programa) y Eclipse (las librerías por defecto eran las HAL y estoy acostumbrado a las Standard, ademas de que es mas engorrosa la generación de nuevos proyectos), pero finalmente me decanté por una opción completamente libre y que permite escoger que librerías quieres, se trata del IDE SW4STM32. Para conseguirlo simplemente hay que registrarse en el enlace anterior.

También he recurrido en ocasiones al software STM32CubeMX, para obtener unas configuraciones rápidas de los periféricos, pero dado que también hace uso de las librerías HAL, no me centrare apenas en este.

Finalmente, y dado que es un aspecto muy interesante, también hago amplio uso del software LabView para el desarrollo de aplicaciones que permitan monitorizar y controlar en tiempo real los periféricos programados en la placa. En ocasiones se usara también un monitor de interfaz serie para estos aspectos.

La instalación de estos programas es muy sencilla, por lo que simplemente expondré unas capturas de la creación de proyectos y algunos aspectos relevantes de estos.

SW4STM32

File -> New -> C Project.

Damos nombre al proyecto y seleccionamos "Ac6 STM32 MCU Project".

Click en Next.

Seleccionamos la placa dentro de la serie SM32F4 (deseleccionar las mismas opciones para búsqueda mas rápida) y hacemos click en Next.

Seleccionamos "Standard Peripheral Library (StdPeriph)" y "As sources" (si no generará un segundo proyecto donde estarán dichas librerías) y en caso de que haga falta se añadirán también de "Additional drivers" o "Additional utilities and third-party utilities" y hacemos click en Finish.

El contenido final del proyecto se encuentra distribuido de la siguiente forma:

Así pues, tenemos la librería "StdPeriph_Driver" con los drivers de los periféricos; la carpeta "Utilities" para el manejo rápido de funciones del DAC de audio, el acelerómetro y el botón y leds de usuario; la carpeta "inc" para incluir nuestros propios header files; la carpeta "src" para nuestros source files; la carpeta "startup" que contiene la rutina de inicio de la placa (no os asoméis a ella, esta en ensamblador ... ;-)) y la carpeta "CMSIS" con las funciones propias del nucleo de nuestro microcontrolador.

Una vez escrito y compilado (icono del martillo) el código, nos vamos a la venta de depuración (icono de la cucaracha), momento en el que posiblemente aparezca esta ventana, donde seleccionaremos la primera opción.

Tras esto se nos presentará la siguiente ventana, y con ayuda de los botones play, pause y stop, ademas del uso de breakpoints, realizaremos la depuración del código.

Si en vez de realizar la depuración queremos directamente cargar el código en la placa, usamos el icono del play justo al lado de la cucaracha.

STM32CubeMX

New Project.

En la ventana que se nos abre seleccionamos nuestra placa y hacemos click en OK.

A continuación configuramos los periféricos que vayamos a necesitar (el stick en verde significa que esta programado, el warning significa que solo parte se puede programar debido a que otro periférico este usando alguna de las entradas/salidas del microcontrolador y la cruz en rojo significa que no se podrá usar a menos que se desconfigure el periférico que este usando la función alternativa que capa a este último).

Una vez realizada la configuración hacemos click en Project -> Generate Code, damos nombre al proyecto, seleccionamos el IDE, en mi caso "SW4STM32" y finalmente hacemos click en Ok.

LabView

Create Project.

Seleccionamos "Blank VI" y click en Finish.

Cuando generamos el proyecto nos aparecen dos ventanas, la de la izquierda, "Front Panel" será la interfaz de usuario final y la de la derecha, "Block Diagram" relaciona "eléctricamente" los elementos que aparecen en la primera.

Terminal v1.93b

Por último, muestro una captura del programa para monitorizar el puerto serial (para realizar una comprobación rápida de los datos que circulan por dicha interfaz), que sera la forma de comunicar la placa con el PC.

En unos días comenzaré a publicar algunos ejemplos de uso de los periféricos mas interesantes mientras disponga de herramientas o dispositivos para comprobar el correcto funcionamiento.

Diseño antenas FM

2012-06-29T13:04:00.001+02:00

Haciendo alusión a la entrada anterior, “Transmisor FM 4 watt”, en esta ocasión traigo algunos diseños de antena para probar una vez tengamos el transmisor en funcionamiento.

Dipolo simple

En primer lugar expondré el tipo de antena más empleado para este campo, y el más sencillo de realizar, con unos resultados bastante buenos, se trata de la antena en dipolo simple. La antena en dipolo trata de dos elementos (varillas) metálicos a los que se conectan el vivo y masa del cable de antena, y se dispone en forma vertical. Algunas imágenes:

Las pautas a seguir para su construcción son las siguientes:

Como se puede apreciar en las imágenes, los brazos del dipolo quedan sujetos al mástil horizontal que luego se colocara en uno vertical que será el que este apoyado en tierra. La longitud de dichos brazos puede ser calculada como L = 150 / f, siendo f la frecuencia de emisión, usada en la ecuación en MHz. La longitud obtenida queda expresa en metros, pero esta será corregida en un 95 % debido al efecto de bordes, luego la longitud real será L = 150 * 0.95 / f.
Para conformar la antena, se puede acoplar los brazos del dipolo y el mástil que los sujeta en una placa de metacrilato, siendo estos de aluminio o cobre (elementos más usados), en forma de alambre o tubo delgado. Un ejemplo de esto puede ser:

A la hora de la conexión del cable a la antena se puede optar por soldar o unir directamente sobre los dipolos, o usar conectores entre la antena y el cable, para que sea más practica su colocación y transporte.
Los brazos de los dipolos han de estar aislados eléctricamente, ya que en otro tipo de antenas parecidas, los dipolos direccionales, los brazos de esta sí están conectados eléctricamente.
También se ha de tener en cuenta, que para cuando llueva la soldadura o unión del cable a la antena puede verse afectada, por lo que se habrá de realizar algún tipo de caja para para aislar las conexiones. A la hora de colocar la antena, cuidar la distancia con cualquier objeto (suelo y paredes), separarla al menos una vez la longitud de onda de nuestra frecuencia. La distancia a separar la obtendremos como D = c / f, siendo c la velocidad de la luz (300000000 m/s) y f la frecuencia de emisión, en este caso empleada en Hz.

Aquí una posible disposición final de la antena

Dipolo direccional

Otro tipo de antena, muy parecida a la anterior, es el dipolo direccional. Físicamente es como el dipolo simple, salvo que esta tiene otro elemento más pequeño al que se conecta el vivo del cable de antena, y toda la antena está conectada a la masa del cable. Esta es otra antena de fácil y rápida construcción, con la que se obtienen también muy buenos resultados, pero requiere más ajustes que la anterior. Primero unas imágenes para ir dándole forma:

Las pautas a seguir para su construcción son las siguientes (en esta ocasión seguiré una guía expuesta por un usuario de www.forosdeelectronica.com)

Para empezar expondré el material a emplear:

- Una varilla de aluminio de 10 mm de diámetro y 2.5 m de longitud (esta conformara el dipolo direccional)

- Una varilla de aluminio de 8 mm de diámetro y 50 cm de longitud (para unir los brazos del dipolo)

- Barra de aluminio de 20*20 mm y 1 m de longitud

- Conector tipo PL

- Cable de antena

Haciendo uso de la barra cuadrada se realizaran las perforaciones que aparecen en la imagen. Las dos pequeñas son de 8 mm realizadas a 10 - 15 mm del borde, y las otras dos, la pequeña es de 8 mm y la grande de 15 mm ( esta es para el conector PL) a una distancia de 5 cm de las anteriores.

A continuación se colocaran en los agujeros más exteriores un trozo de la varilla de 8 mm de unos 15 mm de longitud, y se unirá con un tornillo a la barra cuadrada.

Se cortara un pedazo de cable de antena de hasta unos 40 (según la imagen de mas adelante se elegirá dicha medida, expresada como C) cm y se retira la cubierta y la malla. Este se suelda al conector PL hembra, como en la imagen.

Una vez hecho esto, se colocara el conector PL en la barra cuadrada, y se cortara otro pedazo de varilla, en esta ocasión de la de 10 mm, de algo más de los 40 cm (elegirlo en la imagen de más adelante, expresada como C) del cable de antena, para realizar la disposición de las imágenes:

Seguidamente se colocaran los elementos que forman el dipolo, cuya longitud la determinaremos de la siguiente imagen (expresada como A/2 la longitud de cada brazo), uniendolos a las varilla ya colocada en la barra cuadrada con tornillos.

Aquí la imagen antes mencionada:

En cuanto al montaje del dipolo, se pueden seguir otros métodos, como hacerlo con una varilla entera o soldando la varilla completa como se aprecia en las imágenes

Lo último consiste en colocar el puente, el cual nos ayudara a obtener el mejor resultado con la antena (ajustar el punto de resonancia). Estos se pueden hacer de alambre (para buscar el punto de resonancia y luego sustituirlo por algo más agradable a la vista) o con una lámina de latón, aluminio o cobre.

Aquí una posible disposición final, en este caso muestro mi antena:

Ahora llega el punto en el que la gente suele ponerse nerviosa, después de haberse montado una joya como es esta antena. Toca coger el medidor de ROE y moviendo el puente se buscara obtener una lectura de 1,2 : 1. Si no es así se llega a un punto más laborioso, en el que toca recortas secciones del cable hasta aproximarse a dicha medida o estar por debajo de ella, claro.
Una vez ajustada a la mínima reflejada (proceso anterior), estarás en disposición de colocar nuestra antena a una distancia mínima de cualquier obstáculo, esta será de D = c / f, siendo c la velocidad de la luz (300000000 m/s) y f la frecuencia de emisión, en este caso empleada en Hz.

Transmisor FM 4 watt

2012-06-27T22:35:00.000+02:00

Descripción general

Se trata de un transmisor de FM pequeño pero bastante potente que consta de tres etapas de RF además de un preamplificador de audio para una mejor modulación. Tiene una potencia de salida de 4 vatios y funciona con 12-18, lo que hace que sea fácil de transportar. Es el proyecto ideal para el principiante que desee iniciarse en el fascinante mundo de la radiodifusión de FM y quiere un buen circuito de base para experimentar.

Especificaciones técnicas. Características

Tipo de modulación: ........ FM

Rango de frecuencia: .... 88-108 MHz

Voltaje de trabajo: ..... 12-18 VDC

Corriente máxima: ....... 450 mA

Potencia de salida: ............ 4 W

¿Cómo funciona?

La frecuencia de salida del transmisor es ajustable de 88 a 108 MHz, que es la banda de FM que se utiliza para la radiodifusión. El circuito, como ya hemos mencionado consta de cuatro etapas. Tres etapas de RF y un preamplificador de audio para la modulación. La primera etapa de RF es un oscilador y está construido alrededor de TR1. La frecuencia de oscilación es controlada por la red LC L1-C15. C7 se encarga de asegurar que el circuito continúa oscilante y C8 ajusta el acoplamiento entre el oscilador y la etapa de RF siguiente, que es un amplificador. Este se construye alrededor de TR2 que opera en clase C y está sintonizado por medio de L2 y C9. La última etapa de RF es también un amplificador construido alrededor de TR3 que opera en clase C, cuya entrada está sintonizada por medio de C10 y L4. Desde la salida de esta última etapa, que está sintonizada por medio de L3-C12 se toma la señal de salida que a través del circuito sintonizado L5-C11 va a la antena.

El circuito del preamplificador es muy simple y está construido alrededor de TR4. La sensibilidad de entrada de la etapa es ajustable con el fin de hacer posible el uso del transmisor con diferentes señales de entrada. Por supuesto, es posible utilizar un mezclador de audio en la entrada para resultados más profesionales.

Construcción

Este es un proyecto de RF, lo que exige atención durante la soldadura, un descuido durante la construcción puede significar una baja potencia de salida o incluso cero, poca estabilidad y otros problemas. Soldar primero de todos los pasadores (o puentes), y continuar con las bobinas, teniendo cuidado de no deformarlas, los RFC´s, las resistencias, los condensadores electrolíticos y, finalmente, los condensadores variables. Asegurarse de que el electrolítico se coloca correctamente con respecto a su polaridad y que los condensadores variables no se sobrecalientan durante la soldadura. Continuar con la soldadura de los transistores en sus lugares, teniendo cuidado de no sobrecalentar ya que son los más sensibles de todos los componentes utilizados en el proyecto. Los terminales de entrada de audio está en los puntos 1 (tierra) y 2 (señal), la fuente de alimentación está conectado a los puntos 3 (-) y 4 (+) y la antena está conectada a los puntos 5 (tierra) y 6 (señal). Como ya hemos mencionado que la señal se utiliza para la modulación del transmisor, puede ser la salida de un preamplificador o mezclador o se puede utilizar el micrófono piezoeléctrico. Como antena se puede usar un dipolo abierto o un plano de tierra. Antes de empezar a usar el transmisor o cada vez que cambie la frecuencia de trabajo debe seguir el procedimiento descrito a continuación que se llama alineación.

Esquema del circuito medidor

Esquema del transmisor

Diseño de la placa PCB

Ajustes (alineación)

Si busca que el transmisor sea capaz de entregar su potencia máxima en cualquier momento, debe alinear todas las etapas de RF con el fin de asegurar que se obtiene la mejor transferencia de energía entre ellos. Hay dos maneras de hacer esto y depende de si se tiene un medidor de ROE o no. Si se dispone de medidor de ROE encienda el transmisor, después de haber conectado el medidor de ROE en serie con la antena, girar C15 con el fin de ajustar el oscilador a la frecuencia que se ha elegido para transmitir. A continuación, iniciar el ajuste de los condensadores C8 C9 C10 C12 y C11 en este orden hasta que se consiga la máxima potencia de salida en el medidor de ROE. Para aquellos que no dispongan de un medidor de ROE hay otro método que da resultados bastantes satisfactorios.

Hay que construir el pequeño circuito de la figura, el cual se conecta a la salida del transmisor y en la salida se conecta un multímetro, seleccionando una escala de tensión adecuada (también existe una versión para usar con amperímetro).

Usar C15 para sintonizar la frecuencia deseada y luego ajuste los demás condensadores variables en el mismo orden en que se describe más arriba para la máxima lectura en el multímetro. La desventaja de este método es que no se alinea el transmisor con una antena real conectada a su salida y puede ser necesario para hacer pequeños ajustes a C11 y C12.

No olvidar de ajustar el transmisor cada vez que se cambie la antena o su frecuencia de trabajo.

En cada transmisor están presentes además de la salida principal, los armónicos de la frecuencia de salida, que suelen tener un alcance muy corto. Con el fin de asegurarse de no sintonizar los armónicos, desplazarse lo más lejos posible del transmisor para realizar la escucha, o usar un analizador de espectro para ver el espectro de salida y ajustar con esto el receptor en la frecuencia adecuada.

Lista de componentes

R1 = 220K

R2 = 4.7K

R3 = R4 = 10K

R5 = 82 Ohm

C1 = C2 = 4.7uF electrolítico

C3 = C13 = 4.7nF cerámico

C4 = C14 = 1nF cerámico

C5 = C6 = 470 pF cerámico

C7 = 11pF cerámico

C8 = 3-10pF variable

C9 = C12 = 7-35pf variable

C10 = C11 = 10-60pF variable

C15 = 4-20pf variable

L1 = 4 vueltas de cobre plateado con 5.5 mm de diámetro

L2 = 6 vueltas de cobre plateado con 5.5 mm de diámetro

L3 = 3 vueltas de cobre plateado con 5.5 mm de diámetro

L4 = dibujada en la PCB

L5 = 5 vueltas de cobre plateado con 7.5 mm de diámetro

RFC1 = RFC2 = RF3 = VK 200

TR1 = TR2 = 2N2219 NPN

TR3 = 2N3553 NPN

TR4 = BC547/BC548 NPN

Choque de RF VK200

Precaución

Este equipo de RF se presenta para uso experimental o de laboratorio. Su posesión y uso están limitados por las leyes que varían de estado a estado. Por favor, obtener información sobre lo que puede o no puede hacer en su área y permanecer dentro de los límites legales. Asegúrese de que no se conviertan en una molestia para los demás con sus experimentos.

Si no funciona

Revise su trabajo para posibles puentes a través de las vías adyacentes o los residuos de soldadura que usualmente causan problemas. Verifique de nuevo todas las conexiones externas hacia y desde el circuito para ver si hay un error allí.
Ver que no hay componentes que faltan o insertados en lugar equivocado.
Asegúrese de que todos los componentes están polarizados en el sentido correcto.
Asegúrese de que el suministro tiene la tensión correcta y está conectado en el sentido correcto de su circuito.
Revise su proyecto para los componentes defectuosos o dañados.
Revisar etapa por etapa para verificar el correcto funcionamiento de cada una de ellas.

Este circuito aun no lo he diseñado, estoy a la espera de mas entrado el verano para volver a la escuela y realizarlo allí. Por entonces subiré un vídeo y comentare los resultados y posibles modificaciones.

En mi canal de youtube tengo vídeos de hace ya algo de tiempo de mis primeros transmisores: http://www.youtube.com/user/yoluismi?feature=mhee

Teoría de Electrónica Analógica

2012-04-30T13:15:00.002+02:00

Después de mucho, mucho, sin una entrada, intentare dejar caer algunas. En esta ocasión se trata de parte de la teoría que estamos dando en la asignatura de Electronica Analógica.

Esta es la teoría que se da en la asignatura de Tecnología Electrónica, donde se ven los diodos (todos), diodos zener y transistores con todas sus características técnicas y practicas.

Diodos semiconductores: http://www.mediafire.com/download.php?mp568djd9kdn7pd
Diodos zener: http://www.mediafire.com/download.php?fu4x64hg3bvl287
Transistores BJT: http://www.mediafire.com/download.php?eiktkdl95bnbw7s

De aqui se sacan la mayoría de los fundamentos de diodos y transistores que se usaran en la asignatura de Electronica Analogica.

Aquí comienza la asignatura de Electrónica Analógica, pero seguramente que los documentos que presenten terminen mezclándose, ya que las mismas cosas de asignaturas anteriores se han ido usando en esta.

Tema 1 - Aplicaciones con diodos y transistores

Modelo en pequeña señal para transistores BJT (emisor común)

Modelos en parámetros híbridos para el BJT. El primero es el modelo completo, y el segundo es el simplificado, el que se ha usado en el formulario "Etapas amplificadoras básicas para transistores BJT". Ambos modelos son validos para los BJT en NPN y PNP.

Modelo en pequeña señal para transistores FET (fuente común)

Este modelo vale para los dos tipos de FET y para sus dos versiones, canal N y canal P.

Etapas amplificadoras básicas para modelos de pequeña señal

Etapas amplificadoras básicas para transistores BJT

Etapas amplificadoras básicas para transistores FET

Ordenes de magnitud de las etapas amplificadoras básicas (BJT y FET)

Modelo en gran señal para transistores FET canal N

Modelo en gran señal para transistores FET canal P

Modelo en gran señal para transistores BJT NPN (modelo ideal)

Modelo en gran señal para transistores BJT NPN (modelo de 1ª aproximación)

Modelo en gran señal para transistores BJT PNP (modelo ideal)

Modelo en gran señal para transistores BJT PNP (modelo de 1ª aproximación)

Tema 2 - Amplificadores realimentados

Estructura básica del amplificador realimentado

Detalles a comentar del diagrama de bloques:

Xif: señal que genera la fuente
Xi: señal que entra al amplificador básico
Xof: señal que llega a la carga
Xm. señal de muestreo
Xf: señal de comparación
A: ganancia del amplificador básico
B: factor de realimentación

Modelado del amplificador básico

Amplificador de tensión

Amplificador de intensidad

Amplificador de transimpedancia

Amplificador de transconductancia

Topologías de la red de realimentación

Modelado de la red de realimentacion

Serie - paralelo

Paralelo - serie

Serie - serie

Paralelo - paralelo

Topologías de los amplificadores realimentados

La parte mas teórica de este tema queda recogida en el pdf de mas abajo.

Tema 3 - Filtros. Estabilidad. Osciladores

Filtros de 2º orden

Filtro paso baja

Esta gráfica es la proporcionada en teoría

Esta gráfica se ha obtenido con el programa de simulación PsPice para el circuito mostrado (fo=1 KHz y Q=5)

Filtro paso alta

Esta gráfica es la proporcionada en teoría

Esta gráfica se ha obtenido con el programa de simulación PsPice para el circuito mostrado (fo=1 KHz y Q=5)

Para la obtención de los datos de los dos anteriores filtros se ha seguido el método de componentes iguales de manera que R1=R2 y C1=C2. Dicho método esta explicado en la teoría, para la cual se habría de emplear la tabla que aparecerá mas adelante.

Filtro paso de banda

Esta gráfica es la proporcionada en teoría

Filtro rechazo de banda

Esta gráfica es la proporcionada en teoría

La mencionada tabla para la obtención de los componentes es esta

En ella se muestran las ecuaciones que resultan de analizar los filtros de 2º orden antes expuestos. A la derecha de cada uno se tiene la misma expresión habiendo aplicado el método de componentes iguales. Para obtener los valores de los componentes solo hemos de conocer fo (frecuencia de resonancia, toma otros nombres según que autores) y Q (factor de calidad).

Nota: la expresión del filtro rechazo de banda no se ha escrito debido al volumen de esta, ademas también se a dado en el circuito los datos directamente en componentes iguales.

A la hora de la construcción de filtros de mayor orden, se puede recurrir a dos maneras de diseño:

Síntesis directa: RLC + OA, método que conlleva gran dificultad.
Diseño en cascada: para la obtención de un filtro de orden n se irán colocando filtros de menor orden en cascada. En este caso los componentes suelen ser obtenidos mediante programa informático. Mas antiguamente se partía de tablas como la siguiente.

En la siguiente imagen se muestran distintos tipos de gráficas a partir de las cuales se clasifican los filtros de orden n

Principios básicos de osciladores senoidales.

Para generar señales senoidales:

Osciladores lineales: amplificadores operacionales + red RC o LC + control no lineal de amplitud.
Osciladores no lineales: conformacion de señales triangulares en senoidales.

Para el control no lineal de amplitud se emplea el circuito siguiente:

Y su correspondiente gráfica, en la que se aprecia la señal de entrada (verde) y la de salida (roja) amplificada debido a que R8 e mayor que R1 e invertida por ser realimentación negativa. El recorte de la señal se obtendrá en función de la configuración que se disponga en el divisor de tensión que forman las 4 resistencias verticales.

Para el oscilador lineal se empleara el conocido puente de Wien (con control no lineal de amplitud):

El oscilador de puente de Wien en general es la totalidad del circuito quitando el divisor de tensión que forman las resistencias verticales y los diodos

Y su correspondiente gráfica (con el control de amplitud), en la que se aprecia la señal que se genera a la entrada (verde, en V- del amplificador) y la señal de salida (rojo), amplificada debido a la relación R4/R7 > 1 y en esta ocasión no invertida, debido a que la realimentación en este caso es positiva, que es lo general en este tipo de circuitos.

La gráfica que se obtendría para el oscilador sin el control de ganancia seria la siguiente, en la que se puede apreciar como ambas señales, la que genera el circuito y al obtenida a la salida, saturan a ciertos limites, como para la salida, que satura a la tensión de alimentación.

También se ha dado otra variación del oscilador, en este caso el oscilador con desplazamiento de fase:

En la gráfica se observa el desplazamiento de fase que existe entre las tres sondas de medida: verde (sonda del medio), rojo (sonda de la izquierda) y azul (sonda de la derecha).

Nuevamente, la teoría explicativa de este tema queda recogida en el pdf de mas abajo.

Dentro del siguiente link esta la teoría: http://www.mediafire.com/?ykvrm8bc8p5felf. Dicha teoría esta escrita por el profesor que nos imparte la asignatura. En ella se encuentran los temas que se imparten en la asignatura de Electrónica Analógica y los que se impartió en la asignatura de Electrónica Industrial.

También dejo aquí un vídeo de la practica que estamos realizando en la asignatura, un amplificador de audio con control de volumen y filtro de agudos y graves, hecho en casa, la practica terminará dentro de dos semanas, y hasta ahora va mejor el que me he montado yo que el de las practicas:

En los siguientes links están los guiones de la practica donde se realiza el amplificador del vídeo, por si alguien quiere practicar un poco.

Practica 3: http://www.mediafire.com/download.php?nucb61x85y3g77r

Practica 4: http://www.mediafire.com/download.php?tscs38sl8j3u159

Practica 5: http://www.mediafire.com/download.php?8zwrct09j5936yq

Y por si aun muestran mas interés, aquí ejercicios resueltos de la asignatura de Electrónica Analógica.

Tema 1

http://www.mediafire.com/download.php?delf2hdjqq53xlx

Tema 2

http://www.mediafire.com/download.php?gu3fuvulx18l4bp

Tema 3

http://www.mediafire.com/view/?c1i7ea6p4dtps1v

Este libro nos lo recomendó nuestro profesor de problemas (Electrónica Básica para Ingenieros),

http://www.mediafire.com/download.php?gog2n6ztoi5qj60

ademas de este otro, el cual es bastante conocido (Circuitos Microelectrónicos - Sedra, Smith):

http://www.mediafire.com/view/?dam7hzleiaru405

Nota: si algún link deja de estar activo, avisar en un comentario.

Superconductores

2011-09-14T11:19:00.000+02:00

Se denomina superconductividad a la capacidad intrínseca que poseen ciertos materiales para conducir corriente electrica sin resistencia ni pérdida de energía en determinadas condiciones.

La resistividad electrica de un conductor metálico disminuye gradualmente a medida que la temperatura se reduce. Sin embargo, en los conductores ordinarios, como el cobre y la plata, las impurezas y otros defectos producen un valor límite. Incluso cerca de cero absoluto una muestra de cobre muestra una resistencia no nula. La resistencia de un superconductor, en cambio, desciende bruscamente a cero cuando el material se enfría por debajo de su temperatura crítica. Una corriente electrica que fluye en una espiral de cable superconductor puede persistir indefinidamente sin fuente de alimentación. Al igual que el ferromagnetismo y las lineas espectrales atómicas, la superconductividad es un fenómeno de la mecánica cuántica.

La superconductividad ocurre en una gran variedad de materiales, incluyendo elementos simples como el estaño y el aluminio, diversas aleaciones metálicas y algunos semiconductores fuertemente dopados. La superconductividad no ocurre en metales nobles como el oro y la plata, ni en la mayoría de los metales ferromagnéticos.

Comportamiento magnético

Aunque la propiedad más sobresaliente de los superconductores es la ausencia de resistencia, lo cierto es que no podemos decir que se trate de un material de conductividad infinita, ya que este tipo de material por sí sólo no tiene sentido termodinámico. En realidad un material superconductor de tipo I es perfectamente diamagnético. Esto hace que no permita que penetre el campo, lo que se conoce como efecto Meissner.

El campo magnético distingue dos tipos de superconductores: los de tipo I, que no permiten en absoluto que penetre un campo magnético externo (lo cual conlleva un esfuerzo energético alto, e implica la ruptura bruscadel estado superconductor si se supera la temperatura crítica), y los de tipo II, que son superconductores imperfectos, en el sentido en que el campo realmente penetra a través de pequeñas canalizaciones denominadas vórtices de Abrikosov, o fluxones. Estos dos tipos de superconductores son de hecho dos fases diferentes que fueron predichas por Lez Davidovich Landau y Aleksey Alekséyevich Abrikósov.

Cuando a un superconductor de ipo II le aplicamos un campo magnético externo débil lo repele perfectamente. Si lo aumentamos, el sistema se vuelve inestable y prefiere introducir vórtices para disminuir su enérgia. Éstos van aumentando en número colocándose en redes de vórtices que pueden ser observados mediante técnicas adecuadas. Cuando el campo es suficientemente alto, el número de defectos es tan alto que el material deja de ser superconductor. Éste es el campo crítico que hace que un material deje de ser superconductor y que depende de la temperatura.

Comportamiento electrico

La aparición del superdiamagnetismo es debida a la capacidad del material de crear supercorrientes. Éstas son corrientes de electrones que no disipan energía, de manera que se pueden mantener eternamente sin obedecer el efecto Joule de pérdida de energía por generación de calor. Las corrientes crean el intenso campo magnético necesario para sustentar el efecto Meissner. Estas mismas corrientes permiten transmitir energía sin gasto eonergético, lo que representa el efecto más espectacular de este tipo de materiales. Debido a que la cantidad de electrones superconductores es finita, la cantidad de corriente que puede soportar el material es limitada. Por tanto, existe una corriente crítica a partir de la cual el material deja de ser superconductor y comienza a disipar energía.

En los superconductores de tipo II, la aparición de fluxones provoca que, incluso para corrientes inferiores a la crítica, se detecte una cierta disipación de energía debida al choque de los vórtices con los átomos de la red.

Descubrimiento

Ya en el siglo XIX se llevaron a cabo diversos experimentos para medir la resistencia eléctrica a bajas temperaturas, siendo James Dewar el primer pionero en este campo.

Sin embargo, la superconductividad como tal no se descubriría hasta 1911, año en que el físico holandés Heike Kamerlingh Onnes observó que la resistencia eléctrica del mercurio desaparecía bruscamente al enfriarse a 4 K (-269 °C), cuando lo que se esperaba era que disminuyera gradualmente hasta el cero absoluto. Durante los primeros años el fenómeno fue conocido como supraconductividad.

En 1913 se descubre que un campo magnético suficientemente grande también destruye el estado superconductor, descubriéndose tres años después la existencia de una corriente eléctrica crítica.

Puesto que se trata de un fenómeno esencialmente cuántico, no se hicieron grandes avances en la comprensión de la superconductividad, puesto que la comprensión y las herramientas matemáticas de que disponían los físicos de la época no fueron suficientes para afrontar el problema hasta los años cincuenta. Por ello, la investigación fue hasta entonces meramente fenomenológica, como por ejemplo el descubrimiento del efecto Meissner en 1933 y su primera explicación mediante el desarrollo de la ecuación de London dos años más tarde por parte de los hermanos Fritz y Heinz London.

Los superconductores de alta temperatura

Tras algunos años de relativo estancamiento, en 1986 Bednorz y Müller descubrieron que una familia de materiales cerámicos, los óxidos de cobre con estructura de perovsquita, eran superconductores con temperaturas críticas superiores a 90 kelvin. Estos materiales, conocidos como superconductores de alta temperatura, estimularon un renovado interés en la investigación de la superconductividadCooper". Y, debido a que el estado superconductor persiste hasta temperaturas más manejables, superiores al punto de ebullición del nitrógeno líquido, muchas aplicaciones comerciales serían viables, sobre todo si se descubrieran materiales con temperaturas críticas aún mayores.

Aplicaciones

Los imanes superconductores son algunos de los electroimanes más poderosos conocidos. Se utilizan en los trenes maglev, en máquinas para la resonancia magnética nuclear en hospitales y en el direccionamiento del haz de un acelerador de patículas. También pueden utilizarse para la separación magnética, en donde partículas magnéticas débiles se extraen de un fondo de partículas menos o no magnéticas, como en las industrias de pigmentos. Los superconductores se han utilizado también para hacer circuitos digitales y filtros de radiofrecuencia y microondas para estaciones base de telefonia móvil. Los superconductores se usan para construir uniones Josephson, que son los bloques de construcción de los SQUIDs (dispositivos superconductores de interferencia cuántica), los magnetómetros conocidos más sensibles. Una serie de dispositivos Josephson se han utilizado para definir el voltio en el sistema internacional (SI). En función de la modalidad de funcionamiento, una unión Josephson se puede utilizar como detectorde fotones o como mezclador. Aplicaciones futuras prometedoras incluyen tranformadores de alto rendimiento, dispositivos de almacenamiento de energía, la transmisión de energía eléctrica, motores eléctricos (por ejemplo, para la propulsión de vehículos, como en vactrains o trenes maglev) y dispositivos de levitación magnética. Sin embargo la superconductividad es sensible a los campos magnéticos en movimiento de modo que las aplicaciones que usan corriente alterna (por ejemplo, los transformadores) serán más difícil de elaborar que las que dependen de corriente continua.

Transmisor fm miniatura

2011-09-11T11:13:00.001+02:00

Este sencillo circuito, le permitirá transmitir señales de audio en un área de aproximadamente 100 mts de radio.

La señal emitida por el mismo, puede ser sintonizada en cualquier punto del dial de su radio de FM, pues su frecuencia de transmisión puede ser fácilmente localizada entre los 88 y los 108Mhz.

Sus usos son ilimitados, puede ser utilizado como monitor para bebes, como micrófono inalámbrico para conferencias, transmitir el audio del PC hacia algún otro punto de la casa.

Una de las aplicaciones más fascinantes de la electrónica, son las comunicaciones inalámbricas. Este proyecto permitirá iniciarse en dicho campo.

Este tipo de comunicaciones, están regidas por las normas de cada país, por lo cual no se deben exceder ciertos límites, la omisión de dichos límites, es castigada con multas y sanciones.

El transmisor de FM en miniatura, ha sido diseñado de tal forma que no exceda dichos límites de su frecuencia de oscilación que está comprendida entre los 88 y los 130Mhz y el campo generado por las irradiaciones, no supera los 50mV por metro, a una distancia de 15cm del circuito.

Si usted ensambla su circuito siguiendo las especificaciones que a continuación le daremos, no excederá dichos límites, pues cualquier modificación que se haga al circuito incluyendo pro ejemplo una variación en el voltaje de alimentación, cambiará el alcance de la señal emitida.

Lista de Materiales
2 Transistores 2N2222 (También pueden usar los 2N3904, BC547, BC548)

1 Micrófono Electret

2 Condensadores Electrolíticos 10uF/25v

1 Condensador Electrolítico de 2.2uF/25v

2 Condensadores Cerámicos de .1uF/50v

2 Condensadores Cerámicos de 2.7pF/50v (También pueden usar de 2.5pF)

1 Condensador ajustable de 5-60pF (trimmer)

2 Resistencias 1k

1 Resistencia 15K

1 Resistencia 6.8k

2 Resistencias 10K

2 Resistencias 4.7K

1 Resistencia 2.2K

1 Resistencia 220 Ohm

50 cm. Alambre para puentes de 0.51mm de diámetro (24 AWG)

Tornillos

1 Conector + Soporte para Batería

5 Espadines

1 Baquelita

1 Batería 9V

Cautín

Taladro

Soldadura

Estaño

Construcción de La Bobina
Para fabricar la bobina, tome el alambre para puentes y córtelo por mitad, tome los 2 trozos resultantes y enróllelos en un lapicero común dando 6 vueltas alrededor del mismo.

Aunque es más fácil conseguir el alambre para puentes, también se puede usar alambre de cobre esmaltado, eso sí, calibre #24.

Una vez hecho esto, retire el lapicero y separe las bobinas teniendo especial cuidado en no deformarlas, tome aquella que sea más uniforme y colóquela en su circuito.La otra, desenróllela y utilícela como antena, se preguntará por que se sigue este procedimiento que parece ilógico, la razón es que de esta forma se asegura que la separación entre las espiras es la necesaria y que es igual entre ellas así el transmisor funcionará correctamente.

Pasos Para El Ensamblaje
Soldar los componentes de menor altura como las resistencias.

Luego instale los condensadores cerámicos, el condensador variable (trimmer), los 5 espadines y los transistores.

Posteriormente, suelde los condensadores electrolíticos y la Bobina. Recuerde que en la Placa del circuito impreso el terminal identificado con el signo (-) en los condensadores debe quedar ubicado del lado opuesto del identificado con el signo (+).

Finalmente suelde el micrófono, teniendo en cuenta su polaridad, la antena y el conector para la batería de 9v a los espadines respectivos y asegure el soporte para la batería mediante los tornillos.

Funcionamiento
El transistor Q2 es el oscilador, Q1 es el amplificador para modular la señal.

La señal moduladora se aplica a la base de Q2 mediante C2, R6.

Los capacitores C6 y C7 son parte del oscilador.

Q2, L1, C5 conforman un circuito oscilador controlado por voltaje, el cual es modulado por el voltaje de audio que es amplificado por Q1.

C5 es usado para sintonizar el circuito oscilador estableciendo la frecuencia de oscilación.

C8 actúa como condensador de filtro.

Prueba y calibración del Circuito
Una vez que este seguro de que todos los componentes han sido ensamblados puede proceder a la prueba y calibración del circuito. Para ello, ubique una radio de FM cerca del circuito, busque en el dial un punto en silencio (sin emisoras) y suba el volumen del receptor hasta un punto en el que puede usted oír las interferencias.

Conecte una batería de 9v al circuito y escuche atentamente la radio.

Lentamente y con la ayuda de un destornillador pequeño, ajuste el condensador (trimmer C5) hasta que en el receptor se escuche un silbido o sonido similar, lo cual quiere decir que en dicho punto se ha sintonizado en el transmisor la frecuencia dial.

En ese momento puede hablar en el micrófono y se debe escuchar en la radio lo que se habla.

Si en la frecuencia seleccionada, no se logra una buena recepción, repita este procedimiento en otro punto de la banda de FM.

Si lo prefiere, en vez de variar el capacitor, sintonice la radio hasta hallar el punto donde encuentre mejor recepción (silencio).

Si después de hacer esto, no consigue sintonizar el transmisor, puede ajustar la bobina que conforma el circuito oscilador juntando sus espiras para elevar la frecuencia, o separando las mismas si lo que desea es reducirla un poco.

Este circuito funciona mejor cuando es alimentado por una batería pero si lo desea puede hacerlo con una fuente de alimentación regulada.

Sugerencias
Si usted desea mejorar la calidad de la transmisión de su circuito, en vez de soldar la antena directamente al circuito impreso, hágalo sobre la segunda espira de la bobina, partiendo del punto donde se une con el colector del transistor Q2.

Adicionalmente, si desea tener la posibilidad de controlar el volumen del transmisor, cambie la resistencia R6 por un potenciómetro, el cuál puede ser aproximadamente de 10K.

Para alargar la vida de la batería, desconéctela cuando no se esté usando el transmisor.

Si se quiere aplicar una señal de audio externa como por ejemplo de un MP3, se debe suprimir el micrófono y su resistencia de polarización R1, dejando como entrada de audio el capacitor de desacople C1.

Video de un transmisor en este caso de AM, ya que tiene menos restrinciones que la FM y esta en menor uso

La Ley de Ohm

2011-09-10T11:02:00.011+02:00

La Ley de Ohm establece que la intensidad que circula por un conductor, circuito o resistencia, es inversamente proporcional a la resistencia R y directamente proporcional a la tensión V.
La ecuación matemática que describe esta relación es:

Donde, I es la corriente que pasa a través del objeto en amperios, V es la diferencia de potencial de las terminales del objeto en voltios, y R es la resistencia en ohmios Ω. Específicamente, la ley de Ohm dice que la R en esta relación es constante, independientemente de la corriente.
Esta ley tiene el nombre del físico alemán Georg Ohm, que en un tratado publicado en 1827, halló valores de tensión y corriente que pasaba a través de unos circuitos eléctricos simples que contenían una gran cantidad de cables. Él presentó una ecuación un poco más compleja que la mencionada anteriormente para explicar sus resultados experimentales. La ecuación de arriba es la forma moderna de la ley de Ohm.

Historia

En enero de 1781, antes del trabajo de Georg Ohm, Henry Cavendish experimentó con botellas de Leyden y tubos de vidrio de diferente diámetro y longitud llenados con una solución salina. Como no contaba con los instrumentos adecuados, Cavendish calculaba la corriente de forma directa: se sometía a ella y calculaba su intensidad por el dolor. Cavendish escribió que la "velocidad" (corriente) variaba directamente por el "grado de electrificación" (tensión). Él no publicó sus resultados a otros científicos a tiempo, y sus resultados fueron desconocidas hasta que MNaxwell los publicó en 1879.
En 1825 y 1826, Ohm hizo su trabajo sobre las resistencias, y publicó sus resultados en 1827 en el libro Die galvanische Kette, mathematisch bearbeitet (Trabajos matemáticos sobre los circuitos electricos). Su inspiración la obtuvo del trabajo de la explicación teórica de Fourier sobre la conducción del calor.
En sus experimentos, inicialmente uso pilas voltaicas, pero posteriormente usó un termopar ya que este proveía una fuente de tensión con una resistencia interna y diferencia de potencial casi constante. Usó un galvanómetro para medir la corriente, y se dio cuenta que la tensión de las terminales del termopar era proporcional a su temperatura. Entonces agregó cables de prueba de diferente largo, diámetro y material para completar el circuito. El encontró que los resultados obtenidos podían modelarse a través de la ecuación:

Donde x era la lectura obtenida del galvanómetro, l era el largo del conductor a prueba, a dependía solamente de la temperatura del termopar, y b era una constante de cada material. A partir de esto, Ohm determinó su ley de proporcionalidad y publicó sus resultados.
La ley de Ohm todavía se sigue considerando como una de las descripciones cuantitativas más importante de la física de la electricidad, aunque cuando Ohm publicó por primera vez su trabajo las críticas lo rechazaron. Fue denominado "una red de fantasías desnudas", y el ministro alemán de educación afirmó que un profesor que predicaba tales herejías no era digno de enseñar ciencia. El rechazo al trabajo de Ohm se debía a la filosofía científica que prevalecía en Alemania en esa época, la cual era liderada por Hegel, que afirmaba que no era necesario que los experimentos se adecuaran a la comprensión de la naturaleza, porque la naturaleza esta bien ordenada, y que además la veracidad científica puede deducirse al razonar solamente. También, el hermano de Ohm, Martín Ohm, estaba luchando en contra del sistema de educación alemán. Todos estos factores dificultaron la aceptación del trabajo de Ohm, el cual no fue completamente aceptado hasta la década de los años 1840. Afortunadamente, Ohm recibió el reconocimiento de sus contribuciones a la ciencia antes de que muriera.
En los años 1850, la ley de Ohm fue conocida como tal, y fue ampliamente probada, y leyes alternativas desacreditadas, para las aplicaciones reales para el diseño del sistema del telégrafo, discutido por Morse en 1855.
En los años 1920, se descubrió que la corriente que fluye a través de un resistor ideal tiene fluctuaciones estadísticas, que dependen de la temperatura, incluso cuando la tensión y la resistencia son exactamente constantes. Esta fluctuación, conocida como ruido de Johnson-Nyquist, es debida a la naturaleza discreta de la carga. Este efecto térmico implica que las medidas de la corriente y la tensión que son tomadas por pequeños períodos de tiempo tendrá una relacion V/I que fluirá del valor de R implicado por el tiempo promedio de la corriente medida. La ley de Ohm se mantiene correcta para la corriente promedio, para materiales resistivos.
El trabajo de Ohm precedió a las ecuaciones de Maxwell y también a cualquier comprensión de los circuitos de corriente alterna. El desarrollo moderno en la teoría electromagnética y el análisis de circuitos no contradicen la ley de Ohm cuando estás son evaluadas dentro de los límites apropiados.

Simil hidraulico

En hidraulica se verifica una ley similar a la Ley de Ohm, que puede facilitar su comprensión. Si tenemos un fluido dentro de un tubo, la diferencia de presiones entre sus extremos equivale a la diferencia de potencial o tensión; el caudal a través del conducto equivale a la intensidad de la corriente eléctrica; y la suma de obstáculos que impiden la corriente del fluido equivale a la resistencia electrica.

Historia de la Pila

2011-09-09T13:02:00.001+02:00

Pila voltaica

En 1780, Luigi Galvani estaba diseccionando una rana, sujeta con un gancho de metal. Cuando tocó la pata de la rana con su bisturí de hierro, la pierna se encogió como si el animal aún estuviese vivo. Galvani creía que la energía que había impulsado la contracción muscular observada venía de la misma pierna, y la llamó "electricidad animal".

Sin embargo, Alessandro Volta, un amigo y colega científico, no estaba de acuerdo, creyendo que este fenómeno estaba causado realmente por la unión o contacto entre dos metales diferentes que estaban unidos por una conexión húmeda. El propio Volta verificó experimentalmente esta hipótesis, y la publicó en 1791. Fue perfeccionada hasta que, en 1800, Volta inventó la primera bateria o generador electroquimico capaz de producir una corriente electrica mantenida en el tiempo, y por ello fue conocida como pila voltaica.

La pila voltaica consiste de pares de discos de cobre y zinc apilados uno encima del otro, separados por una capa de tela o de cartón impregnado en salmuera (este era el electrolito). A diferencia de la botella de Leyden, la pila voltaica producía una corriente continua y estable, y perdía poca carga con el tiempo cuando no se la utiliza, aunque sus primeros modelos no podían producir una tensión lo suficientemente fuerte como para producir chispas.

Volta creía que la corriente se producía como resultado de la unión entre dos materiales diferentes, con sólo tocarse uno al otro (esta teoría científica obsoleta fue conocida como la tensión de contacto), y no como resultado de reacciones químicas. En consecuencia, consideró que la corrosión que sufrían las planchas de zinc podía ser un defecto relacionado que tal vez podría corregirse de alguna manera con el cambio de materiales. Sin embargo, ningún científico había conseguido evitar esta corrosión. De hecho, se observó que la corrosión era más rápido cuando se producía más corriente. Esto sugirió que la corrosión era realmente parte integrante de la capacidad de la la batería para producir una corriente. Esto, en parte, llevó al rechazo de la teoría de la tensión de contacto en favor de la teoría electroquímica.

Los modelos de pila originales de Volta tienen algunos fallos técnicos, como fugas del electrólito y cortocircuitos provocados debido al peso de los discos que comprimen los paños empapados en la salmuera. El inglés William Cruickshank resolvió este problema mediante la fijación de los elementos en una caja en lugar de amontonarlos en una pila. Esto fue conocido como la batería de artesa. El propio Volta diseñó una variante que consiste en una cadena de vasos llenos de una solución de sal, unidos por arcos metálicos sumergidos en el líquido. Esto fue conocido como la Corona de Copas o pila de corona. Estos arcos estaban hechos de dos metales diferentes (por ejemplo, zinc y cobre), soldados entre sí. Este modelo también demostró ser más eficiente que las pilas originales, aunque no fue tan popular.

Otro problema de las pilas de Volta era su corta duración (una hora en el mejor de los casos), lo cual estaba causado por dos fenómenos. El primero era que la corriente producía la electrolisis de la disolución de electrólitos, lo que originaba una película de burbujas de hidrógeno que se formaban en el electrodo de cobre, que aumentaba constantemente la resistencia interna de la batería. El otro era un fenómeno llamado de acción local, por el cual se formaban minúsculos cortocircuitos en torno a las impurezas del cinc, causando su degradación. Este último problema fue resuelto en 1835 por William Sturgeon, quien descubrió que mezclando algo de mercurio con el zinc se eliminaba este inconveniente.

A pesar de sus defectos, las pilas de Volta proporcionaban una corriente más permanente que las botellas de Leyden, e hizo posible muchos experimentos y descubrimientos nuevos, como la electrolisis del agua.

Pila Daniell

Un químico británico llamado John Frederic Daniell buscó una manera de eliminar el problema de las burbujas de hidrógeno que aparecen en la pila voltaica, y su solución fue utilizar un segundo electrolito para consumir el hidrógeno producido por el primero. En 1836, inventó la pila Daniell, que consistía en una vasija de cobre llena de una disolución de sulfato de cobre, en el que se sumerge un recipiente de barro sin esmaltar lleno de acido sulfúrico y un electrodo de zinc. La barrera de barro era porosa, lo que permitía a los iones pasar a través suya, pero impedía la mezcla de las dos disoluciones. Sin esta barrera, cuando no había corriente se comprobó que los iones de cobre (II) se derivaban hacia el ánodo de zinc y sufrían la reducción sin producir una corriente, destruyendo la vida de la batería.

Con el tiempo, la acumulación de cobre podría bloquear los poros de la barrera de barro y acortar la vida de la batería. Sin embargo, la celda de Daniell proporcionan una corriente mayor y más fiable que la pila voltaica, debido al depósito de cobre electrolítico en el cátodo (un conductor) en lugar de hidrógeno (un aislante). También era más segura y menos corrosiva. Tenía una tensión de funcionamiento de alrededor de 1,1 voltios. Fue ampliamente utilizada en las redes de telégrafo, hasta que fue suplantada por la pila Leclanche a finales de la década de 1860.

Pila de Grove

La pila de Grove fue inventada por William Robert Grove en 1844 y es una modificación de la pila Daniell. Consistía en un anodode zinc sumergido en acido sulfurico y un catodo de platino sumergido en acido nitrico, separados por barro poroso. La pila de Grove proporcionaba una corriente elevada y un voltaje casi dos veces superior al de la pila Daniell, por lo que fue la favorita de las redes telegráficas de América durante un tiempo. Sin embargo, se desprendían vapores tóxicos de óxido nítrico cuando estaba en operación. La tensión también se reducía considerablemente cuando la carga disminuía, lo que llegó a ser una responsabilidad cuando las redes telegráficas se hicieron más complejas.

Pila de plomo-acido: primera "pila" recargable

Hasta este punto, todas las baterías existentes debían ser vaciadas de forma permanente cuando se agotaban los reactivos y finalizaban todas sus reacciones químicas. En 1859, Gaston Planté inventó la bateria de plomo-ácido, el primer acumulador, o sea, la primera batería que puede recargarse (en realidad, regenerar las sustancias químicas gastadas) haciendo pasar una corriente en sentido inverso a través de ella. Una bateria de plomo bateria de plomo-ácido se compone de un ánodo de plomo y un cátodo de dioxido de plomo sumergidos en acido sulfúrico. Ambos electrodos reaccionan con el ácido para producir sulfato de plomo (II), pero la reacción en el ánodo de plomo libera electrones mientras que la reacción en el óxido de plomo los capta, lo que produce una corriente. Estas reacciones químicas pueden ser revertidas mediante la aplicación de una corriente en sentido inverso, lo que permite recargarla, al igual que se de debe hacer antes de su primer uso.

El primer diseño de Planté consistía en dos placas de plomo separadas por bandas de goma y enrolladas en espiral.Sus baterías se utilizaron por primera vez para alimentar la luz en los vagones del tren mientras se detenía en una estación. En 1881, Camille Alphonse Faure inventó una versión mejorada que consistía en una celosía o rejilla de plomo en la que se apelmazó una pasta de dióxido de plomo, formando una placa. Varias planchas podían apilarse para obtener un mayor rendimiento. Este diseño fue más fácil de producir en masa.

Celda de gravedad

Esta variante particular de la pila Daniell , también es conocida como celda de pata de gallo debido a la forma distintiva de uno de sus electrodos.

En algún momento durante la década de 1860, un francés con el nombre de Callaud inventó una variante de la pila Daniell llamada celda de gravedad. Esta versión más simple prescindió de la barrera porosa. Esto redujo la resistencia interna del sistema y por lo tanto la batería produjo una corriente más intensa. Rápidamente se convirtió en la batería de elección para las redes telegráficas americanas y británicas, y se utilizó hasta la década de 1950. En la industria del telégrafo, esta batería se montaba a menudo in situ por los propios trabajadores de telégrafos, y cuando ésta se agotaba, era renovada mediante la sustitución de los componentes consumidos.

La celda de gravedad consistía de un frasco de vidrio, con un cátodo de cobre asentado en la parte inferior y un ánodo de zinc (con forma parecida a una pata de gallo), colgado por debajo del borde. Se esparcían cristales de sulfato de cobre (II) junto al cátodo, y el frasco se llenaba con agua destilada. Cuando la corriente circulaba, se formaba una capa de disolución de sulfato de zinc en la parte superior junto al ánodo. Esta capa superior se mantenía separada de la capa de sulfato de cobre del fondo por su menor densidad y por la polaridad de la célula.

Por la celda de gravedad tenía que estar circulando, de modo continuo, una corriente para evitar que las dos disoluciones se mezclaran por difusion, por lo que esta celda no era adecuada para un uso intermitente.

Pila leclanche

En 1866, Georges Leclanche inventó una batería que consistía en un ánodo de zinc y un cátodo de dioxido de manganeso envueltos en un material poroso, sumergidos en un frasco de disolución de cloruro de amonio. El cátodo de dióxido de manganeso estaba mezclado con un poco de carbono que mejoraba la conductividad y la absorción de electrolitos. Suministraba un voltaje de 1,4 a 1,6 voltios.

Esta célula consiguió un éxito muy rápido en telegrafía, señalización y timbres eléctricos. Se utilizó para alimentar los primeros teléfonos, por lo general desde una caja de madera colocada junto a la pared, antes de que los teléfonos pudieron obtener la energía de la propia línea. No podía proporcionar una corriente sostenida durante mucho tiempo. En conversaciones largas, la batería se agotaba, haciendo inaudible la conversación. Esto se debía a que ciertas reacciones químicas en la célula aumentaban la resistencia interna y, por tanto, bajaba el voltaje. Estas reacciones se invertían cuando la batería se quedaba inactivo, por lo que estas pilas sólo eran adecuadas para un uso intermitente.

Pila de zinc-carbono: primera pila seca

En 1887, Carl Gassner patentó una variante de la celda Leclanché que llegó a ser conocida como la pila seca, ya que no tiene un electrolito líquido libre. En vez de eso, mezcló el cloruro de amonio con yeso de París para crear una pasta, con un poco de cloruro de zinc añadido para prolongar la vida útil. El cátodo de dióxido de manganeso se sumerge en la pasta, y ambos fueron encerrados en una carcasa de zinc, que también actuaba como ánodo.

A diferencia de las pilas húmedas, la pila seca Gassner era más sólida, no requería mantenimiento, no se derramaba y podría ser utilizado en cualquier orientación. Suministraba un potencial de 1,5 voltios. La primera pila seca producida en masa fue el modelo Columbia, comercializado por primera vez por la National Carbon Company (NCC) en 1896. Esta compañía mejoró el modelo de Gassner, sustituyendo el yeso de París por cartón en espiral, una innovación que dejaba más espacio para el cátodo y hacía que la batería fuera más fácil de montar. Fue la primera batería apropiada para el público en general e hizo prácticos los dispositivos eléctricos portátiles. La linterna se inventó ese mismo año. La batería de zinc-carbono todavía se fabrica hoy en día.

Paralelamente, en 1887 Federico Guillermo Luis Hellesen desarrolló su propio diseño de pila seca. Se ha afirmado que el diseño de Hellesen precedió al de Gassner.

Alrededor de 1936, los arqueólogos descubrieron en una aldea cercana a Bagdad, un conjunto de vasijas de terracota cada una de las cuales contenía un rollo de lámina de cobre que albergaba una varilla de hierro. Algunos científicos especulan que estos artilugios podrían ser antiguas celdas galvánicas (alrededor de 2.000 años de antigüedad, aunque el cálculo de la edad sigue siendo debatido), a los que se les denomina la "Bateria de Bagdad". Se cree que un ácido común de los alimentos, como el jugo de limón o vinagre, sirvió como un electrolito. Las réplicas modernas han producido con éxito corrientes eléctricas, dando crédito a esta hipótesis. Si la muestra fue de hecho una batería, pudo haber sido usada para galvanoplastia, para producir leves descargas eléctricas como fuente de experiencia religiosa, o simplemente utilizada para almacenar rollos antiguos.

Nacimiento del condensador. La botella de Leyden

2011-09-08T11:10:00.000+02:00

La botella de Leyden es un dispositivo eléctrico realizado con una botella de vidrio que permite almacenar cargas eléctricas. Históricamente la botella de Leyden fue el primer tipo de condensador.

Historia

En 1746, Pieter van Musschenbroek, que trabajaba en la Universidad de Leiden, efectuó un experimento para comprobar si una botella llena de agua podía conservar cargas eléctricas. Esta botella consistía en un recipiente con un tapón al cual le atraviesa una varilla metálica que queda sumergida en el líquido. La varilla tiene una forma de gancho en la parte superior al cual se le acerca un conductor cargado eléctricamente. Durante la experiencia un asistente separó el conductor y recibió una fuerte descarga al aproximar su mano a la varilla.

Un año más tarde el británico William Watson descubrió que aumentaba la descarga si la envolvía con una capa de estaño. Siguiendo los nuevos descubrimientos, Jean Antonie Nollet tuvo la idea de reemplazar el líquido por hojas de estaño, quedando desde entonces esta configuración de la botella que se utiliza actualmente para experimentos. Watson pudo transmitir una descarga eléctrica de manera espectacular produciendo una chispa eléctrica desde una botella de Leyden a un cable metálico que atravesaba el río Támesis en 1747. Las botellas de Leyden eran utilizadas en demostraciones públicas sobre el poder de la electricidad. En ellas se producían descargas eléctricas capaces de matar pequeños ratones y pájaros.

Funcionamiento

La botella de Leyden es un dispositivo que permite almacenar cargas eléctricas comportándose como un condensador. La varilla metálica y las hojas de estaño o aluminio conforman la armadura interna. La armadura externa esta constituida por la capa que cubre la botella. La misma botella actúa como un material dielectrico (aislante) entre las dos capas del condensador. El nombre de condensador proviene de las ideas del siglo XIX sobre la naturaleza de la carga eléctrica que asimilaban ésta a un fluido que podía almacenarse tras su condensación en un dispositivo adecuado como la botella de Leyden.

Este es el principio por el cual, si un rayo cae por diferencia de potencia en un avion, este no sufrirá en su interior ningún tipo de descarga ni alteración eléctrica.

Para los que les llame la atención, el experimento:

Se desarrolla con una botella de cristal, en la cual, se corta un trozo de lámina de aluminio de uso doméstico y con esto y con un rollo de película fotográfica, se envuelve el frasco. Posteriormente se coloca en el interior otro trozo de lámina de aluminio. En este punto del experimento podría emplearse pegamento pero existe el peligro de que los gases liberados en el interior puedan hacer explotar el frasco.

Se realiza una perforación en la tapa de la botella y se introduce en esta un tornillo y se asegura en la parte interior de la botella con un trozo de alambre obtenido de un clip para papel. Este alambre debe hacer contacto con la lámina que se ha colocado en el interior. Con un trozo de cable (con varios hilos) y se sujeta en la parte de arriba del tornillo; a esta parte se le conoce como "cepillo de colección".

Como generador se utiliza un tubo de PVC que se frota con un paño o un trozo de tela para generar electricidad estática.

El aparato se hace funcionar colocando la botella de Leyden en el borde de una mesa, luego se debe hacer que el cepillo de colección toque al tubo de PVC, mientras esto se realiza, se desliza frotando en el paño o tela. El alambre que sale de la botella de Leyden es una conexión a tierra. Se puede sujetar el frasco por la parte que tiene la lámina de aluminio y no se recibirá una descarga si no se toca la lámina y el tornillo.

Botella de Leyden

Condensador electrolítico

Condensador cerámico

Condensador tántalo

Condensador poliester

Condensador tubo

Condensador variable

¿Condensador de Fuzo? .... ¡¡¡Fluzeando!!!

(Marty McFly en 1985)

Transistor

2011-09-06T11:55:00.000+02:00

Reseña
Varios historiadores de la tecnologia consideran al transistor como el mayor invento del siglo XX. Es el dispositivo eletronico básico que dio lugar a los circuitos integrados y demás elementos de la alta escala de integración.

El transistor es un dispositivo electronico semiconductor que cumple funciones de amplificador, oscilador, conmutador o rectificador. El término "transistor" es la contracción en ingles de transfer resistor (resistencia de transferencia). Actualmente se encuentran prácticamente en todos los aparatos domésticos de uso diario: radios, televisores, grabadoras, reproductores de audio y video...

Historia
El transistor bipolar fue inventado en los Laboratorios Bell de EE. UU. en diciembre de 1947 por Jhon Bardeen, Walter Houser Brattain y William Bradford Shockley, quienes fueron galardonados con el Premio Nobel de Fisica en 1956. Fue el sustituto de la valvula termoionica de tres electrodos, o triodo.
El transistor de efecto de campo fue descubierto antes que el transistor (1930), pero no se encontró una aplicación útil ni se disponía de la tecnología necesaria para fabricarlos masivamente.
Es por ello que al principio se usaron transistores bipolares y luego los denominados transistores de efecto de campo. En los últimos, la corriente entre el surtidor o fuente y el drenaje se controla mediante el campo eléctrico establecido en el canal. Por último, apareció el MOSFET. Los MOSFET permitieron un diseño extremadamente compacto, necesario para los circuitos altamente integrados.
Hoy la mayoría de los circuitos se construyen con tecnología CMOS. La tecnología CMOS es un diseño con dos diferentes MOSFET (MOSFET de canal n y p), que se complementan mutuamente y consumen muy poca corriente en un funcionamiento sin carga.
El transistor consta de un sustrato (usualmente silicio) y tres partes dopadas artificialmente (contaminadas con materiales específicos en cantidades específicas) que forman dos uniones bipolares, el emisor que emite portadores, el colector que los recibe o recolecta y la base, que está intercalada entre las dos primeras, modula el paso de dichos portadores. A diferencia de las válvulas, el transistor es un dispositivo controlado por corriente y del que se obtiene corriente amplificada. En el diseño de circuitos a los transistores se les considera un elemento activo, a diferencia de los resistores, condesadores e inductores que son elementos pasivos. Su funcionamiento sólo puede explicarse mediante mecanica cuantica.
De manera simplificada, la corriente que circula por el colector es función amplificada de la que se inyecta en el emisor, pero el transistor sólo gradúa la corriente que circula a través de sí mismo, si desde una fuente de corriente continua se alimenta la base para que circule la carga por el colector, según el tipo de circuito que se utilice. El factor de amplificación o ganancia logrado entre corriente de colector y corriente de base, se denomina Beta del transistor. Los tres tipos de configuraciones básicas para utilización analógica de los transistores son emisor común, colector común y base común.
Modelos posteriores al transistor descrito, el transistor bipolar (transistores FET, MOSFET, JFET, CMOS, VMOS, etc.) no utilizan la corriente que se inyecta en el terminal de base para modular la corriente de emisor o colector, sino la tensión presente en el terminal de puerta o reja de control (graduador) y gradúa la conductancia del canal entre los terminales de Fuente y Drenaje. Cuando la conductancia es nula y el canal se encuentra estrangulado, por efecto de la tensión aplicada entre Compuerta y Fuente, es el campo eléctrico presente en el canal el responsable de impulsar los electrones desde la fuente al drenaje. De este modo, la corriente de salida en la carga conectada al Drenaje (D) será función amplificada de la Tensión presente entre la Compuerta (Gate) y Fuente (Source). Su funcionamiento es análogo al del triodo.
Los transistores de efecto de campo, son los que han permitido la integración a gran escala disponible hoy en día.

El transistor bipolar frente a la valvula termoionica

Las válvulas tienen características eléctricas similares a la de los transistores de efecto campo (FET): la corriente que los atraviesa depende de la tensión en el borne de comando, llamado rejilla. Las razones por las que el transistor reemplazó a la válvula termoiónica son varias:

Las válvulas necesitan tensiones muy altas, del orden de las centenas de voltios, que son letales para el ser humano.
Las válvulas consumen mucha energía, lo que las vuelve particularmente poco útiles para el uso con baterías.
Probablemente, uno de los problemas más importantes haya sido el peso. El chasis necesario para alojar las válvulas y los transformadores requeridos para su funcionamiento sumaban un peso importante, que iba desde algunos kilos a decenas de kilos.
El tiempo medio entre fallas de las válvulas termoiónicas es muy corto comparado con el de los transistores.
Las válvulas presentan una cierta demora en comenzar a funcionar, ya que necesitan estar calientes para establecer la conducción.
Los transistores son más pequeños que las válvulas, incluso que los nuvistores. Aunque existe unanimidad sobre este punto, conviene hacer una salvedad: en el caso de dispositivos de potencia, estos deben llevar un disipador, de modo que el tamaño que se ha de considerar es el del dispositivo (válvula o transistor) más el del disipador. Como las válvulas pueden funcionar a temperaturas más elevadas, la eficiencia del disipador es mayor en ellas que en los transistores.
Los transistores trabajan con impedancias bajas, o sea con tensiones reducidas y corrientes altas; mientras que las válvulas presentan impedancias elevadas y por lo tanto trabajan con altas tensiones y pequeñas corrientes.
Finalmente, el costo de los transistores no solamente era muy inferior, sino que contaba con la promesa de que continuaría bajando con suficiente investigación y desarrollo.

Como ejemplo de todos estos inconvenientes se puede citar a la primera computadora digital, llamada ENIAC. Era un equipo que pesaba más de treinta toneladas y consumía 200 kilovatios, suficientes para alimentar una pequeña ciudad. Tenía alrededor de 18.000 válvulas, de las cuales algunas se quemaban cada día, necesitando una logística y una organización importantes.
Cuando el transistor bipolar fue inventado en 1947, fue considerado una revolución. Pequeño, rápido, fiable, poco costoso, sobrio en sus necesidades de energía, reemplazó progresivamente a la válvula termoiónica durante la década de 1950, pero no del todo. En efecto, durante los años 1960, algunos fabricantes siguieron utilizando válvulas termoiónicas en equipos de radio de gama alta, como Collins y Drake; luego el transistor desplazó a la válvula de los transmisores pero no del todo de los amplificadores de radiofrecuencia. Otros fabricantes, de equipo de audio esta vez, como Fender, siguieron utilizando válvulas en amplificadores de audio para guitarras. Las razones de la supervivencia de las válvulas termoiónicas son varias:

El transistor no tiene las características de linealidad a alta potencia de la válvula termoiónica, por lo que no pudo reemplazarla en los amplificadores de transmisión de radio profesionales y de radioaficionados.
Los armónicos introducidos por la no-linealidad de las válvulas resultan agradables al oído humano, por lo que son preferidos por los audiófilos.
El transistor es muy sensible a los efectos electromagnéticos de las explosiones nucleares, por lo que se siguieron utilizando válvulas termoiónicas en algunos sistemas de control-comando de cazas de fabricación soviética.
Las válvulas son capaces de manejar potencias muy grandes, impensables en transistores. Por ejemplo, en un gran concierto la amplificación de audio hacia los altavoces.

Primer transistor

Valvula termoionica

Transisto bipolar

Transistor Mosfet

Circuito integrado

http://www.youtube.com/watch?v=4qdAQTfOlIw
http://www.youtube.com/watch?v=DjqqAXkLX30
http://www.youtube.com/watch?v=8ZXtFCTGV6c
http://www.youtube.com/watch?v=6Os5w9bIRmQ

http://www.youtube.com/watch?v=9MMaAgtnb6E

Una definición elemental de amplificación fue dada por William Shockley: "Si usted toma un fardo de heno y lo ata a la cola de una mula y a continuación le prende fuego, y compara luego la energía disipada a partir de entonces por la mula con la energía disipada antes por usted en frotar el fósforo, entenderá plenamente el concepto de amplificación"

Radio ¿que seria del hoy sin ella?

2011-09-03T18:30:00.000+02:00

Que ha sido de estas radios, que llaman la atencion de cualquier amante de la electronica analogica valvular.

Pues si, estamos en una epoca en la que no nos conformamos con nada, lo cual nos ha llevado a dejar atras una tecnica, que si no hubiese sido desarrollada por los grandes de la eletronica y electricidad, veremos si hoy alguien hubiera sido capaz. Pero bueno, mientras se tenga conocimiento de como fue y cuando, yo por lo menos me conformo, y por ello el hecho de esta nueva entrada, en la que haciendo reseñas a la radio valvular y alguno de sus emprendedores, dejare caer todo aquello que a todavia mucha gente no deja de llamar la atencion y conquistar a nuevos y viejos electronicos.

Algo de historia de la radio y su medio de difusion, las ondas

Descubrimiento de las ondas electromagneticas de radio

Heinrich Rudolf Herts, en 1888, fue el primero en validar experimentalmente la teoría de Maxwell, al idear como "crear" artificialmente ondas electromagnéticas y como detectarlas y a continuación llevando a la práctica emisiones y recepciones de estas ondas y analizando sus características físicas demostrando que las ondas creadas artificialmente tenían todas las propiedades de las ondas electromagnéticas "teóricas".

Hertz dio un paso de gigante al afirmar y probar que las ondas electromagnéticas se propagan a una velocidad similar a la velocidad de la luz y que tenían las mismas características físicas que las ondas de luz, como las de reflejarse en superficies metálicas, desviarse por prismas, estar polarizadas, etc., sentando así las bases para el envío de señales de radio.

Como homenaje a Hertz por este descubrimiento, las ondas electromagnéticas pasaron a denominarse ondas hertzianas.

Desarrollo de la radio

Es difícil atribuir la invención de la radio a una única persona. En 1895, en Italia, un joven de apenas 20 años, Guglielmo Marconi, recibía a través del diario la noticia de los efectos de las ondas electromagnéticas engendradas por un oscilador eléctrico inventado por Hertz. En 1896, Marconi obtuvo la primera patente del mundo sobre la radio, la patente británica 12039, pero países como Francia y Rusia rechazaron reconocer su patente por dicha invención, refiriéndose a las publicaciones de Popov, previas en el tiempo.

El 7 de mayo de 1895 el profesor e ingeniero ruso Aleksandr Stepánovich Popov había presentado un receptor capaz de detectar ondas electromagnéticas. Diez meses después, el 24 de marzo de 1896, ya con un sistema completo de recepción-emisión de mensajes telegráficos, transmitió el primer mensaje telegráfico entre dos edificios de la Universidad de San Petersburgo situados a una distancia de 250 m. El texto de este primer mensaje telegráfico fue: "HEINRICH HERTZ".

Nikola Tesla (que por un camino diferente al de Hertz había llegado también a producir y detectar ondas de radio buscando, más que transmitir señales, transmitir energía eléctrica a larga distancia sin necesidad de usar conductores metálicos) hizo su primera demostración pública de radiocomunicación en San Luis (Misuri, Estados Unidos), en 1893. Dirigiéndose al Franklin Institute de Filadelfia y a la National Electric Light Association describió y demostró en detalle los principios de la radiocomunicación. Sus aparatos contenían ya todos los elementos que fueron utilizados en los sistemas de radio hasta el desarrollo de los tubos de vacio. En Estados Unidos, algunos desarrollos clave en los comienzos de la historia de la radio fueron creados y patentados en 1897 por Tesla. Sin embargo, la Oficina de Patentes de Estados Unidos revocó su decisión en 1904 y adjudicó a Marconi una patente por la invención de la radio, posiblemente influenciada por los patrocinadores financieros de Marconi en Estados Unidos. Años después, en 1943, meses después de la muerte de Tesla, el Tribunal Supremo de los Estados Unidos dictaminó que la patente relativa a la radio era legítimamente propiedad de Tesla, reconociéndolo de forma legal como inventor de la radio. El 12 de diciembre de 1901, Marconi transmitió, por primera vez, señales de codigo morse por ondas electromagnéticas.

Radio años 20

Radio años 30

Radio años 40

Radio años 50

Con la llegada de los años 60 y la revolucion del transistor, al cual dedicare otro tema, la radio pasa ha hacerse portable debido al reducido tamaño y consumo de estos.

Mas adelante con la miniturizacion del transistor y el circuito integrado todo pasar a ser digital y de tamaño aun mas reducido.

Para el electronico

Dos grandes, enemigos