Desarrollo de códigos para las capas L1, L2, L3 y L4 en el modelo OSI

: El modelo OSI (Open Systems Interconnection) es un modelo conceptual utilizado para entender y diseñar la arquitectura de una red. Las capas que analizaremos son las capas L1 (Física), L2 (Enlace de Datos), L3 (Red) y L4 (Transporte). A continuación, explicaremos cada capa con ejemplos de código que pueden ayudar en su implementación.

 
### Capa L1: Física
La capa física es responsable de la transmisión de bits a través de un medio físico. En esta capa trabajamos con los detalles de cables, conectores, señales eléctricas y sincronización.
 
**Ejemplo de código (Simulación de transmisión de señal en Python):**
```python
import numpy as np
import matplotlib.pyplot as plt
 
# Simulación de una señal simple
fs = 500  # Frecuencia de muestreo
f = 5  # Frecuencia de la señal
x = np.arange(fs)
y = np.sin(2 * np.pi * f * x / fs)
 
plt.plot(x, y)
plt.title('Simulación de una señal digital')
plt.xlabel('Tiempo')
plt.ylabel('Amplitud')
plt.show()
```
 
### Capa L2: Enlace de Datos
La capa de enlace de datos proporciona el control de acceso al medio y la detección y corrección de errores. También se ocupa del enlace lógico de los datos.
 
**Ejemplo de código (Implementación básica de CRC para la verificación de errores):**
```python
def crc_remainder(input_bitstring, polynomial_bitstring, initial_filler):
    len_polynomial = len(polynomial_bitstring)
    initial_padding = initial_filler * (len_polynomial - 1)
    input_padded_array = list(input_bitstring + initial_padding)
    
    while '1' in input_padded_array[:len(input_bitstring)]:
        cur_shift = input_padded_array.index('1')
        for i in range(len_polynomial):
            input_padded_array[cur_shift + i] = str(
                int(polynomial_bitstring[i] != input_padded_array[cur_shift + i]))
    
    return ''.join(input_padded_array)[len(input_bitstring):]
 
data = "1101011111"
polynomial = "10011"
print("Resto CRC:", crc_remainder(data, polynomial, '0'))
```
 
### Capa L3: Red
La capa de red es responsable del direccionamiento y encaminamiento lógico de los datos. Un ejemplo común es el Protocolo de Internet (IP).
 
**Ejemplo de código (Enrutamiento básico utilizando un diccionario en Python):**
```python
routing_table = {
    "192.168.1.0": "eth0",
    "10.0.0.0": "eth1",
    "default": "ppp0"
}
 
def route_packet(ip_address):
    for network, interface in routing_table.items():
        if ip_address.startswith(network):
            return f"Paquete encaminado a través de {interface}"
    return f"Paquete encaminado a través de {routing_table['default']}"
 
print(route_packet("192.168.1.10"))
```
 
### Capa L4: Transporte
La capa de transporte es responsable de la entrega confiable o no confiable de los datos a través de la red. Protocolos comunes son TCP (protocolo de control de transmisión) y UDP (protocolo de datagramas de usuario).
 
**Ejemplo de código (Implementación de una comunicación simple TCP en Python):**
 
**Servidor TCP:**
```python
import socket
 
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 12345))
server_socket.listen(1)
 
print("Esperando una conexión...")
conn, addr = server_socket.accept()
print(f"Conectado por {addr}")
 
while True:
    data = conn.recv(1024)
    if not data:
        break
    print(f"Recibido: {data.decode()}")
    conn.sendall(data)
 
conn.close()
```
 
**Cliente TCP:**
```python
import socket
 
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(('localhost', 12345))
 
message = "Hola, servidor!"
client_socket.sendall(message.encode())
data = client_socket.recv(1024)
print(f"Recibido: {data.decode()}")
 
client_socket.close()
```
 
Esperamos que estos ejemplos te hayan proporcionado una visión general de cómo implementar cada una de estas capas en el desarrollo de sistemas de red.