ActiveX Data Objects

ActiveX Data Objects (ADO) es uno de los mecanismos que usan los programas de
computadoras para comunicarse con las bases de datos, darles órdenes y obtener resultados
de ellas.

Con ADO, un programa puede leer, insertar, editar, o borrar, la información contenida en
diferentes áreas de almacenamiento dentro de la base de datos llamadas tablas. Además, se
puede manipular la propia base de datos para crear nuevas áreas para el almacenamiento de
información (tablas), como también alterar o eliminar las ya existentes, entre otras cosas.

Fue desarrollado por Microsoft y es usado en ambientes Windows por lenguajes de

programación como Visual Basic, C++, Delphi entre otros, como también en la Web
mediante el uso de Active Server Pages (ASP) y el lenguaje VBScript.

Evolución
ADO substituyó tanto a DAO (Data Access Object), como a RDO (Remote Data Object),
que eran los sistemas previos que se usaban para acceder a las bases de datos y bases de
datos remotas, respectivamente. Tiene la mayor parte de la funcionalidad de ambos
modelos y sin embargo es más sencillo de usar y de entender y por lo tanto más fácil y
menos engorroso de programar.

La última versión de ADO, creada por Microsoft, se llama ADO.NET, y se usa en los
entornos de programación de la plataforma .NET, de Microsoft, para manejar bases de
datos tanto en Windows como en la Web mediante ASP.NET, que es la nueva versión del
ASP para la plataforma.NET.

En la plataforma de programación de software libre llamada Mono también existe una

biblioteca similar a ADO.NET, lo que significa que ahora, la tecnología ADO.NET se
puede usar en otros sistemas operativos aparte de Windows, como Linux, Mac OS X, BSD,
y Solaris.

ADO.NET es mucho más poderoso que ADO pero también es muy diferente, por lo que es
necesario rediseñar los programas hechos con ADO, para que funcionen en él.

Está previsto que para el 2006 salga una nueva versión del entorno.NET que tendrá una
versión mejorada de ADO.NET, denominada ADO.NET 2.

+-----+------+
| DAO | RDO |
+-----+------+
| ADO |
+------------+
| ADO.NET |
+------------+
| ADO.NET 2 |
+------------+
| ADO.NET 3.5|
+------------+

Funcionamiento
ADO es un intermediario entre el programa y la base de datos. El programa no ve la base
de datos directamente, sino que hace todo el trabajo a través de ADO. Usando ADO, el
programa se comunica con la base de datos, consulta, edita, inserta, borra, registros, añade
tablas, etc. ADO a su vez se comunica con la base de datos a través de un "proveedor de
datos".

El programa usa ADO para hacer una solicitud a la base de datos:

"Dame el nombre y apellido de todos los empleados que vivan en
Venezuela"

Programa ---> ADO ---> Proveedor de datos ---> Base de datos

En la dirección contraria, la base de datos responde, comunicándose con el proveedor de

datos, éste con ADO, y al final, la información llega al programa.

La base de datos responde

Programa <--- ADO <--- Proveedor de datos <--- Base de datos

+--------+-----------+
| Nombre | Apellido |
+--------+-----------+
| José | Pereira |
| Juan | Pérez |
| María | Hernández |
+--------+-----------+

Una vez que el programa tiene la información proveniente de la base de datos, puede hacer
con ella lo que considere, como por ejemplo, puede desplegarla en una página Web.

Los usuarios solicitados son los siguientes:

Nombre Apellido
José Pereira
Juan Pérez
María Hernández

Componentes de ADO
Principales componentes de ADO

• Connection (Permite establecer una conexión con la base de datos)

• Recordset (Maneja un conjunto de records de la base de datos)
• Command (Permite enviar órdenes SQL para ser ejecutados por la base de datos)

Otros componentes de ADO

• Record (Permite manejar un registro, típicamente pero no exclusivamente, de una

fuente diferente a una base de datos. Uno de sus usos es la representación de datos
que no están estructurados en forma de Tablas, como por ejemplo que tengan una
estructura tipo árbol.
• Field (Permite manipular un campo perteneciente a un Record o un Recordset)
• Parameter (Permite configurar un parámetro para una consulta SQL. Se usa con
Command)
• Stream (Permite manejar flujos de datos (streams), provenientes de ficheros de
texto, páginas web, etc)
• Error (Indica las características de los errores que pudieran suceder al ejecutar
métodos de los objetos de ADO)
• Property (Contiene información perteneciente a un objeto determinado)

Objetos Connection, Recordset y Command

Los 3 principales componentes de ADO son Connection, Recordset y Command (la
conexión, el recordset, y la orden).

+------------+
+----+ Connection +----+
| +------------+ |
| |
+-----+-----+ +-----+-----+
| Recordset +----------+ Command |
+-----------+ +-----------+

La Conexión

La conexión es como una autopista que permite el flujo de datos entre el programa y la
base de datos. Por ella pueden viajar las órdenes que desde el programa se usan para hacer
solicitudes de información a la base de datos o para realizar una operación dentro de ella
como borrar registros, añadir registros, modificar tablas, etc. También, por esta autopista,
pueden ir y venir los datos, desde y hacia la base de datos, entre otras cosas.

Tanto el recordset como la orden usan la conexión para comunicarse con la base de datos.

La conexión se comunica con la base de datos a través de un intermediario llamado

"proveedor de datos".
+----------+ +-----------+ +---------+
| Conexión | ------> | Proveedor | ------> | Base de |
| | <------ | de datos | <------ | datos |
+----------+ +-----------+ +---------+

El proveedor de datos

El proveedor de datos es un componente que se relaciona directamente con la base de datos.

Hay un proveedor de datos por cada tipo de base de datos. Así, las bases de datos de tipo
Access, SQL Server, Oracle, MySQL, tienen, cada una, un proveedor de datos específico.

La conexión ADO puede usar dos tipos de proveedores de datos, OLE DB y ODBC, siendo
OLE DB el tipo de proveedor nativo.

Cuando no existe un proveedor de OLE DB específico para una base de datos determinada,
y en cambio existe un proveedor ODBC, la conexión ADO puede usarlo para comunicarse
con la base de datos, sin embargo, no directamente, sino a través de un proveeor OLE DB
especial que sirve de intermediario entre ADO y ODBC.

La figura de abajo muestra, a la izquierda, un esquema de los diferentes componentes que

existen entre un programa y la base de datos, y, a la derecha, muestra el camino que recorre
la información, usando por un lado OLE DB, y por el otro ODBC. Nótese que al usar
ODBC, la ruta es más larga porque tiene que pasarse por más componentes. Esto hace la
comunicación un poco más lenta.

Con OLE DB Con ODBC

+---------------+ +---------------+ +---------------+
| Programa | | Programa | | Programa |
+---------------+ | | | | | |
| ADO | | ADO | | ADO |
+---------------+ | | | | | |
| OLE DB | | OLEDB | | OLEDB (OLE DB especial para
| +--------+ | | | | | comunicación con
cualquier ODBC)
| | ODBC | | | | | ODBC |
+------+--------+ | | | | | |
| Base de datos | | Base de datos | | Base de datos |
+---------------+ +---------------+ +---------------+

Todo esto es transparente al usuario de ADO, quien, en líneas generales, no tiene por que
enterarse ni conocer estos mecanismos.

ADO tiene un alto grado de abstracción, lo que significa que, al mantener una interface
sencilla, oculta los detalles complejos del manejo de la base de datos.

Un programa puede saltarse completamente el ADO, y acceder a la base de datos

directamente de 3 maneras diferentes, a través de OLDB, ODBC, o por ODBC usando una
capa intermedia de OLE DB. Al trabajar de esta manera, se tiene la ventaja de una mayor
funcionalidad que no contiene ADO a cambio de una mayor complejidad en la
programación. Esto es necesario algunas veces, en ciertos tipos de programas y para ciertas
necesidades, pero no es lo común.

+------------------------+
| Programa |
+---+-------+-------+----+
1 2 3
+---+----+--+---+---+----+
| OLE DB | ODBC | OLE DB |
| | +--------+
| | | ODBC |
+--------+------+--------+
| Base de datos |
+------------------------+

El Recordset

El Recordset es, como su nombre lo indica, un conjunto de records. En general, sus datos
tienen su origen en una base de datos, aunque también pueden generarse
independientemente de ésta.

Un recordset puede contener cero o más records (registros). Cada recordset tiene una
colección de campos, que es común a todos los records. Podemos verlo como una matriz o
tabla, en donde las filas son los records, y las columnas son los campos.

Recordset con algunos datos de la tabla de empleados:

+------------+---------+----------+
| IdEmpleado | Nombre | Apellido |
+------------+---------+----------+
| 1 | Luis | Pérez | <-- Record 1
+------------+---------+----------+
| 5 | José | Abreu | <-- Record 2
+------------+---------+----------+
| 3 | Pedro | León | <-- Record 3
+------------+---------+----------+
| 7 | María | Marcano | <-- Record 4
+------------+---------+----------+
| | |
| | +------- Campo "Apellido"
| |
| +------------------ Campo "Nombre"
|
+----------------------------- Campo "IdEmpleado"

Un recordset puede tener varias características que el programador define a su

conveniencia. Puede ser de solo lectura, o de lectura-escritura, por ejemplo.

La información con que se carga el recordset puede provenir de una tabla o varias tablas, de
la base de datos.

El recordset, tiene capacidades de navegación entre su conjunto de registros. Puede:

 • Moverse al siguiente registro
• Moverse al anterior
• Moverse al primero
• Moverse al último
• y otros

En un recordset, se ve y se pueden editar los datos de un solo registro en un tiempo dado, se

pueden manipular los datos de los campos del "registro actual" en donde se encuentra.

Además de editar registros, también se puede:

• Insertar registros nuevos

• Borrar registros

Las edición, la inserción y el borrado de registros en el recordset, se reflejarán en la Base de

Datos.

El Comando

La orden (command) es el componente ADO que permite hacer solicitudes o dar órdenes a
la base de datos mediante una sentencia SQL.

Se puede especificar la inserción de registros nuevos en una tabla, así como también, la
eliminación la actualización y la obtención de registros con determinadas condiciones.

Además, se pueden crear, alterar y modificar las características de las tablas que conforman
la base de datos.

Ejemplo de uso de ADO desde Visual Basic

En este ejemplo se asume un Formulario con un DataGrid. Se usará la base de datos
"Neptuno.mdb" que viene en las instalaciones en español de Microsoft Office y de Visual
Basic.

Referencia a ADO

Para poder usar ADO desde Visual Basic, lo primero que debemos hacer es referenciar el
componente ADO. Esto se hace por el menú "Proyecto\Referencias" y en la ventana que
sale, seleccionamos ADO, que en la lista se verá como

Microsoft ActiveX Data Objects X.XX Library

en donde X.XX representa la versión de ADO que queremos usar, que puede ir desde la 1.5
hasta la 2.8. DFA Nota: Un computador pudiera tener instalada una o más versiones
simultáneamente y debemos elegir una de ellas. Las versiones más recientes tienen más
funcionalidades y tienen menos errores que las antiguas.
La conexión con la base de datos

Para trabajar con una base de datos, primero debemos establecer una conexión con ésta.

En el Formulario, declaramos el objeto MiConexión, que nos permitirá la conexión con la

base de datos

' declaro el objeto MiConexion como una variable de módulo.

' Cuando se instancie será la conexión con la base de datos
Dim MiConexion As ADODB.Connection

En este momento, el objeto MiConexion solo está declarado, pero todavía no existe porque
no ha sido instanciado.

En el evento Form_Load, instanciamos el objeto MiConexion, y establecemos la conexión

con la base de datos para poder comunicarnos con ella.

Private Sub Form_Load()

' Instancio la conexión (ahora la conexión existe)
Set MiConexión = New ADODB.Connection

With MiConexión
' Cursor en Cliente para poder usar un DataGrid
.CursorLocation = adUseClient
' Abro la conexión con la base de datos Neptuno.mdb usando su DSN
.Open "DSN=Neptuno"
End With
End Sub

Ya tengo la conexión instanciada y ya me he conectado con la base de datos. La autopista

está abierta y funcionando.

Ahora puedo hacer cosas con la información que contiene la base de datos. Puedo leerla,
escribirla, borrarla, modificarla, etc. También puedo manipular la propia base de datos.
Puedo crear tablas, modificarlas, puedo crear usuarios, etc.

Leo información de la base de datos

Ahora que tenemos la conexión establecida con la base de datos, queremos leer
información de ésta y mostrarla en la pantalla.

Especificamos la información que queremos

Primero, debemos especificarle, a la base de datos, qué información queremos. Esto se hace
mediante una sentencia SQL.

Por ejemplo. Queremos el ID y el Nombre del producto para todos los productos cuyo
Nombre contenga la palabra "Queso".
Esta es la sentencia SQL que necesitamos
SELECT IdProducto, NombreProducto
FROM Productos
WHERE NombreProducto LIKE '%Queso%'

La sentencia SQL de arriba significa lo siguiente:

Indicamos, a la base de datos, que nos devuelva dos campos,

IdProducto y NombreProducto
SELECT IdProducto, NombreProducto

Indicamos en qué Tabla, de la base de datos,

están los campos previamente señalados
Están en la Tabla Productos
FROM Productos

Indicamos una condición.

Queremos solo los registros en cuyo nombre esté la palabra "Queso"
WHERE NombreProducto LIKE '%Queso%'

En Visual basic, creamos una variable de string a la que llamaremos "SQL". Podríamos
llamarla como querramos, podríamos llamarla "Aguacate", Visual Basic lo manejaría sin
problemas, pero es mejor darle un nombre que tenga sentido para nosotros y que
corresponda con el uso que se le va a dar.

Dim SQL As String

A esa variable le asignamos un texto que será la orden que le vamos a enviar a la base de
datos. Este texto es la sentencia SQL que acabamos de crear arriba.

SQL = "SELECT IdProducto, NombreProducto" & vbCrLf & _

"FROM Productos" & vbCrLf & _
"WHERE NombreProducto LIKE '%Queso%'"

Ya tenemos especificado la orden que le vamos a enviar a la base de datos para que nos
devuelva los registros con la información que queremos. Ahora debemos crear un
Recordset, que es el objeto de ADO donde se recibirá la información proveniente de la base
de datos.

Usamos un Recordset para recibir la información desde la base de datos

Declaramos el objeto Recordset que recibirá la información de la base de datos

Dim rs As ADODB.Recordset

La variable "rs" recibirá los datos provenientes de la base de datos.

Ahora usamos la conexión para enviar la orden a la base de datos para que nos devuelva la
información.
Set rs = MiConexion.Execute(SQL)

Cuando se ejecuta la sentencia previa, la conexión "MiConexion", ejecuta la orden

contenida en la variable "SQL". Esto significa que la orden es enviada a la base de datos y
ésta responde devolviendo la información requerida. "MiConexion" lee esa información
proveniente de la base de datos, y la convierte en un Recordset, el cual es asignado al
objeto "rs".

Ahora el Recordset "rs" tiene la información que llegó desde la base de datos, lista para ser
usada. Allí tenemos, todos los registros de la Tabla "Productos" que cumplan con la
condición de que en el campo "NombreProducto" contenga la palabra "queso". En el
Recordset solo se encuentran los campos que especificamos, "IdProducto" y
"NombreProducto".

Mostramos la información que contiene el Recordset en un DataGrid

En el Recordset "rs" tenemos la información. Esta información es usable de muchas

maneras, ya que con el Recordset tal y como está podemos recorrer esa información y
manipularla, añdir registros, borrarlos, etc.

Sin embargo, en este ejemplo, queremos mostrarla en un DataGrid.

Para ello, solo tenemos que asignar el Recordset a la propiedad DataSource del DataGrid.
Una vez hecho esto, el DataGrid mostrará el contenido del recordset.

Set DataGrid1.DataSource = rs

Código completo del programa

Nota: Para que el programa funcione solo hay que añadir un control DataGrid al Formulario
y una referencia a Microsoft ActiveX Data Objects X.XX Library.

Option Explicit

' ----------------------------------------------------------
' Declaro el objeto MiConexion como una variable de módulo.
' Cuando se instancie será la conexión con la base de datos.
' ----------------------------------------------------------
Dim MiConexión As ADODB.Connection

' ----------------------------------------------------------
' Al cargarse el Formulario hago el trabajo.
' (Aquí, a lo sumo, solo debería establecerse la conexión con la base de
datos,
' y las demás cosas se deberían hacer en otro lado,
' pero este es solo un ejemplo sencillo)
' ----------------------------------------------------------
Private Sub Form_Load()
' ----------------------------------------------------------
' Instancio la conexión y me conecto con la base de datos
 ' ----------------------------------------------------------
Set MiConexión = New ADODB.Connection

With MiConexión
' Cursor en Cliente para poder usar un DataGrid
.CursorLocation = adUseClient
' Abro la conexión con la base de datos usando un DSN
.Open "DSN=Neptuno"
End With
' ----------------------------------------------------------
' Especifico qué información quiero de la base de datos
' ----------------------------------------------------------
Dim SQL As String

SQL = "SELECT IdProducto, NombreProducto" & vbCrLf & _

"From Productos" & vbCrLf & _
"WHERE NombreProducto LIKE '%Queso%'"
' ----------------------------------------------------------
' Cargo el recordset con la información proveniente de la base de
datos
' ----------------------------------------------------------
Dim rs As ADODB.Recordset

Set rs = MiConexión.Execute(SQL)
' ----------------------------------------------------------
' Muestro la información en el DataGrid
' ----------------------------------------------------------
Set DataGrid1.DataSource = rs
End Sub

Imagen del programa

Se muestran los artículos de la Tabla Productos cuyos nombres contengan la palabra

"queso".

Gráfico rasterizado
Una imagen rasterizada, también llamada mapa de bits, imagen matricial o bitmap, es
una estructura o fichero de datos que representa una rejilla rectangular de píxeles o puntos
de color, denominada raster, que se puede visualizar en un monitor de ordenador, papel u
otro dispositivo de representación.

A las imágenes rasterizadas se las suele caracterizar por su altura y anchura (en pixels) y
por su profundidad de color (en bits por pixel), que determina el número de colores
distintos que se pueden almacenar en cada pixel, y por lo tanto, en gran medida, la calidad
del color de la imagen.

Los gráficos rasterizados se distinguen de los gráficos vectoriales en que estos últimos
representan una imagen a través del uso de objetos geométricos como curvas de Bézier y
polígonos, no del simple almacenamiento del color de cada pixel. El formato de imagen
matricial está ampliamente extendido y es el que se suele emplear para tomar fotografías
digitales y realizar capturas de vídeo. Para su obtención se usan dispositivos de conversión
analógica-digital, tales como escáneres y cámaras digitales.

Colores
La imagen puede o no poseer colores.

Resolución

Detalle de una imagen rasterizada. Si hacemos zoom sobre esta imagen, podemos ver los
cuadraditos (pixels) que la conforman.

Una imagen rasterizada no se puede ampliar a cualquier resolución sin que la pérdida de
calidad sea notoria. Esta desventaja contrasta con las posibilidades que ofrecen los gráficos
vectoriales, que pueden adaptar su resolución fácilmente a la resolución máxima de nuestra
pantalla u otro dispositivo de visualización. Las imágenes rasterizadas son más prácticas
para tomar fotografías o filmar escenas, mientras que los gráficos vectoriales se utilizan
sobre todo para el diseño gráfico o la generación de documentos escritos. Las pantallas de
ordenador actuales habitualmente muestran entre 72 y 130 pixeles por pulgada(PPI), y
algunas impresoras imprimen 2400 puntos por pulgada (DPI) o más; determinar cuál es la
mejor resolución de imagen para una impresora dada puede llegar a ser bastante complejo,
dado que el resultado impreso puede tener más nivel de detalle que el que el usuario pueda
distinguir en la pantalla del ordenador. Habitualmente, una resolución de 150 a 300 pixels
funciona bien para imprimir a 4 colores (CMYK).

Sin embargo, existe una fórmula matemática que me permite definir esta resolución según
el sustrato de impresión:

lpi x 2 x f a/r = dpi

Donde lpi, es el lineaje a utilizarse según el sustrato, por ejemplo: 150 lpi, si son papeles
recubiertos, 85 lpi para periódico, etc.

2 es un factor basado en la capacidad de rasterización del escanner

y f a/r es la ampliación o disminución en que se necesita la imagen.

La fórmula puede utilizarse, solamente como lpi x 2 = dpi.

Conversión entre formatos raster y vectorial

La transformación de un gráfico rasterizado a uno vectorial se llama vectorización. Este
proceso normalmente se lleva a cabo o bien manualmente calcando la imagen rasterizada o
bien con ayuda de un programa específico, como por ejemplo Corel PowerTrace. El
proceso inverso, convertir una imagen vectorial en un gráfico rasterizado, es mucho más
sencillo y se llama rasterización.

El cubo de Rubik es un cuerpo tridimensional que podemos "interpretar" como un cuerpo

formado por voxels.

Analogía en 3D
En infografía 3D (en tres dimensiones) el concepto de una rejilla plana de pixels se
extiende a un espacio tridimensional formado por ladrillos cúbicos llamados "voxels". En
este caso, existe una reja tridimensional con elementos (cubitos) que contienen la
información del color. A pesar de que los « voxels » son un concepto potente para tratar
cuerpos con formas complejas exigen mucha memoria para ser almacenados. En
consecuencia, a la hora de producir imagénes en tres dimensiones se utilizan más a menudo
imágenes vectoriales 3D.
“Interleaver” vuelve a dirigir aquí. Para el dispositivo fiber-optic, vea Interleaver óptico.
“Interleaver” vuelve a dirigir aquí. Para el código de turbo, vea turbo cifrar el interleaver.
Mire para arriba Interpolación en
Wiktionary, el diccionario libre.

Interpolación en informática es una manera de arreglar datos en a nocontiguo manera para

aumentar funcionamiento.

Se utiliza en:

• multiplexación de división de tiempo (TDM) adentro telecomunicaciones

• memoria de computadora
• almacenamiento en discos

La interpolación se utiliza principalmente en la comunicación de datos, multimedias

formatos del archivo, radio transmisión (por ejemplo adentro satélites) o cerca ADSL. El
término multiplexación se utiliza a veces referir a la interpolación de señal numérica datos.

La interpolación también se utiliza para las estructuras de datos multidimensionales,

considera Z-orden (curva).

Interpolación en el almacenamiento en discos

Históricamente, la interpolación fue utilizada en ordenar almacenaje del bloque en los
dispositivos de almacenaje disk-based tales como diskette y disco duro. El propósito
primario de la interpolación era ajustar las diferencias de la sincronización entre cuando la
computadora era lista transferir datos, y cuando esos datos llegaban realmente el al frente
de la impulsión que se leerá. La interpolación era muy común antes de los años 90, pero
descolorado de uso como procesando velocidades aumentó. El almacenamiento en discos
moderno no se interpola.

La interpolación fue utilizada para arreglar los sectores de la manera más eficiente posible,
de modo que después de leer un sector, la hora fuera permitida para procesar, y entonces el
sector siguiente en orden es listo ser leído apenas pues la computadora es lista hacer tan.
Emparejar la interpolación del sector a la velocidad de proceso por lo tanto acelera la
transferencia de datos, pero una interpolación incorrecta puede hacer que el sistema realiza
marcado más lento.

Uso del ejemplo

La información se almacena comúnmente en el almacenamiento en discos en los pedazos

muy pequeños referidos como sectores o bloques. Éstos se arreglan en los anillos
concéntricos referidos como pistas o cilindros a través de la superficie de cada disco.
Mientras que puede parecerse el más fácil pedir estos bloques en orden serial directa en
cada pista, tal como 1 2 3 4 5 6 7 8 9, porque dispositivos que computaban tempranos esto
que ordenaba no era práctico.
Los datos que se escribirán o a leer se ponen en una región especial de la memoria
reutilizable designada a almacenador intermediario. Cuando los datos necesitaron ser
escritos, fueron movidos en el almacenador intermediario, y después escritos del
almacenador intermediario al disco. Cuando los datos fueron leídos, el revés ocurrió,
transfiriendo primero en el almacenador intermediario y después se movió a donde estaba
necesario. La mayoría de las computadoras tempranas no eran bastante rápidas leer un
sector, no mueven los datos desde el almacenador intermediario a en alguna parte, y no
sean listas leer el sector siguiente para el momento en que el sector siguiente apareciera
bajo cabeza leída.

Cuando los sectores fueron arreglados en orden serial directa, después de que el primer
sector fuera leído la computadora puede pasar el tiempo que toma para tres sectores al paso
cerca antes de que sea listo recibir datos otra vez. No obstante con los sectores en orden
directa, el sector dos, tres, y cuatro ha pasado ya cerca. La computadora no necesita los
sectores 4, 5, 6, 7, 8, 9, o 1, y debe esperar éstos para pasar cerca, antes del sector dos de la
lectura. Esto que espera la vuelta del disco alrededor al punto derecho retarda la tarifa de
transferencia de datos.

Corregir para el proceso retrasa, la interpolación ideal para este sistema sería 1:4, pidiendo
los sectores como esto: 1 8 6 4 2 9 7 5 3. Lee el sector 1, procesos para tres sectores por el
que 8 pasos 6 y 4 cerca, y apenas mientras que la computadora llegan a ser listos otra vez,
está llegando el sector dos apenas mientras que es necesario.

El almacenamiento en discos moderno no necesita interpolar puesto que el espacio de

almacenador intermediario es tanto más grande ahora. Los datos ahora se almacenan más
comunmente como racimos que sean grupos de sectores, y el almacenador intermediario de
los datos es suficientemente grande permitir que todos los sectores en un bloque sean leídos
inmediatamente sin cualquier retrasa entre los sectores.

Interpolación en la transmisión de datos

La interpolación se utiliza en tecnología digital de la transmisión de datos para proteger la
transmisión contra errores de la explosión. Estos errores sobreescriben muchos de pedacitos
en una fila, tan un esquema típico de la corrección de error que espere que los errores que
se distribuirán más uniformemente puedan ser abrumados. La interpolación se utiliza para
ayudar a parar esto del suceso.

Los datos se transmiten a menudo con los pedacitos del control de error que permiten al
receptor corregir algunos errores que ocurran durante la transmisión. Si ocurre un error de
la explosión, demasiados errores se pueden hacer en una palabra de código, y ese codeword
no puede ser descifrado correctamente. Para reducir el efecto de tales errores de la
explosión, los pedacitos de un número de codewords se interpolan antes de ser transmitido.
Esta manera, un error de la explosión afecta solamente un número correctable de pedacitos
en cada codeword, y el decodificador puede descifrar los codewords correctamente.
Este método es popular porque es una manera menos compleja y más barata manejar
errores de la explosión que directamente aumentando la energía del esquema de la
corrección de error.

Miremos un ejemplo. Aplicamos un error que corrige código de modo que el codeword del
canal tenga cuatro pedacitos y los errores del uno-pedacito pueda ser corregido. Los
codewords del canal se ponen en un bloque como esto: aaaabbbbccccddddeeeeffffgggg.

Considere la transmisión sin la interpolación:

Mensaje sin error: transmisión

del aaaabbbbccccddddeeeeffffgggg con un error de la explosión:
aaaabbbbccc____deeeeffffgggg

El dddd del codeword se altera en tres pedacitos, así que o no puede ser descifrado en todos
(falta el descifrar) o puede ser que sea descifrado en el codeword incorrecto (el descifrar
falso). Cuáles de los dos suceden depende del error que corrige el código aplicado.

Ahora, hagamos igual con la interpolación:

Palabras de código sin error: el

aaaabbbbccccddddeeeeffffgggg
interpoló: transmisión
del abcdefgabcdefgabcdefgabcdefg con un error de la explosión:
el abcdefgabcd____bcdefgabcdefg
recibió palabras de código después de deinterleaving:
aa_abbbbccccdddde_eef_ffg_gg

En cada uno del aaaa de los codewords, se altera el eeee, ffff, gggg, solamente un pedacito,
tan nuestro uno-pedacito-error-corregir-código descifrará todo correctamente.

Por supuesto, el estado latente es aumentado en la interpolación porque no podemos enviar

el segundo pedacito del aaaa del codeword antes de aguardar el primer pedacito del gggg
del codeword.

Por un diverso ejemplo, considere una oración significativa como:

ThisIsAnExampleOfInterleaving, y supone que conseguimos estallar error que corrompen
seis letras. Primero, déjenos ven lo que parece la oración sin la interpolación.

Considere la transmisión sin la interpolación:

Oración transmitida original:

ThisIsAnExampleOfInterleaving
recibió la oración con un error de la explosión:
ThisIs______pleOfInterleaving

Encontramos que el término “AnExample” es perdido o unintelligible.

Ahora repetimos este ejemplo pero interpolamos la oración antes de la transmisión. El
mensaje es interpolado transmitiendo cada cuarta letra que empieza la primera letra,
entonces cada cuarta letra que empieza el segundo, tan encendido. Para hacer el mensaje un
múltiplo de cuatro letras, tres puntos se han agregado al extremo. (Éste es un ejemplo de la
interpolación del bloque.)

Considere la transmisión con la interpolación:

Oración transmitida:
ThisIsAnExampleOfInterleaving…
Transmisión sin error:
TIEpfeaghsxlIrv.iAaenli.snmOten.
Oración recibida con un error de la explosión:
TIEpfe______Irv.iAaenli.snmOten.
Oración recibida después de deinterleaving:
T_isI_AnE_amp_eOfInterle_vin_…

No se pierde ninguna palabra totalmente y es fácil recuperarlos.

Vea también gráfico Representación de la interpolación.

Desventajas de la interpolación

Uso de interpolar aumentos de las técnicas estado latente. Esto es porque el bloque
interpolado entero debe ser recibido antes de que los datos críticos puedan ser vueltos.