Bueno, os dejo el video de la aplicación en vb.net funcionando.

Lavadora web 2.0

He modificado la clase encargada de comunicar con el plc. En este caso llamaremos a las variables por su nombre. Esta el la clase:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

Imports TwinCAT.Ads
Public Class ClassAds
    Private adsClient As TcAdsClient
    Dim Conectado As AdsState
    Enum AdsState
        Desconectado
        ErrorConect
        ConectadoOk
    End Enum
 
#Region "PLC ADS"
    Public Function Conectar() As String
        Try
            adsClient = New TcAdsClient
            adsClient.Connect("192.168.255.2.1.1", 801)
            adsClient.Timeout = 5000
 
            If adsClient.ReadState.AdsState.ToString = "Run" Then
                Conectado = AdsState.ConectadoOk
            Else
                Conectado = AdsState.ErrorConect
            End If
            Return adsClient.ReadState.AdsState.ToString
        Catch err As Exception
            Conectado = AdsState.ErrorConect
            Return "Error"
        End Try
 
    End Function
 
    Public Function ValorIntPorNombre(ByVal Name As String)
 
        Dim dataStream As AdsStream
        Dim Read As AdsBinaryReader
 
        Try
            'Recuperar Numero Var
            Dim Var As Integer
            Var = adsClient.CreateVariableHandle(Name)
 
            dataStream = New AdsStream(2)
            adsClient.Read(Var, dataStream)
            Read = New AdsBinaryReader(dataStream)
            Return Read.ReadInt16
        Catch err As Exception
 
            Conectado = AdsState.ErrorConect
            Return 0
        End Try
    End Function
    Public Function txtPorNombre(ByVal Name As String)
 
        Dim dataStream As AdsStream
        Dim Read As AdsBinaryReader
        Dim txt As String
        Dim length As Integer
 
        Try
            'Recuperar Numero Var
            Dim Var As Integer
            Var = adsClient.CreateVariableHandle(Name)
 
            dataStream = New AdsStream(31)
            length = adsClient.Read(Var, dataStream)
 
 
            Read = New AdsBinaryReader(dataStream)
            'txt = Read.ReadString
            txt = New String(Read.ReadChars(length))
            'txt = txt.Substring(0, txt.IndexOf("\0"))
            Return txt
        Catch err As Exception
 
            Conectado = AdsState.ErrorConect
            Return 0
        End Try
 
    End Function
    Public Sub EscribirBoolPorNombre(ByVal Name As String, ByVal Valor As Boolean)
 
        Dim dataStream As AdsStream
        Dim Escribir As AdsBinaryWriter
 
        Try
            'Recuperar Numero Var
            Dim Var As Integer
            Var = adsClient.CreateVariableHandle(Name)
            dataStream = New AdsStream(1)
            Escribir = New AdsBinaryWriter(dataStream)
            Escribir.Write(Valor)
 
            adsClient.Write(Var, dataStream)
        Catch err As Exception
            Conectado = AdsState.ErrorConect
        End Try
    End Sub
 
    Public Sub Desconectar()
        If Conectado = AdsState.ConectadoOk Then adsClient.Dispose()
        Conectado = AdsState.Desconectado
    End Sub
    Public Function StateAds() As String
        If Conectado = AdsState.ConectadoOk Then
            Return 1
        Else
            Return 0
        End If
    End Function
#End Region
End Class

Para poder leer las variables por su nombre, lo que hacemos es recuperar el Valor que identifica esta variable. Esto lo realizamos con la siguiente función:
Var = adsClient.CreateVariableHandle(Name)
Name es el nombre de la variable. Para las variables globales las llamaremos por .NombreDeLaVariable y para el resto NombrePrograma.NombreVariable.

He creado una enumeración para definir los estados de la comunicación. Y una nueva función para recuperar texto del plc. En concreto me interesa la variable MAIN.txtAviso, esta variable nos informa del estado actual de la secuencia.

Este es el código del form principal:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

Public Class Form1
    Dim Plc1 As New ClassAds
 
 
 
    Private Sub buConectar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles buConectar.Click
        Plc1.Conectar()
        Timer1.Enabled = True
    End Sub
 
    Private Sub buDesconectar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles buDesconectar.Click
        If Plc1.StateAds = 1 Then Plc1.Desconectar()
 
    End Sub
 
    Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Timer1.Tick
        Timer1.Enabled = False
 
        If Plc1.StateAds <> 1 Then
            MessageBox.Show("Error Ads")
            Exit Sub
        End If
 
        laTemp.Text = "Temperatura = " & Plc1.ValorIntPorNombre(".Temperatura") & "ºC"
        laNivelAgua.Text = "Nivel de Agua  = " & Plc1.ValorIntPorNombre(".NivelAgua")
        laEstado.Text = Plc1.txtPorNombre("MAIN.txtAviso")
 
        pbM1.Visible = Plc1.ValorIntPorNombre(".M1")
        pbBombo.Visible = pbM1.Visible
        pbM2.Visible = Plc1.ValorIntPorNombre(".M2")
        pbY1.Visible = Plc1.ValorIntPorNombre(".Y1")
        pbY2.Visible = Plc1.ValorIntPorNombre(".Y2")
 
        pbX1.Visible = Plc1.ValorIntPorNombre(".X1")
        ImgFondo(Plc1.ValorIntPorNombre(".CajonCerrado"))
 
        Timer1.Enabled = True
    End Sub
    Private Sub ImgFondo(ByVal Estado As Integer)
        If Estado Then
            pbFondo.ImageLocation = "../../Resources/LavPreparada.png"
        Else
            pbFondo.ImageLocation = "../../Resources/TodoParado.png"
        End If
    End Sub
 
    Private Sub buMarcha_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles buMarcha.Click
        If Plc1.StateAds <> 1 Then Exit Sub
        Plc1.EscribirBoolPorNombre(".InicioLavado", True)
    End Sub
 
    Private Sub buCerrarCajon_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles buCerrarCajon.Click
        If Plc1.StateAds <> 1 Then Exit Sub
        Plc1.EscribirBoolPorNombre(".CajonCerrado", True)
        Plc1.EscribirBoolPorNombre(".PuertaCerrada", True)
    End Sub
    Private Sub buAbrirCajon_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles buAbrirCajon.Click
        If Plc1.StateAds <> 1 Then Exit Sub
        Plc1.EscribirBoolPorNombre(".CajonCerrado", False)
        Plc1.EscribirBoolPorNombre(".PuertaCerrada", False)
    End Sub
    Private Sub Form1_Disposed(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Disposed
        If Plc1.StateAds = 1 Then Plc1.Desconectar()
    End Sub
End Class

Este codigo no tiene mucha historia. Se trata de establecer la conexión. Mediante un timer, leer el estado de los motores y valvulas, para mostrar o no los pictureBox. La imagen de fondo la cambiamos mediante la funcion ImgFondo, en función del estado, mostrando una u otra imagen. El resto de codigo son los eventos de los Buttons para abrir/cerrar o poner en marcha la lavadora.
Aquí, dejo tanto el programa del plc como la aplicación en vb.net. Recordaros que deberéis cambiar la dirección AMS en ClassAds. Para seguir adelante con nuestro proyecto deberemos poner en marcha el servidor web y crear las funciones (vb.net) para grabar en la base de datos.

Continuando con el tema de los sinópticos, haré un pequeño ejemplo de un control que muestra una solenoide conectada /desconectada. No voy a entrar en la realización de los dibujos puesto que sería demasiado extenso. Para realizar este control abrimos un nuevo proyecto de vb.net y añadimos un control de usuario. En el control de usuario añadimos dos PictureBox.

Cambiamos la propiedad Name a pbOn y pbOff.

Pinchando en la flecha podemos acceder al menú para Tareas para PictureBox. Pincha en el hipervínculo “elegir imagen” y ponemos la imagen. En mi caso he realizado un dibujo de una solenoide. Con el programa de renderizado he sacado una foto con unos colores y otra cambiando el color del conector, como muestran las siguientes figuras:

Cambiamos la propiedad de modo de tamaño a StretchImagen.

Una vez hecho esto cambiamos la propiedad Dock de ambos PictureBox a Fill

De esta forma nuestro control se podrá redimensionar manteniendo la imagen completa.

Para terminar nuestro control tendremos que añadir una propiedad Estado que será la manera en que cambiemos la imagen a visualizar.

Cuando cambiamos la propiedad estado del control, se lee el código que hay en la función Set. Primero se pasa el valor a la variable interna “_Estado”. Bien ya tenemos hecho nuestro control, ahora sólo resta probarlo. Para poder utilizar el control deberemos generar la aplicación. En el Menú Generar, generar. Si todo es correcto deberíamos tener creado un nuevo componente listo para usar en la caja de componentes.

Como siempre, lo arrastramos al Form principal y añadimos un botón para hacer las pruebas. Doble click sobre el botón y añadimos este código para cambiar la propiedad estado del control a cada pulsación del botón.

Y este es el resultado:

Aquí os dejo un archivo .rar con el modelo de la solenoide en Scketchup, las dos imágenes en .jpg y el proyecto en vb.net.

Cuando tienes averías raras de las que desconoces la causa, interrogas a los usuarios de las instalaciones he intentas reconstruir lo que pasó. En otras ocasiones te gustaría saber cómo funciona la instalación para poder saber cómo mejorarla. Para no tener que volver a hacer interrogatorios podemos crear nuestro espía que grabará en el PC cada cambio de estado para más tarde poder reconstruir el pasado.

En esta entrada y siguientes construiremos una pequeña aplicación que guarde el estado de las entradas/salidas del PLC en el PC, para más tarde poder ver gráficamente lo que pasó con nuestra instalación mientras estábamos fuera. Para compactar la información guardaremos el estado de las entradas/salidas en palabras INT.

Tenemos que realizar los siguientes pasos en el PLC:

• Convertir el estado de 16 entradas en una palabra INT.
• Convertir el estado de 16 salidas en una palabra INT.

Estos en el programa del PC (vb.net) para guardar:

• Guardar en un archivo las palabras cuando se produzca un cambio.

Y éstos en el programa del PC (vb.net) para reconstruir el pasado:

• Leer los registros en un intervalo de tiempo.
• Decodificarlos a binario para poder ver cada I/O por separado.
• Mostrar en una tabla los cambios y el momento.
• Mostrar gráficamente estos estados.

Programa de PLC.

Lógicamente tendremos que declarar las entradas/salidas y dos variables que guardarán el estado de las I/0 en formato INT.

El resto del programa es asignar las entradas a la variable EstadoIn y las salidas a la variable EstadoOut. Para extraer un bit de una palabra basta con poner un “.” Y el número de bit. Por ejemplo Var.2 es el bit 2 de la variable Var.

Y esta es la función que convierte valores INT ó UINT a binario. Mediante esta función podremos obtener el estado de un bit, guardar grupos de valores binarios en un valor INT, etc.

La figura muestra el cálculo necesario. Consiste en dividir entre dos mientras el resto sea mayor de uno. Los bit serán los cociente.

Y esta es la función:

A esta función le entregamos un valor INT o UINT y nos devuelve un texto con el valor en binario 16 bit. Más tarde haremos otra función que usando esta nos devuelva el valor (TRUE/FALSE) de un bit.

INT vs UINT.

Los valores INT van desde -32767 hasta + 32767. O lo que es lo mismo, un valor de 15 bit (2 ^ 15) y un bit para el signo. Los valores UINT van desde 0 hasta 65536 y no existen valores negativos (2^16). Cuando leemos una variable del PLC desde vb.net u otro programa, no sabemos cómo se declaró en el PLC , leemos los bits y lo reconstruimos a INT o UINT. Por lo tanto podemos tener valores en el plc declarados como INT y en el PC reconstruidos como UINT. También podemos convertir valores UINT a INT.

Bien, en la primera parte de la función comprobamos si el valor es negativo, en ese caso sabemos con seguridad que es INT y lo convertimos a UINT para descomponerlo en bit. En los casos que sea positivo, no hay diferencias entre los dos tipos a la hora de convertirlos a bits.

Una vez hecho esto lo que hacemos es dividir entre dos el valor entregado en un bucle While End While. Este bucle se repite hasta que se cumple la condición de que el cociente sea < 1.

Mientras hacemos el bucle se almacenan los valores en una matriz de caracteres que contendrá 1 ó 0. Una vez terminado el bucle se convierte en una cadena de texto. Al pasarlo a cadena de texto rellenamos los valores vacíos con 0 hasta completar los 16 bits.

Esta misma función la utilizaremos para realizar otras tareas, como saber el estado de un bit (TRUE/FALSE).

En la próxima entrada realizaré el programa completo de registrar en el PC, cuando se produzca un cambio.

En este proyecto añadiremos una mejora. Vamos a crear un control de usuario con el botón conectar. En otras palabras, construimos un botón con funcionalidad añadida. En nuestro caso el código necesario para conectarse al PLC. Si la conexión se realiza con éxito pondrá a true una variable pública de manera que podamos consultar el estado de la conexión. Si estamos conectados al PLC, el botón pasara a hacer la función de desconexión.

En este caso, dejaré el proyecto para descargar y me centro en explicar las funciones.

Una de las ventajas que debemos de aprovechar de vb.net es la llamada POO (programación orientada a objetos) aunque en un principio la utilizaremos de una forma muy rudimentaria, puesto que esto tiene muchas posibilidades y por lo tanto puede llegar a ser compleja. Empezaremos por crear pequeños controles reutilizables que nos ahorren algo de trabajo. Nuestro primer control será un botón que haga la función de conectar al PLC.

Vamos a agregar un control de usuarios, como muestra la siguiente imagen.

El control le pondremos ucBuConectar y agregar.

Dentro del pequeño formulario introducimos un botón y le cambiamos la propiedad Dock a Fill (El botón del centro) y el Text a Conectar. Reducimos el tamaño del formulario al ancho y largo del Boton, y pinchamos con el derecho ver código.

En el código crearemos unas propiedades que vendrían a ser como variables IN/OUT de los FB en programación del PLC. Para crear este código podemos utilizar una función del IDE que nos ahorra trabajo y nos ayuda con la memoria.

Seleccionamos Insertar fragmento de código del menú contextual que aparece al pinchar con el derecho el área de código.

Una vez seleccionado el código que queremos utilizar los escribirá por nosotros. Las áreas resaltadas en verde tienen ciertas características especiales. Las propiedades tienen dos variables, una que se utiliza dentro del control y otra pública que será accesible desde fuera del control. Podemos llamar a ambas variables con el mismo nombre al que añadimos algo para modificarlo, en mi caso la variable interna tendrá un carácter de subrayado ” _Var” y la pública, no ” Var”.

Los pasos son: modificar la variable interna, pulsamos tabulador y modificamos el tipo, en este caso boolean:

Y ahora modificamos la variable pública y tabulador. Automáticamente se modifica el resto de código y ya tenemos la propiedad lista para usarla.

Este control utilizará el evento del botón para conectarse al PLC. Hacemos doble click en el botón y escribimos el siguiente código:

El proyecto en detalle:

Cuando se inicia la aplicación se cargan los datos de la conexión en el control ucBuConectar.

Bien, cuando el usuario pulsa el botón, éste se conectará al PLC y activa un temporizador, como podemos ver en el código del ucBuConectar, en esta línea:

Form1.TimerRuntime.Enable = TRUE

Trascurrido el tiempo definido en las propiedades de el control Timer el programa se dirige hasta el siguiente evento:

De esta manera emulamos el funcionamiento de un PLC en el PC, creando una tarea repetitiva que actualiza el valor de las variables del PLC y demás tareas repetitivas que necesite nuestra aplicación. Cuando pasa por la función LeerUINT se dirige a esta función, que leerá las variables para almacenarlas en la variable global Valor. Cuando queramos consultar el valor de estas variables simplemente valor = Valor(numero de marca).

En el primer paso por el código, se inicializa las variables MemoIn y MemoOut con los valores de las variables del plc, y ponemos ConfInicial a True para que no vuelva a entrar. Lo siguiente es comprobar si ha cambiado el valor de las entradas o salidas, de ser así lo muestra en la texbox, que hemos llamado tbTrace y llama a la función Grabar.

Y tan fácil como el siguiente código para grabar un log.

Y éste es el resultado:

Naturalmente esto no tiene sentido para nosotros, y necesitaremos otra aplicación para convertir estos datos en una tabla, y un gráfico que nos ayude a visualizar de una forma comprensible esta información.

Desde aquí podéis descargar el proyecto PLC y PC. Os recuerdo que el este archivo se encuentra en el área de descarga del foro de Infoplc. Por lo tanto será necesario estar registrado para poder descargarlo. De todas formas, si alguien  no quiere registrarse solo tiene que escribir un comentario con su dirección correcta y os lo enviaré.

En la próxima entrada veremos como reconstruir estos datos para mostrarlos en una tabla y en un gráfico. Bueno, no sé si en la próxima o en las próximas.

Capturando excepciones.

Como decíamos en el anterior post, tenemos un superinformático en el PC, también conocido como Framewoks y al que cariñosamente llamamos Marcos. También, decíamos que era capaz de saber si lo que le pedíamos en el código era lógico o imposible de realizar. Bueno pues hay una forma de establecer un diálogo con Marcos, de manera que nos informe de errores para buscar un camino alternativo y que la aplicación siga funcionando.

La estructura es la siguiente:

Try
'Aqui el codigo que queremos que supervise
Catch ex As Exception
'Aquí el codigo alternativo por si falla el anterior
End Try

Cuando Marcos  lee la palabra Try sabe que tiene que estar atento, en caso de producirse un error: error de comunicación, salirse de los índices de una matriz, etc; abandona el código que está leyendo, guarda el nombre del error en la variable ex y continúa leyendo el código  situado debajo de Catch.

Trabajando con consola. Un ejemplo de excepción.

Este tipo de aplicaciones están muy bien para hacer pruebas puesto que nos permite olvidarnos de la interface gráfica.

Crea una nueva aplicación y haz doble click sobre aplicación de consola. Copia y pega el siguiente código. Y dale al play. Cuando te pide un numero prueba a introducir una letra.

1: 'Pedimos un numero'
Console.WriteLine("Introduce un numero?")
'Inicializamos una variable de tipo integer'
Dim Respuesta As Integer
Try
'Cogemos el valor introducido y lo volcamos a la variable Respuesta'
Respuesta = Console.ReadLine()
'Le damos animos al usario por que sabe lo que es un numero'
Console.WriteLine("Bien, bien")
Catch ex As Exception
'Recogemos la excepción en caso de que el usuario sea un negao'
Console.WriteLine("Que nohhhhh. ¡Un numero!")
End Try
Console.WriteLine("Escribe 1 para continuar")
'vemos lo que ha escrito si es uno se va a la etiqueta 1: al principio del programa'
If Console.ReadLine = 1 Then
GoTo 1
Else
'en caso de no ser 1 salimos del programa'
Console.WriteLine("Pulsa intro para salir")
Console.Read()
End If

Depurando.

Los BreakPoint.

El IDE tiene algunas funciones para poder depurar nuestra aplicación.

Si hacemos click en el área gris a la izquierda del código, aparece un punto rojo. Cuando se ejecute la aplicación se detendrá al llegar a ese punto. Esto nos permite conocer el valor de las variables en ese instante. O por ejemplo saber si el programa entró en esa línea.

Si pasamos el ratón por una variable nos mostrará su valor.

Tenemos varias ventanas para saber más. Por defecto se encuentran en la parte más inferior del IDE.

Si el IDE no muestra estas ventanas podemos activarlas desde la barra de herramientas.

Para que el programa se detenga donde se ha colocado el breakpoint, tenemos que haber introducido un valor no válido para una variable integer. Si introducimos un valor válido Marcos no leerá esa línea de código.

Si queremos que la aplicación no vuelva a parar en el punto hacemos click en el BreakPoint para borrarlo.

También podemos mover el punto donde está detenido el programa, por ejemplo para saltar o volver a cargar.

Con este código:

Debug.WriteLine(“El valor de la variable es “ & Valor)

podemos escribir en la ventana inmediato.

Vemos unos conceptos básicos y pronto pasaremos a hacer cositas. Podeis ir poniendo a punto el TwinCat.

Framework

Supongo que todos habréis oído esta palabra. Supongamos que metemos un súper informático en el PC, le decimos que de ahora en adelante se llamará framework 2.0 y que su trabajo será leer nuestro programa y traducirlo para que el sistema operativo sepa que tiene que hacer. Además, como somos unos gandules de cuidado, le decimos que se aprenda unas cuantas funciones para no hacerlas nosotros y que las haga el según lee el programa. Como pensamos que le va a sobrar tiempo, es un superinformatico, le decimos que valla diciéndole al SO (sistema operativo), el sitio que tiene que reservar para las variables. Como aún le sigue sobrando tiempo, si quiere seguir vivo tendrá que supervisar si lo que le pedimos es lógico y en caso de no serlo que nos avise (ya veremos cómo).

Un ejemplo:

Dim VarString AS String = "Casa"   'declaramos una variable de tipo cadena de texto'
Dim VarInt AS Integer
VarInt = VarString.Lenght

Bueno, pues en este ejemplo, le decimos al framework 2.0 de los coj…, oye  dile al SO que deje espacio en la RAM para una almacenar una variable de tipo cadena (un texto) y sitio para almacenar un valor Integer   (desde  -2.147.483.648 hasta  2.147.483.647). Oye, y  búscate la vida pero dime la longitud de la cadena almacenada en la variable VarString.

El framework que es muy obediente cargará 4 (numero de letras de casa) en VarInt.

Mientras, Framework  en nuestro PC y sus clones en otros PC`s, están liaos currando, los de Microsoft están creando otra generación de clones a los que le pondrán nombres como Framework 3.5, etc. Básicamente son lo mismo pero han aprendido a hacer mas cosas. De lo que se desprende que si hacemos un programa contando con Framework  como interprete no podremos hacer funcionar nuestro programa, si no esta en el PC. Si hacemos un programa contando con el Framewok 2.0 funcionara en un PC con el Framework 3.5 pero no al revés.

Otra ventaja del Framework, ademas de facilitar el trabajo, es que no necesitamos instalar el programa para que funcione. Simplemente hay que ejecutarlo.

Propiedades.

Básicamente, para hacer un programa para PC, hacemos una interface gráfica, arrastrando los controles al formulario, se dimensionan adecuadamente y se modifican las propiedades necesarias. Otra cosa importante es poner un nombre simbólico al control. En el anterior post, poníamos un button. El IDE, pone automáticamente el nombre Button1. Pero este nombre no nos dice nada. Podemos cambiar este nombre por otro que nos recuerde la función de este botón. Por ejemplo buHola.

En la barra de la derecha tenemos las propiedades. Si seleccionamos, el botón que incluimos en la anterior entrada, la barra  nos mostrará las propiedades de éste (la imagen superior). Como vemos hay una propiedad Name, aquí deberíamos poner un nombre con el tipo y la función . Por ejemplo podemos utilizar “bu” para los botones y la función ”Hola”. Quedaría así buHola.

Variables.

Declaración de variables.

'Generalmente declaramos una variable así:'
Dim VarINT As Integer
Dim VarString AS String
Dim VarDecimal AS Decimal
Dim VarINT AS Short
'Podemos asignar un valor a una variable:'
Dim VarInt As Integer = 7
Dim VarString AS String = "Los programadores somos unos frikis, pero no salimos en la tele"
'Para que una variable sea visible en otras clases de nuestra aplicación, por ejemplo en otro formulario diferente de donde se declaro, deberemos ponerla al principio de la clase, de esta manera:'
Public Shared VarInt AS Integer

Aquí os dejo un link con los Tipos de datos en Vb.net

Ámbito o visibilidad de una variable.

Dependiendo de donde declaramos las variables serán visibles en un lugar u otro.

Si declaramos una variable dentro del evento del botón del anterior post, esta variable solo será visible dentro de ese gestor de eventos. Si lo hacemos dentro de un bucle FOR NEXT, solo será visible dentro del bucle. Es igual que declarar una variable dentro de un FB en programación de PLC.  Con la diferencia que aquí tenemos al Framework, que sólo declara la variable cuando lee, esa parte de programa.

Como FrameWork es un nombre super feo que  además se puede traducir como Marco, lo podemos llamar Marcos.

Bueno, pues hacemos doble click sobre nuestra aplicación o le damos al play en el IDE y Marcos se pone a leer el programa. Lo primero que hace es leer lo que hay en el Formulario principal. Una cosa  Como…

Public Class Form1
Public Shared Valor As Integer
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Button1.Text = "Hola"
End Sub
End Class

Marcos, le dice al SO que deje espacio para una variable llamada Valor y se dice, a sí mismo, que dejará que otros formularios puedan leer esta variable (Public Shared). Aunque aquí no se ve, hay un código que ha generado el IDE donde le dice a Marcos que este atento por si alguien hace click sobre  el boton1. Bueno y llegamos y lo pulsamos. Entonces, Marcos, busca en el código algún sitio que ponga Handles Button1.Click (en realidad sabe donde está), lee hacia abajo y va haciendo lo que pone. Marcos le dice al SO que cambie el texto del buton por Hola y se encuentra con las palabras END SUB. Y dice Marcos, joer que fácil, bueno pues como diría Maira Gómez, Hasta aquí puedo leer. A seguir esperando, que paciencia, señor, ¡que paciencia!

Para empezar hay que descargar el software de la web de Microsoft desde aquí. Es la versión express que es gratuita pero da para hacer bastantes cosas. Tienes la posibilidad de instalar SQL express, pero yo lo que haga, lo haré con MySql que es una base de datos open source.

En la web podéis encontrar infinidad de tutoriales, manuales, etc. Yo particularmente recomiendo La biblia de Visual Basic 2008 y me parece casi imprescindible meterse un buen libro si no tienes experiencia en este software. La intención de lo que veamos aquí es dar a conocer las posibilidades que tenemos a nuestro alcance. Como dejaré el proyecto que veamos, no es necesario tener muchos conocimientos para ver las aplicaciones rular y entenderlas un poco. Otra cosa será hacer una aplicación real.

IDE.

Un IDE es un entorno de programación que ha sido empaquetado como un programa de aplicación, es decir, consiste en un editor de código, un compilador, un depurador y un constructor de interfaz gráfica (GUI). Los IDEs pueden ser aplicaciones por sí solas o pueden ser parte de aplicaciones existentes. El lenguaje Visual Basic, por ejemplo, puede ser usado dentro de las aplicaciones de Microsoft Office, lo que hace posible escribir sentencias Visual Basic en forma demacros para Microsoft Word.

Fuente: Wikipedia.

Programación dirigida por eventos.

En oposición a la programación en PLC que el programa se lee cíclicamente, en Vb.net el programa está dirigido por eventos y me explico:

Supongamos un programa básico. Un botón que al pulsarlo cambia el texto.

En primer lugar construimos la interfaz de usuario. Para ello en la barra de la izquierda tenemos los controles. Pinchamos en Button (marcado en azul) y lo desplazamos hasta la ventana Form1. Para este ejemplo ya hemos terminado la interface grafica.

Si pulsamos dos veces en el button se abre la ventana de código y nos sitúa el cursor en el gestor de eventos que hemos pulsado.

Cuando se carga el programa espera a que se produzca un evento para  ejecutar el código. Pero sólo ejecutará el código que se encuentra dentro del gestor de ese evento. En nuestro ejemplo es: