# Comportamiento del Mapeo de Tags - LibS7Adv

## Resumen

La biblioteca LibS7Adv ahora implementa un comportamiento diferencial para el manejo de tags según el tipo de driver utilizado:

- **AdvCoSimulator**: Usa los tags directamente sin conversión
- **Sharp7**: Usa `MapTagToAddress()` para convertir tags a direcciones absolutas

## Comportamiento por Driver

### AdvCoSimulator
```csharp
// Para AdvCoSimulator, los tags se usan directamente
string tag = "DB1.DBX0.0";  // Se usa tal como está
connection.ReadBool(tag);
```

### Sharp7
```csharp
// Para Sharp7, los tags se convierten a direcciones absolutas
string tag = "PEW0";         // Se convierte a "IW0"
string address = MapTagToAddress(tag);  // "IW0"
connection.ReadBool(address);
```

## Funciones Afectadas

Todas las siguientes funciones implementan este comportamiento diferencial:

- `LeerBool(string sTag)`
- `EscribirBool(string sTag, bool Value)`
- `LeerNumber(string sTag, bool Signed = false)`
- `EscribirNumber(string sTag, object value)`
- `EscribirTag(string pTag, SDataValue Value)` *
- `LeerTag(string pTag)` *
- `EscribirTagBool(string pTag, bool pValue)`
- `EscribirTagInt16(string pTag, int pValue)`
- `LeerTagBool(string pTag)`
- `LeerTagInt16(string pTag)`
- `LeerTagDInt(string pTag)`
- `EscribirTagDInt(string pTag, int pValue)`

\* *Funciones especiales - ver sección siguiente*

## Funciones con SDataValue

### EscribirTag con Sharp7
Cuando se usa Sharp7, `EscribirTag(string pTag, SDataValue Value)` detecta automáticamente el tipo del `SDataValue` y usa la función específica correspondiente:

```csharp
// Ejemplo de uso
SDataValue value = new SDataValue();
value.Bool = true;

// Con AdvCoSimulator: usa WriteTag directamente
// Con Sharp7: detecta que es Bool y usa EscribirBool internamente
EscribirTag("I0.0", value);
```

**Tipos soportados en Sharp7:**
- `EPrimitiveDataType.Bool` → `EscribirBool`
- `EPrimitiveDataType.Int8/UInt8` → `EscribirNumber`
- `EPrimitiveDataType.Int16` → `EscribirNumber`
- `EPrimitiveDataType.UInt16` → `EscribirNumber`
- `EPrimitiveDataType.Int32` → `EscribirNumber`
- `EPrimitiveDataType.UInt32` → `EscribirNumber`
- `EPrimitiveDataType.Float` → `EscribirNumber`
- `EPrimitiveDataType.Double` → `EscribirNumber`

### LeerTag con Sharp7
`LeerTag(string pTag)` no está soportado con Sharp7 ya que `SDataValue` es específico de AdvCoSimulator. Se recomienda usar las funciones específicas por tipo.

## Normalización de Direcciones (Solo Sharp7)

El sistema `MapTagToAddress()` + `NormalizePlcAddress()` soporta múltiples notaciones de direcciones PLC:

### Ejemplos de Conversión
```csharp
"PEW0"  → "IW0"   // Alemán con P → Americano
"EW0"   → "IW0"   // Alemán → Americano  
"PIW0"  → "IW0"   // Americano con P → Sin P
"PAW0"  → "QW0"   // Alemán output con P → Americano
"AW0"   → "QW0"   // Alemán output → Americano
"PE0.0" → "I0.0"  // Bit alemán con P → Americano
"E0.0"  → "I0.0"  // Bit alemán → Americano
```

## Migración de Código Existente

### Código Anterior (Incorrecto)
```csharp
// ANTES: MapTagToAddress se usaba siempre
string address = MapTagToAddress(tag);
connection.ReadBool(address);
```

### Código Actual (Correcto)
```csharp
// AHORA: El comportamiento es automático según el driver
var result = plcViewModel.LeerBool(tag);  // Se maneja internamente
```

## Ventajas del Nuevo Comportamiento

1. **Compatibilidad Completa**: Cada driver usa su método óptimo
2. **Transparencia**: El usuario no necesita saber qué driver está usando
3. **Flexibilidad**: AdvCoSimulator mantiene toda su funcionalidad de tags
4. **Normalización**: Sharp7 soporta múltiples notaciones PLC internacionalmente
5. **Futuro-Proof**: Base preparada para tablas de mapeo simbólico

## Recomendaciones de Uso

1. **Para código nuevo**: Usar las funciones del PLCViewModel directamente
2. **Para AdvCoSimulator**: Seguir usando tags como `"DB1.DBX0.0"`
3. **Para Sharp7**: Cualquier notación (`"PEW0"`, `"IW0"`, `"EW0"`) funcionará
4. **Para SDataValue**: Preferir AdvCoSimulator, o usar funciones específicas con Sharp7