PDF de programación - Capitulo 3 y 4. Programar lo pequeño y lo grande

Imágen de pdf Capitulo 3 y 4. Programar lo pequeño y lo grande

Capitulo 3 y 4. Programar lo pequeño y lo grandegráfica de visualizaciones

Publicado el 14 de Enero del 2017
796 visualizaciones desde el 14 de Enero del 2017
225,1 KB
20 paginas
Creado hace 12a (29/11/2007)
CAPÍTULO 3 y 4. PROGRAMACIÓN PARA TIEMPO REAL

3

3.1.3

3.1.4

3.1
3.1

3.1.1
3.1.2

Programación para tiempo real................................................................................. 2
Lenguajes para tiempo real............................................................................... 2
Estilo general, tipos de datos, estructuras de control y subprogramas. ............ 2
Estilo general. ........................................................................................... 2
Tipos de datos........................................................................................... 3
3.1.2.1 Tipos discretos...................................................................................... 3
3.1.2.2 Números reales. .................................................................................... 3
3.1.2.3 Tipos de datos estructurados. ............................................................... 4
3.1.2.4 Tipos de datos dinámicos y apuntadores. ............................................. 4
3.1.2.5 Archivos. .............................................................................................. 5
Estructuras de control. .............................................................................. 5
3.1.3.1 Secuencia. ............................................................................................. 5
3.1.3.2 Estructuras de decisión. ........................................................................ 6
3.1.3.3 Estructuras repetitivas........................................................................... 8
Subprogramas. .......................................................................................... 9
3.1.4.1 Modos y mecanismo para el paso de parámetros. ................................ 9
3.1.4.2 Procedimientos. .................................................................................. 10
3.1.4.3 Funciones............................................................................................ 11
3.2
Ocultación de información, compilación por separado, tipo abstracto de datos,
POO y Reusabilidad. .................................................................................................. 12
Ocultación de información. .................................................................... 12
Compilación por separado...................................................................... 12
Tipos abstractos de datos........................................................................ 12
Programación orientada al objeto........................................................... 13
3.2.4.1 ADA y la POO.................................................................................... 13
JAVA y la POO. ................................................................................. 14
1.1.1.1
Reusabilidad. .......................................................................................... 16
3.2.5.1 Programación genérica en Java. ......................................................... 16
Interfaces en Java................................................................................ 17
3.2.5.2

3.2.1
3.2.2
3.2.3
3.2.4

3.2.5



Rafael Álvarez García
Última revisión 29-11-07
rafpalvarez@gmail.com

Nota importante:
Este documento no pretende reemplazar al material propuesto por la UNED para
la asignatura Sistemas en Tiempo Real. Cualquier sugerencia, comentario o
corrección sobre este documento, envíelo a rafpalvarez@gmail.com para poder
realizar los cambios necesarios.



1



3 Programación para tiempo real.

3.1 Lenguajes para tiempo real.


Resulta imposible dar una descripción detallada de todos los lenguajes utilizados en
el dominio de STR por lo que el estudio de los mismos lo limitamos a los siguientes
cuatro lenguajes. Ada, Java, C++ y Occam2.

Los programas se escriben una vez, pero se leen varias veces; de esto se desprende
que el estilo léxico de la sintaxis del lenguaje debiera estar más orientado al lector que
al que lo escribe. Una forma simple de incrementar la legibilidad es utilizar nombres
que aporten significados.

3.1 Estilo general, tipos de datos, estructuras de control y

subprogramas.

3.1.1 Estilo general.


Los tres lenguajes anteriores están , en mayor o menor medida, estructurados en

bloques. Un bloque en Ada consiste en :

• La declaración de objetos.
• Una secuencia de sentencias.
• Un conjunto de gestores de excepciones.



Un esquema de uno de estos bloques es:

declare

<parte declarativa>

bejín

<secuencia de sentencias>

exception

<gestores de excepciones>

end;


Dentro de un programa ADA se puede colocar un bloque en cualquier lugar donde

pudiera darse una sentencia.

En C y Java, un bloque se delimita por un par de llaves ({ y }), y tiene la siguiente

estructura:


{
<parte declarativa>
<secuencia de sentencias>
}



Como en ADA, java y C++ tienen manejador de excepciones.

Occam2, como Ada, es un lenguaje estructurado en bloques.



2

Cualquier proceso puede ser precedido por la declaración de objetos que serán

usados por ese proceso.

3.1.2 Tipos de datos.


Ada permite

la declaración de constantes,

tipos, variables, subprogramas
(procedimientos y funciones) y paquetes. De forma similar, C++ y Java permiten definir
clases y paquetes. Occam2 no permite definir tipos de datos por el usuario.
3.1.2.1 Tipos discretos.


La tabla siguiente muestra los tipos discretos predefinidos soportados en los cuatro

lenguajes.



Ada, Java y Ocaam2 son fuertemente tipados, es decir las asignaciones y

expresiones deben involucrar objetos del mismo tipo.

Tanto ADA como C++ permiten que los tipos enteros básicos sean con o sin signos.
ADA y C++ permiten la definición de tipos de enumerados.
Otra posibilidad que soporta Ada es el uso de subrangos o subtipos para restringir

los valores de un objeto

En Java, los tipos nuevos se crean utilizando las posibilidades de la programación

orientada al objeto.

3.1.2.2 Números reales.


En esencia, existen dos modos distintos d representar valores reales en un lenguaje

de alto nivel.

• Coma flotante
• Enteros escalados.



Los números en coma flotante son una aproximación finita a los números reales. Un
número de coma flotantes está representado por tres valores: una mantisa, M, un
exponente, E, y una base, B. Su valor se calcula según la fórmula M * BE

El uso de enteros escalados está indicado para los cálculos numéricos exactos.



3

Ada utiliza el término flota y C utiliza los términos flota y double para su
implementación dependiente del tipo real. No existe un equivalente en Occam2, ya que
se debe especificar el número de bits, estos son REAL!&, REAL32 y REAL64. Los
literales en coma flotante en Java se consideran automáticamente como de doble
precisión.

Además del tipo predefinido Flota, Ada proporciona a los usuarios la posibilidad de
crear números de coma flotantes de diferente precisión, así como números de coma fija.
Por ejemplo:

type Nuevo_Flota is digits 10 range –1.0E18..2.0E18
Un subtipo de éste puede restringir el rango o la precisión:
subtype Otro_Float is Nuevo_Flota digits 2; subtype
Otro_Nuevo_Float is Nuevo_Flota range 0.0..1000.0;



3.1.2.3 Tipos de datos estructurados.


Las posibilidades de manejo de tipos de datos estructurados para cada uno de los
cuatro lenguajes pueden establecerse bastante fácilmente . Occam2 y Java soportan
arrays, y ADA y C soportan arrays y registros.

-- definición de una constante en occam2


-- Lectura es un array con diez elementos



• occam2

INT MAX Is 10:
[MAX]REAL32 Lectura:
[MAX][MAX]Bool Indicadores:
/* C */
#define MAX 10
typedef float lectura[MAX];

// Java
static final int max = 10;
float lectura[] = new float[max];


• Ada


Max: Const Integer := 10;
type Lectura is array(0..MAX – 1) of Float;

3.1.2.4 Tipos de datos dinámicos y apuntadores.


La implementación de tipos de datos dinámicos representan una considerable
sobrecarga en el tiempo de ejecución para un lenguaje. Por esta razón Occam2 no tiene
estructuras dinámicas.

Al contrario que en C, el operador new de Ada está definido en el lenguaje, pero sin
embargo, no existe un operador para desalojar. En su lugar, se proporciona un operador
genérico que elimina el almacenamiento de los objetos designados.



4

Ni Ada ni C especifican la necesidad de n recolector de basura, ya que estos

normalmente producen sobrecargas impredecibles en tiempo de ejecución.


...
{
typedef struct nodo {
int valor;
struct nodo *sig;
} nodo_t;

int v;
nodo_t* Apunt = malloc(sizeof(nodo_t));
Apunt->valor = V;
Apunt->sig = 0;
...
}


type Nodo; -- declaración incompleta
type Acc is acces Nodo;
type Nodo is

record

Valor: Integer;
Sig: Acc;
end record;
V integer;
A1: Acc;
begin



A1 := new(Nodo);
A1.Valor := V;
A1.Sig := null;

end;


Al contrario que en Ada y C, todos los objetos en Java son referencias al objeto real

que contiene los datos, por lo que no existe un tipo de acceso o apuntador.

3.1.2.5 Archivos.


Ni Ada, ni C++, ni Java ni Occam2 tienen un constructor de tipo archivo como
Pascal. En su lugar cada lenguaje permite una implementación que soporte archivos vía
bibliotecas.

3.1.3 Estructuras de control.


Existe un acuerdo general sobre la abstracción de control necesaria en un lenguaje
de programación secuencial. Estas abstracciones se pueden agrupar en tres categorías:
secuencias, decisiones y bucles.



3.1.3.1 Secuencia.



5

La ejecución secuencial de sentencias es el modo normal de comportamiento en un
lenguaje de programación no concurrente. Tanto
  • Links de descarga
http://lwp-l.com/pdf899

Comentarios de: Capitulo 3 y 4. Programar lo pequeño y lo grande (0)


No hay comentarios
 

Comentar...

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios
Es necesario revisar y aceptar las políticas de privacidad