LITIUM

FFT ARM9 S3C2440

2012-01-06T08:22:00.001-08:00

http://www.youtube.com/watch?v=HemL3kkgkVk

#include "def.h"
#include "math.h"
#include "float.h"
#include "2440addr.h"
#include "2440lib.h"
#include "2440slib.h"
#include "lcd.h"
#include <stdlib.h>
#include <math.h>

/* function prototypes FFT */
void fft(int N, double (*x)[2], double (*X)[2]);
void fft_rec(int N, int offset, int delta, double (*x)[2], double (*X)[2], double (*XX)[2]);
void ifft(int N, double (*x)[2], double (*X)[2]);
void FTT_PAINT (int nn);
void init_FFT (void);

#define TWO_PI (6.2831853071795864769252867665590057683943L)
#define NN 256
int N = NN ; /* number of points in FFT */
double (*x)[2]; /* pointer to time-domain samples */
double (*X)[2]; /* pointer to frequency-domain samples */
double dummy; /* scratch variable */
int iFFT = 0; /* generic index */
U32 X_antigou[256][2];

#define RGB(g,r,b) (unsigned int)( (r << 16) + (g << 8) + b )

void init_FFT (void)
{
x = malloc(2 * N * sizeof(double));
X = malloc(2 * N * sizeof(double));

Lcd_printf( 15 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"0" );
Lcd_printf( 80 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"1K" );
Lcd_printf( 148 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"2K" );
Lcd_printf( 216 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"3K" );
Lcd_printf( 284 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"4K" );
Lcd_printf( 352 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"5K" );
Lcd_printf( 420 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"6K" );
Lcd_printf( 488 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"7K" );
Lcd_printf( 556 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"8K" );
Lcd_printf( 624 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"9K" );
Lcd_printf( 692 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"10K" );
Lcd_printf( 760 , 30 ,RGB( 0xff,0xff,0xff),RGB( 0x00,0x00,0x00),0,"11K" );
}

void FTT_PAINT (int nn)
{
int m;
int mmm;
U32 X1;

fft(nn, x, X);
mmm=0;

for (m = 1; m <= (nn/2)-1 ; m++ )
{ X1 = sqrt( pow(X[m][0],2) + pow(X[m][1],2) );

if((X1) >= 415 )
{X1 = 415;}

mmm = mmm+6;
Glib_Line( 10+mmm , 476 , 10+mmm , 476-X_antigou[m][0] ,RGB(0X00,0X00,0X00));
Glib_Line( 10+mmm , 476 , 10+mmm , 476-X1 ,RGB(0XFA,0X4F,0X02));
Glib_Line( 10+mmm+1 , 476 , 10+mmm+1 , 476-X_antigou[m][0] ,RGB(0X00,0X00,0X00));
Glib_Line( 10+mmm+1 , 476 , 10+mmm+1 , 476-X1 ,RGB(0XFA,0X4F,0X02));
Glib_Line( 10+mmm+2 , 476 , 10+mmm+2 , 476-X_antigou[m][0] ,RGB(0X00,0X00,0X00));
Glib_Line( 10+mmm+2 , 476 , 10+mmm+2 , 476-X1 ,RGB(0XFA,0X4F,0X02));
Glib_Line( 10+mmm+3 , 476 , 10+mmm+3 , 476-X_antigou[m][0] ,RGB(0X00,0X00,0X00));
Glib_Line( 10+mmm+3 , 476 , 10+mmm+3 , 476-X1 ,RGB(0XFA,0X4F,0X02));
Glib_Line( 10+mmm+4 , 476 , 10+mmm+4 , 476-X_antigou[m][0] ,RGB(0X00,0X00,0X00));
Glib_Line( 10+mmm+4 , 476 , 10+mmm+4 , 476-X1 ,RGB(0XFA,0X4F,0X02));
Glib_Line( 10+mmm+5 , 476 , 10+mmm+5 , 476-X_antigou[m][0] ,RGB(0X00,0X00,0X00));

X_antigou[m][1] = X1;
}
for (m = 1; m <= (nn/2)-1 ; m++ )
{ X_antigou[m][0] = X_antigou[m][1]; }
}

/*----------------------------------------------------------------------------
fft.c - fast Fourier transform and its inverse (both recursively)
Copyright (C) 2004, Jerome R. Breitenbach. All rights reserved.

The author gives permission to anyone to freely copy, distribute, and use
this file, under the following conditions:
- No changes are made.
- No direct commercial advantage is obtained.
- No liability is attributed to the author for any damages incurred.
----------------------------------------------------------------------------*/

/* FFT */
void fft(int N, double (*x)[2], double (*X)[2])
{
double (*XX)[2] = malloc(2 * N * sizeof(double));
fft_rec(N, 0, 1 , x, X, XX);
free(XX);
}

/* FFT recursion */
void fft_rec(int N, int offset, int delta, double (*x)[2], double (*X)[2], double (*XX)[2])
{
int N2 = N/2; /* half the number of points in FFT */
int k; /* generic index */
double cs, sn; /* cosine and sine */
int k00, k01, k10, k11; /* indices for butterflies */
double tmp0, tmp1; /* temporary storage */

if(N != 2) /* Perform recursive step. */
{

fft_rec(N2, offset, 2*delta, x, XX, X);
fft_rec(N2, offset+delta, 2*delta, x, XX, X);

for(k=0; k<N2; k++)
{
k00 = offset + k*delta; k01 = k00 + N2*delta;
k10 = offset + 2*k*delta; k11 = k10 + delta;
cs = cos(TWO_PI*k/(double)N); sn = sin(TWO_PI*k/(double)N);
tmp0 = cs * XX[k11][0] + sn * XX[k11][1];
tmp1 = cs * XX[k11][1] - sn * XX[k11][0];
X[k01][0] = XX[k10][0] - tmp0;
X[k01][1] = XX[k10][1] - tmp1;
X[k00][0] = XX[k10][0] + tmp0;
X[k00][1] = XX[k10][1] + tmp1;
}
}
else
{
k00 = offset; k01 = k00 + delta;
X[k01][0] = x[k00][0] - x[k01][0];
X[k01][1] = x[k00][1] - x[k01][1];
X[k00][0] = x[k00][0] + x[k01][0];
X[k00][1] = x[k00][1] + x[k01][1];
}
}

/* IFFT */
void ifft(int N, double (*x)[2], double (*X)[2])
{
int N2 = N/2; /* half the number of points in IFFT */
int i; /* generic index */
double tmp0, tmp1; /* temporary storage */

/* Calculate IFFT via reciprocity property of DFT. */
fft(N, X, x);
x[0][0] = x[0][0]/N; x[0][1] = x[0][1]/N;
x[N2][0] = x[N2][0]/N; x[N2][1] = x[N2][1]/N;
for(i=1; i<N2; i++)
{
tmp0 = x[i][0]/N; tmp1 = x[i][1]/N;
x[i][0] = x[N-i][0]/N; x[i][1] = x[N-i][1]/N;
x[N-i][0] = tmp0; x[N-i][1] = tmp1;
}
}

MORSE c++

2011-12-06T09:41:00.000-08:00

#include

// PROTO
void MorseTX(char *letra,uint32_t Velo);
void Morse_Encoder (char *morse, uint32_t Velo );
//

char Buffer_Tx [] = "VVV LU7FJ LU7FJ FF99QE TST";

*/ EJEMPLO
Morse_Encoder (Buffer_Tx,30);
*/

char A[] = {'.','-',0};
char B[] = {'-','.','.','.',0};
char C[] = {'-','.','-','.',0};
char D[] = {'-','.','.',0};
char E[] = {'.',0};
char F[] = {'.','.','-','.',0};
char G[] = {'-','.','.',0};
char H[] = {'.','.','.','.',0};
char I[] = {'.','.',0};
char J[] = {'.','-','-','-',0};
char K[] = {'-','.','-',0};
char L[] = {'.','-','.','.',0};
char M[] = {'-','-',0};
char N[] = {'-','.',0};
char O[] = {'-','-','-',0};
char P[] = {'.','-','-','.',0};
char Q[] = {'-','-','.','-',0};
char R[] = {'.','-','.',0};
char S[] = {'.','.','.',0};
char T[] = {'-',0};
char U[] = {'.','.','-',0};
char V[] = {'.','.','.','-',0};
char W[] = {'.','-','-',0};
char X[] = {'-','.','.','-',0};
char Y[] = {'-','.','-','-',0};
char Z[] = {'-','-','.','.',0};
char SPACE[] = {' ',0};

char n1 []= {'.','-','-','-','-',0};
char n2 []= {'.','.','-','-','-',0};
char n3 []= {'.','.','.','-','-',0};
char n4 []= {'.','.','.','.','-',0};
char n5 []= {'.','.','.','.','.',0};
char n6 []= {'-','.','.','.','.',0};
char n7 []= {'-','-','.','.','.',0};
char n8 []= {'-','-','-','.','.',0};
char n9 []= {'-','-','-','-','.',0};
char n0 []= {'-','-','-','-','-',0};

void MorseTX( char *letra, uint32_t Velo )
{
    uint32_t vel ;
    uint32_t RV = 50 - Velo;

    do
     {
     char x = (*letra);
    switch(x)
    {
    case '.':
      PORTC |= (1<<PORTC4);
    for (vel = 0; vel < RV; vel++){_delay_ms(2);}
    PORTC &= ~(1<<PORTC4);
    for (vel = 0; vel < RV; vel++){_delay_ms(2);}
    break;

    case '-':
      PORTC |= (1<<PORTC4);
    for (vel = 0; vel < RV; vel++){_delay_ms(6);}
    PORTC &= ~(1<<PORTC4);
    for (vel = 0; vel < RV; vel++){_delay_ms(2);}
    break;

    case ' ':
    PORTC &= ~(1<<PORTC4);
    for (vel = 0; vel < RV; vel++){_delay_ms(8);}
    break;
        }

     } while(*++letra) ;
    for (vel = 0; vel < RV; vel++){_delay_ms(4);}
}

void Morse_Encoder (char *morse, uint32_t vpm )
{

do
{
char x = (*morse);
switch(x)
{
case 'A':
MorseTX(A,vpm);
break;
case 'B':
MorseTX(B,vpm);
break;
case 'C':
MorseTX(C,vpm);
break;
case 'D':
MorseTX(D,vpm);
break;
case 'E':
MorseTX(E,vpm);
break;
case 'F':
MorseTX(F,vpm);
break;
case 'G':
MorseTX(G,vpm);
break;
case 'H':
MorseTX(H,vpm);
break;
case 'I':
MorseTX(I,vpm);
break;
case 'J':
MorseTX(J,vpm);
break;
case 'K':
MorseTX(K,vpm);
break;
case 'L':
MorseTX(L,vpm);
break;
case 'M':
MorseTX(M,vpm);
break;
case 'N':
MorseTX(N,vpm);
break;
case 'O':
MorseTX(O,vpm);
break;
case 'P':
MorseTX(P,vpm);
break;
case 'Q':
MorseTX(Q,vpm);
break;
case 'R':
MorseTX(R,vpm);
break;
case 'S':
MorseTX(S,vpm);
break;
case 'T':
MorseTX(T,vpm);
break;
case 'U':
MorseTX(U,vpm);
break;
case 'V':
MorseTX(V,vpm);
break;
case 'W':
MorseTX(W,vpm);
break;
case 'X':
MorseTX(X,vpm);
break;
case 'Y':
MorseTX(Y,vpm);
break;
case 'Z':
MorseTX(Z,vpm);
break;
case ' ':
MorseTX(SPACE,vpm);
break;
case '0':
MorseTX(n0,vpm);
break;
case '1':
MorseTX(n1,vpm);
break;
case '2':
MorseTX(n2,vpm);
break;
case '3':
MorseTX(n3,vpm);
break;
case '4':
MorseTX(n4,vpm);
break;
case '5':
MorseTX(n5,vpm);
break;
case '6':
MorseTX(n6,vpm);
break;
case '7':
MorseTX(n7,vpm);
break;
case '8':
MorseTX(n8,vpm);
break;
case '9':
MorseTX(n9,vpm);
break;
}

} while (*++morse);

}

RMC - NMEA has its own version of essential gps pvt (position, velocity, time)

2011-06-28T12:02:00.000-07:00

RMC - NMEA has its own version of essential gps pvt (position, velocity, time) data. It is called RMC, The Recommended Minimum, which will look similar to:

$GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A

Where:
     RMC          Recommended Minimum sentence C
     123519       Fix taken at 12:35:19 UTC
     A            Status A=active or V=Void.
     4807.038,N   Latitude 48 deg 07.038' N
     01131.000,E  Longitude 11 deg 31.000' E
     022.4        Speed over the ground in knots
     084.4        Track angle in degrees True
     230394       Date - 23rd of March 1994
     003.1,W      Magnetic Variation
     *6A          The checksum data, always begins with *

Note that, as of the 2.3 release of NMEA, there is a new field in the RMC sentence at the end just prior to the checksum. For more information on this field see here.

real :

$GPRMC,184203.999,V,2340.2965,S,04632.7430,W,000.0,000.0,280611,,,N*7E

union G_RMC
{
struct {
char RMC [6];
char UTC[10]; // Fix taken at UTC 184203.999
char Status[1]; // Status A=active or V=Void.
char Latitude[9]; // Latitude 2340.2965
char N_S[1]; // N / S
char Longitude[11]; // Longitude 04632.7430 E - W
char W_E[1]; // W / E
char Speed_k [5]; // Speed over the ground in knots
char Track_angle[5]; // Track angle in degrees True
char DATE [6]; // 280611 Date - 26rd of 06 2011
char Magnetic_V[5]; // Magnetic Variation
char Magnetic_W[1]; // "W" si hay datos
char Magnetic_N[1]; /* N novalid data ,
A modo outonomo ,
D diferencial ,
E estimado deat zone ,
M entrada manual
S modo simulado */
char checksum[2]; // checksum 7E
};
struct
{
char GPS_GPRMCN[];
};
};
union G_RMC GPS_RMC;

VTG - Velocity made good.

2011-06-28T12:00:00.000-07:00

VTG - Velocity made good. The gps receiver may use the LC prefix instead of GP if it is emulating Loran output.

$GPVTG,054.7,T,034.4,M,005.5,N,010.2,K*48

where:
        VTG          Track made good and ground speed
        054.7,T      True track made good (degrees)
        034.4,M      Magnetic track made good
        005.5,N      Ground speed, knots
        010.2,K      Ground speed, Kilometers per hour
        *48          Checksum

Note that, as of the 2.3 release of NMEA, there is a new field in the VTG sentence at the end just prior to the checksum. For more information on this field see here.

GSV - Satellites in View

2011-06-28T11:58:00.001-07:00

GSV - Satellites in View shows data about the satellites that the unit might be able to find based on its viewing mask and almanac data. It also shows current ability to track this data. Note that one GSV sentence only can provide data for up to 4 satellites and thus there may need to be 3 sentences for the full information. It is reasonable for the GSV sentence to contain more satellites than GGA might indicate since GSV may include satellites that are not used as part of the solution. It is not a requirment that the GSV sentences all appear in sequence. To avoid overloading the data bandwidth some receivers may place the various sentences in totally different samples since each sentence identifies which one it is.
The field called SNR (Signal to Noise Ratio) in the NMEA standard is often referred to as signal strength. SNR is an indirect but more useful value that raw signal strength. It can range from 0 to 99 and has units of dB according to the NMEA standard, but the various manufacturers send different ranges of numbers with different starting numbers so the values themselves cannot necessarily be used to evaluate different units. The range of working values in a given gps will usually show a difference of about 25 to 35 between the lowest and highest values, however 0 is a special case and may be shown on satellites that are in view but not being tracked.

$GPGSV,2,1,08,01,40,083,46,02,17,308,41,12,07,344,39,14,22,228,45*75

Where:
      GSV          Satellites in view
      2            Number of sentences for full data
      1            sentence 1 of 2
      08           Number of satellites in view

      01           Satellite PRN number
      40           Elevation, degrees
      083          Azimuth, degrees
      46           SNR - higher is better
           for up to 4 satellites per sentence
      *75          the checksum data, always begins with *

GSA - GPS DOP and active satellites

2011-06-28T11:57:00.002-07:00

GSA - GPS DOP and active satellites. This sentence provides details on the nature of the fix. It includes the numbers of the satellites being used in the current solution and the DOP. DOP (dilution of precision) is an indication of the effect of satellite geometry on the accuracy of the fix. It is a unitless number where smaller is better. For 3D fixes using 4 satellites a 1.0 would be considered to be a perfect number, however for overdetermined solutions it is possible to see numbers below 1.0.
There are differences in the way the PRN's are presented which can effect the ability of some programs to display this data. For example, in the example shown below there are 5 satellites in the solution and the null fields are scattered indicating that the almanac would show satellites in the null positions that are not being used as part of this solution. Other receivers might output all of the satellites used at the beginning of the sentence with the null field all stacked up at the end. This difference accounts for some satellite display programs not always being able to display the satellites being tracked. Some units may show all satellites that have ephemeris data without regard to their use as part of the solution but this is non-standard.

$GPGSA,A,3,04,05,,09,12,,,24,,,,,2.5,1.3,2.1*39

Where:
     GSA      Satellite status
     A        Auto selection of 2D or 3D fix (M = manual) 
     3        3D fix - values include: 1 = no fix
                                       2 = 2D fix
                                       3 = 3D fix
     04,05... PRNs of satellites used for fix (space for 12) 
     2.5      PDOP (dilution of precision) 
     1.3      Horizontal dilution of precision (HDOP) 
     2.1      Vertical dilution of precision (VDOP)
     *39      the checksum data, always begins with *

GGA - essential fix data which provide 3D location and accuracy data.

2011-06-28T11:57:00.000-07:00

The most important NMEA sentences include the GGA which provides the current Fix data, the RMC which provides the minimum gps sentences information, and the GSA which provides the Satellite status data.
GGA - essential fix data which provide 3D location and accuracy data.

$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47

Where:
     GGA          Global Positioning System Fix Data
     123519       Fix taken at 12:35:19 UTC
     4807.038,N   Latitude 48 deg 07.038' N
     01131.000,E  Longitude 11 deg 31.000' E
     1            Fix quality: 0 = invalid
                               1 = GPS fix (SPS)
                               2 = DGPS fix
                               3 = PPS fix
          4 = Real Time Kinematic
          5 = Float RTK
                               6 = estimated (dead reckoning) (2.3 feature)
          7 = Manual input mode
          8 = Simulation mode
     08           Number of satellites being tracked
     0.9          Horizontal dilution of position
     545.4,M      Altitude, Meters, above mean sea level
     46.9,M       Height of geoid (mean sea level) above WGS84
                      ellipsoid
     (empty field) time in seconds since last DGPS update
     (empty field) DGPS station ID number
     *47          the checksum data, always begins with *

If the height of geoid is missing then the altitude should be suspect. Some non-standard implementations report altitude with respect to the ellipsoid rather than geoid altitude. Some units do not report negative altitudes at all. This is the only sentence that reports altitude.

AVR

2011-06-27T10:37:00.001-07:00

Los AVR son una familia de microcontroladores RISC de Atmel. La arquitectura de los AVR fue concebida por dos estudiantes en el Norwegian Institute of Technology, y posteriormente refinada y desarrollada en Atmel Norway, la empresa subsidiaria de Atmel, fundada por los dos arquitectos del chip.

El AVR es una CPU de arquitectura Harvard. Tiene 32 registros de 8 bits. Algunas instrucciones sólo operan en un subconjunto de estos registros. La concatenación de los 32 registros, los registros de entrada/salida y la memoria de datos conforman un espacio de direcciones unificado, al cual se accede a través de operaciones de carga/almacenamiento. A diferencia de los microcontroladores PIC, el stack se ubica en este espacio de memoria unificado, y no está limitado a un tamaño fijo.

El AVR fue diseñado desde un comienzo para la ejecución eficiente de código C compilado. Como este lenguaje utiliza profusamente punteros para el manejo de variables en memoria, los tres últimos pares de registros internos del procesador, son usados como punteros de 16 bit al espacio de memoria externa, bajo los nombres X, Y y Z. Esto es un compromiso que se hace en arquitecturas de ocho bit desde los tiempos de Intel 8008, ya que su tamaño de palabra nativo de 8 bit (256 localidades accedidas) es pobre para direccionar. Por otro lado, hacer que todo el banco superior de 16 registros de 8 bit tenga un comportamiento alterno como un banco de 8 registros de 16 bit, complicaría mucho el diseño, violando la premisa original de su simplicidad. Además, algunas instrucciones tales como add immediate en inglés , faltan, ya que la instrucción substract immediate , en inglés con el complemento dos puede ser usada como alternativa.

El set de instrucciones AVR está implementado físicamente y disponible en el mercado en diferentes dispositivos, que comparten el mismo núcleo AVR pero tienen distintos periféricos y cantidades de RAM y ROM: desde el microcontrolador de la familia Tiny AVR ATtiny11 con 1KB de memoria flash y sin RAM (sólo los 32 registros), y 8 pines, hasta el microcontrolador de la famila Mega AVRATmega2560 con 256KB de memoria flash, 8KB de memoria RAM, 4KB de memoria EEPROM, conversor análogo digital de 10 bits y 16 canales, temporizadores, comparador analógico, JTAG, etc. La compatibilidad entre los distintos modelos es preservada en un grado razonable.

Los microcontroladores AVR tienen una cañería ('pipeline' en inglés) con dos etapas (cargar y ejecutar), que les permite ejecutar la mayoría en un ciclo de reloj, lo que los hace relativamente rápidos entre los microcontroladores de 8-bit.

El set de instrucciones de los AVR es más regular que la de la mayoría de los microcontroladores de 8-bit (por ejemplo, los PIC). Sin embargo, no es completamente ortogonal:

Los registros punteros X, Y y Z tienen capacidades de direccionamiento diferentes entre sí (ver mas arriba por qué)
Los registros 0 al 15 tienen diferentes capacidades de direccionamiento que los registros 16 al 31.
Las registros de I/O 0 al 31 tienen distintas características que las posiciones 32 al 63.
La instrucción CLR afecta los 'flag', mientras que la instrucción SER no lo hace, a pesar de que parecen ser instrucciones complementarias (dejar todos los bits en 1, y dejar todos los bits en 0 respectivamente).
Los códigos de operación 0x95C8 y 0x9004 hacen exactamente lo mismo (LPM).

Como los PIC, tiene una comunidad de seguidores (ejemplificadas por el foro de internet AVRFreaks), principalmente debido a la existencia de herramientas de desarrollo gratuitas o de bajo coste. Estos microcontroladores están soportados por tarjetas de desarrollo de costo razonable, capaces de descargar el código al microcontrolador, y por una versión de las herramientas GNU. Esto último es posible por su uniformidad en el acceso al espacio de memoria, propiedad de la que carecen los procesadores de memoria segmentada o por bancos, como el PIC o el 8051 y sus derivados.

ARM

2011-06-27T10:36:00.003-07:00

El diseño del ARM comenzó en 1983 como un proyecto de desarrollo en la empresa Acorn Computers Ltd. Roger Wilson y Steve Furber lideraban el equipo, cuya meta era, originalmente, el desarrollo de un procesador avanzado, pero con una arquitectura similar a la del MOS 6502. La razón era que Acorn tenía una larga línea de ordenadores personales basados en dicho micro, por lo que tenía sentido desarrollar uno con el que los desarrolladores se sintieran cómodos.

El equipo terminó el diseño preliminar y los primeros prototipos del procesador en el año 1985, al que llamaron ARM1. La primera versión utilizada comercialmente se bautizó como ARM2 y se lanzó en el año 1986.

La arquitectura del ARM2 posee un bus de datos de 32 bits y ofrece un espacio de direcciones de 26 bits, junto con 16 registros de 32 bits. Uno de estos registros se utiliza como contador de programa, aprovechándose sus 4 bits superiores y los 2 inferiores para contener los flags de estado del procesador.

El ARM2 es probablemente el procesador de 32 bits útil más simple del mundo, ya que posee sólo 30.000 transistores. Su simplicidad se debe a que no está basado en microcódigo (sistema que suele ocupar en torno a la cuarta parte de la cantidad total de transistores usados en un procesador) y a que, como era común en aquella época, no incluye caché. Gracias a esto, su consumo en energía es bastante bajo, a la vez que ofrece un mejor rendimiento que un 286. Su sucesor, el ARM3, incluye una pequeña memoria caché de 4 KB, lo que mejora los accesos a memoria repetitivos.

A finales de los años 80, Apple Computer comenzó a trabajar con Acorn en nuevas versiones del núcleo ARM. En Acorn se dieron cuenta de que el hecho de que el fabricante de un procesador fuese también un fabricante de ordenadores podría echar para atrás a los clientes, por lo que se decidió crear una nueva compañía llamada Advanced RISC Machines, que sería la encargada del diseño y gestión de las nuevas generaciones de procesadores ARM. Ocurría esto en el año 1990.

Este trabajo derivó en el ARM6, presentado en 1991. Apple utilizó el ARM 610 (basado en el ARM6), como procesador básico para su innovador PDA, el Apple Newton. Por su parte, Acorn lo utilizó en 1994 como procesador principal en su RiscPC.

El núcleo mantuvo su simplicidad a pesar de los cambios: en efecto, el ARM2 tiene 30.000 transistores, mientras que el ARM6 sólo cuenta con 35.000. La idea era que el usuario final combinara el núcleo del ARM con un número opcional de periféricos integrados y otros elementos, pudiendo crear un procesador completo a la medida de sus necesidades.

La mayor utilización de la tecnología ARM se alcanzó con el procesador ARM7TDMI, con millones de unidades en teléfonos móviles y sistemas de videojuegos portátiles.

DEC licenció el diseño, lo cual generó algo de confusión debido a que ya producía el DEC Alpha, y creó el StrongARM. Con una velocidad de reloj de 233 MHz, este procesador consumía solo 1 W de potencia (este consumo de energía se ha reducido en versiones más recientes). Esta tecnología pasó posteriormente a manos de Intel, como fruto de un acuerdo jurídico, que la integró en su línea de procesadores Intel i960 e hizo más ardua la competencia.

Freescale (una empresa que derivó de Motorola en el año 2004), IBM, Infineon Technologies, OKI, Texas Instruments, Nintendo, Philips, VLSI, Atmel, Sharp, Samsung ySTMicroelectronics también licenciaron el diseño básico del ARM.

El diseño del ARM se ha convertido en uno de los más usados del mundo, desde discos duros hasta juguetes. Hoy en día, cerca del 75% de los procesadores de 32 bits poseen este chip en su núcleo.

8051

2011-06-27T10:35:00.001-07:00

El Intel 8051 es un microcontrolador (µC) desarrollado por Intel en 1980 para uso en productos embebidos. Es un microcontrolador muy popular.

Los núcleos 8051 se usan en más de 100 microcontroladores de más de 20 fabricantes independientes como Atmel, Dallas Semiconductor, Philips, Winbond, entre otros.

La denominación oficial de Intel para familia de µCs 8051 es MCS 51.

Éste microcontrolador está basado en una Arquitectura Harvard (es decir, existen espacios de direcciones separados para código y datos). Aunque originariamente fue diseñado para aplicaciones simples, se permite direccionar 64 KB de ROM externa y 64 KB de RAMpor medio de líneas separadas chip select para programa y datos.

Adicionalmente, el microcontrolador contiene una memoria interna, dividida en dos partes: los SFR y memoria de propósito general. Los SFR (Special Function Registers), son los registros proporcionados por el microcontrolador, y tienen asignadas direcciones en esta memoria interna. El acceso a esta memoria interna es más rápido que el acceso a la memoria externa, pero es de tamaño limitado. Parte de esta memoria interna además se usa como pila durante las llamadas a función y el proceso de interrupciones.

Una característica particular del 8051 es la inclusión de una unidad de proceso booleano que permite que operaciones de nivel de bit lógica booleana se ejecuten directa y eficientemente en registros internos. Esto ha hecho que el 8051 sea muy popular en aplicaciones de control industrial.

Otra característica muy valorada es que tiene cuatro conjuntos separados de registros. A menudo se usa esta característica para reducir la latencia de interrupción. (La rutina que maneja la interrupción declara usar otro conjunto de registros, evitándose de esta manera tener que salvar en la pila los registros originales).

La mayoría de los 8051 incluyen una o dos UARTs, dos o tres temporizadores, 128 o 256 bytes de RAM interna (16 bytes de los cuales son direccionables a nivel de bit), cuatro o cinco registros de entrada/salida y entre 0k-54K de memoria interna de programa. El núcleo 8051 original ejecuta un ciclo máquina cada 12 ciclos de reloj, requiriendo la mayoría de instrucciones uno o dos ciclos máquina. Pero actualmente la mayoría de fabricantes ofrecen versiones mejoradas que sólo requieren de 2 a 4 ciclos de reloj por cada instrucción máquina.

Los microcontroladores 8051 modernos ofrecen muchas mejoras sobre el original. Mejoras comunes incluyen watchdog timers (un temporizador programable que "resetea" el microcontrolador si no se refresca en cierto tiempo), osciladores internos, memoria de programa Flash ROM interna, código de inicialización en ROM, almacenamiento en EEPROM interna, I²C, SPI, USB, generadores PWM, conversores analógicos A/D y D/A, relojes de tiempo real RTC, temporizadores y contadores extra, facilidades de depuración internas, más fuentes de interrupción, modos de bajo consumo, interfaz CAN, etc.

Existen varios compiladores de lenguaje C disponibles para el 8051, así como en lenguaje ensamblador . La mayoría añaden extensiones al lenguaje que permiten al programador especificar por ejemplo el tipo de memoria donde se ubicará la variable, especificar manejadores de interrupción, especificar el banco de registros, acceder a instrucciones especiales de manipulación de bits...

El predecesor del 8051, el 8048, se usó en el teclado del primer IBM PC, donde convertía pulsaciones de tecla en un stream serie que se envía a la unidad central del ordenador. El 8048 y sus derivados aun se usan actualmente en teclados básicos.

El 8031 fue una versión reducida del Intel 8051 original que no contiene memoria interna.

El 8052 fue una versión mejorada del Intel 8051 original con:

256 bytes de RAM interna, en vez de 128 bytes
8 kB de ROM, en vez de 4 kB
un tercer temporizador de 16-bit
un segundo puerto serie.

Además de todas las facilidades de Timers que poseen estro controladores, estos cuentan con diferentes sistemas de comunicación serial y paralela.

[Procesadores Intel 8031]

El predecesor del 8051 fue el 8048. Se usaba en el teclado del primer IBM PC, su función era convertir las pulsaciones de tecla en datos en serie que eran enviados a la unidad central de la computadora. El 8048 y sus derivados todavía se siguen usando para teclados básicos. El 8031 era una versión reducida del origial Intel 8031 que no incluía ninguna memoria interna de programa (ROM). Para usar este chip, hacía falta usar una memoria exterior que el 8031 usaría. Un chip 8051 se podría vender como un 8031 sin ROM, dado que la ROM del 8051 está desactivada por el estado normal del pin EA en el diseño basado en el 8031.

C# -> C SHARP

2011-06-27T10:32:00.000-07:00

C♯ o C# (pronunciado ci sharp en inglés) es un lenguaje de programación orientado a objetos desarrollado y estandarizado porMicrosoft como parte de su plataforma .NET, que después fue aprobado como un estándar por la ECMA e ISO.

Su sintaxis básica deriva de C/C++ y utiliza el modelo de objetos de la plataforma.NET, similar al de Java aunque incluye mejoras derivadas de otros lenguajes (entre ellos Delphi).

El nombre C Sharp fue inspirado por la notación musical, donde ♯ (sostenido, en inglés sharp) indica que la nota (C es la nota do en inglés) es un semitono más alta, sugiriendo que C♯ es superior a C/C++. Además el signo de # viene de dos + pegados.¹

C♯, como parte de la plataforma.NET, está normalizado por ECMA desde diciembre de 2001 (C# Language Specification"Especificación del lenguaje C♯"). El 7 de noviembre de 2005 salió la versión 2.0 del lenguaje, que incluía mejoras tales como tipos genéricos, métodos anónimos, iteradores, tipos parciales y tipos anulables. El 19 de noviembre de 2007 salió la versión 3.0 de C#, destacando entre las mejoras los tipos implícitos, tipos anónimos y LINQ (Language Integrated Query -consulta integrada en el lenguaje).

Aunque C♯ forma parte de la plataforma.NET, ésta es una interfaz de programación de aplicaciones (API), mientras que C♯ es un lenguaje de programación independiente diseñado para generar programas sobre dicha plataforma. Ya existe un compiladorimplementado que provee el marco de DotGNU - Mono que genera programas para distintas plataformas como Win32, UNIX y Linux

C++

2011-06-27T10:31:00.000-07:00

C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que permitan la manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.

Posteriormente se añadieron facilidades de programación genérica, que se sumó a los otros dos paradigmas que ya estaban admitidos (programación estructurada y la programación orientada a objetos). Por esto se suele decir que el C++ es un lenguaje de programación multiparadigma.

Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los fabricantes de compiladores más modernos. Existen también algunos intérpretes, tales como ROOT.

Una particularidad del C++ es la posibilidad de redefinir los operadores (sobrecarga de operadores), y de poder crear nuevos tipos que se comporten como tipos fundamentales.

El nombre C++ fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C.

ASSEMBLY LENGUAGE

2011-06-27T10:26:00.000-07:00

El lenguaje ensamblador, o assembler (assembly language en inglés ) es un lenguaje de programación debajo nivel para los computadores, microprocesadores, microcontroladores, y otros circuitos integradosprogramables. Implementa una representación simbólica de los códigos de máquina binarios y otras constantes necesarias para programar una arquitectura dada de CPU y constituye la representación más directa del código máquina específico para cada arquitectura legible por un programador. Esta representación es usualmente definida por el fabricante de hardware, y está basada en los mnemónicos que simbolizan los pasos de procesamiento (las instrucciones), los registros del procesador, las posiciones de memoria, y otras características del lenguaje. Un lenguaje ensamblador es por lo tanto específico a cierta arquitectura de computador física (o virtual). Esto está en contraste con la mayoría de los lenguajes de programación de alto nivel, que, idealmente son portables.

Un programa utilitario llamado ensamblador es usado para traducir sentencias del lenguaje ensamblador al código de máquina del computador objetivo. El ensamblador realiza una traducción más o menos isomorfa (un mapeo de uno a uno) desde las sentencias mnemónicas a las instrucciones y datos de máquina. Esto está en contraste con los lenguajes de alto nivel, en los cuales una sola declaración generalmente da lugar a muchas instrucciones de máquina.

Muchos sofisticados ensambladores ofrecen mecanismos adicionales para facilitar el desarrollo del programa, controlar el proceso de ensamblaje, y la ayuda de depuración. Particularmente, la mayoría de los ensambladores modernos incluyen una facilidad de macro (descrita más abajo), y son llamados macro ensambladores.

Fue usado principalmente en los inicios del desarrollo de software, cuando aún no se contaba con potentes lenguajes de alto nivel y los recursos eran limitados. Actualmente se utiliza con frecuencia en ambientes académicos y de investigación, especialmente cuando se requiere la manipulación directa de hardware, altos rendimientos, o un uso de recursos controlado y reducido.

El código escrito en lenguaje ensamblador posee una cierta dificultad de ser entendido ya que su estructura se acerca al lenguaje máquina, es decir, es un lenguaje de bajo nivel.

El lenguaje ensamblador es difícilmente portable, es decir, un código escrito para un microprocesador, puede necesitar ser modificado, para poder ser usado en otra máquina distinta. Al cambiar a una máquina con arquitectura diferente, generalmente es necesario reescribirlo completamente.

Los programas hechos por un programador experto en lenguaje ensamblador son generalmente mucho más rápidos y consumen menos recursos del sistema (memoria RAM y ROM) que el programa equivalente compilado desde un lenguaje de alto nivel. Al programar cuidadosamente en lenguaje ensamblador se pueden crear programas que se ejecutan más rápidamente y ocupan menos espacio que con lenguajes de alto nivel.

Con el lenguaje ensamblador se tiene un control muy preciso de las tareas realizadas por un microprocesador por lo que se pueden crear segmentos de código difíciles y/o muy ineficientes de programar en un lenguaje de alto nivel, ya que, entre otras cosas, en el lenguaje ensamblador se dispone de instrucciones del CPU que generalmente no están disponibles en los lenguajes de alto nivel.

También se puede controlar el tiempo en que tarda una rutina en ejecutarse, e impedir que se interrumpa durante su ejecución