Inicjalizacja komunikacji RS232 i Ethernet

0

Cześć,
mam taki problem, że w jednej funkcji muszę obsłużyć inicjalizację komunikacji RS232 i Ethernet oraz coś tam wysłać.
Problem polega na tym, że chcę inicjalizację przeprowadzić tylko raz więc użyłem warunku if, lecz dalsza część kodu odpowiedzialna za wysyłanie i odbiór nie widzi że komunikacja w ogóle była nawiązana i wyskakują błędy:

        public void ProcWatek()            // Procedura uruchamiana w watku
        {
            if (Inicjalizacja == 0)
            {
                isStop = true;
            }
            else
            {
                isStop = false;
            }
            
            String linia;
            String PortSzeregowy;
            String PortSzeregowyCaly;
            SerialPort serial;
            String Adres1;
            String Port1;
            TcpClient Klient1;
            NetworkStream Stream1;
            BinaryWriter SWrite;
            BinaryReader Sread;
            String message;


            if (Inicjalizacja == 0)
            {
                Console.Write("Podaj port szeregowy do otwarcia [1-10]: ");
                PortSzeregowy = Console.ReadLine();                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.
                PortSzeregowyCaly = "COM" + PortSzeregowy;

                SprawdzPortCOM(PortSzeregowy);

                while (string.IsNullOrEmpty(PortSzeregowy) || BladCOM == 1)
                {
                    Console.WriteLine("Podaj poprawny port szeregowy do otwarcia [1-10]: ");
                    PortSzeregowy = "COM" + Console.ReadLine();                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.
                    SprawdzPortCOM(PortSzeregowy);
                }

                serial = new SerialPort();//Deklaracja obiektu
                serial.PortName = PortSzeregowyCaly;//port w DEVKIT!
                serial.BaudRate = 115200;
                serial.Parity = Parity.None;
                serial.DataBits = 8;
                serial.StopBits = StopBits.One;
                serial.Handshake = Handshake.None;

                try
                {
                    serial.Open();//otwiera port
                }

                catch
                {
                    Console.WriteLine("Błąd otwarcia portu - Możliwe zajęcie.");
                    Console.WriteLine("\n");
                }

                Console.Write("Podaj adres IP serwera pomiarowego: ");      // Wypisz tekst w konsoli.
                Adres1 = Console.ReadLine();                         // Przypisz do zmiennej Adres1 odczytane dane z konsoli.
                SprawdzAdres1(Adres1);                                      // Sprwdź poprawność adresu IP serwera pomiarowego

                Console.Write("Podaj port serwera pomiarowego: ");          // Wypisz tekst w konsoli.
                Port1 = Console.ReadLine();                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.

                SprawdzPort1(Port1);                                        // Sprawdź poprawność danych zmiennej Port1.

                while (string.IsNullOrEmpty(Adres1) || BladIP1 == 1)
                {
                    Console.Write("\nPodaj poprawny adres IP serwera pomiarowego: ");    // Wypisz tekst w konsoli.
                    Adres1 = Console.ReadLine();                                         // Przypisz do zmiennej Adres1 odczytane dane z konsoli.
                    SprawdzAdres1(Adres1);                                               // Sprwdź poprawność adresu IP serwera pomiarowego.
                }

                while (string.IsNullOrEmpty(Port1) || BladPort1 == 1)
                {
                    Console.Write("\nPodaj poprawny port serwera pomiarowego: ");        // Wypisz tekst w konsoli.
                    Port1 = Console.ReadLine();                                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.
                    SprawdzPort1(Port1);                                                 // Sprawdź poprawność danych zmiennej Port1.
                }

                Console.Write("\n");                                        // Wypisz tekst w konsoli.

                Klient1 = new TcpClient();                        // Program łączy się do serwera jako klient 1.

                try
                {
                    BladOtwarciaEth = 0;
                    Klient1.Connect(IPAddress.Parse(Adres1), Port1i);           // Adres IP i port serwera do którego trzeba się podłączyć (pomiarowy).
                }

                catch (SocketException e)
                {
                    Console.WriteLine("Błąd inicjalizacji połączenia: \n");     // Wypisz tekst w konsoli. 
                    Console.WriteLine("SocketException: {0}", e);               // Wypisanie błędu w konsoli.
                    BladOtwarciaEth = 1;
                }

                while (BladOtwarciaEth == 1)
                {
                    Console.Write("Podaj poprawny adres IP serwera pomiarowego: ");      // Wypisz tekst w konsoli.
                    Adres1 = Console.ReadLine();                         // Przypisz do zmiennej Adres1 odczytane dane z konsoli.
                    SprawdzAdres1(Adres1);                                      // Sprwdź poprawność adresu IP serwera pomiarowego

                    Console.Write("Podaj poprawny port serwera pomiarowego: ");          // Wypisz tekst w konsoli.
                    Port1 = Console.ReadLine();                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.

                    SprawdzPort1(Port1);                                        // Sprawdź poprawność danych zmiennej Port1.

                    while (string.IsNullOrEmpty(Adres1) || BladIP1 == 1)
                    {
                        Console.Write("\nPodaj poprawny adres IP serwera pomiarowego: ");    // Wypisz tekst w konsoli.
                        Adres1 = Console.ReadLine();                                         // Przypisz do zmiennej Adres1 odczytane dane z konsoli.
                        SprawdzAdres1(Adres1);                                               // Sprwdź poprawność adresu IP serwera pomiarowego.
                    }

                    while (string.IsNullOrEmpty(Port1) || BladPort1 == 1)
                    {
                        Console.Write("\nPodaj poprawny port serwera pomiarowego: ");        // Wypisz tekst w konsoli.
                        Port1 = Console.ReadLine();                                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.
                        SprawdzPort1(Port1);                                                 // Sprawdź poprawność danych zmiennej Port1.
                    }

                    Console.Write("\n");                                        // Wypisz tekst w konsoli.                                   // Sprawdź poprawność danych zmiennej Port1.

                    try
                    {
                        Klient1.Connect(IPAddress.Parse(Adres1), Port1i);           // Adres IP i port serwera do którego trzeba się podłączyć (pomiarowy).
                        BladOtwarciaEth = 0;
                    }

                    catch (SocketException e)
                    {
                        Console.WriteLine("Błąd inicjalizacji połączenia: \n");     // Wypisz tekst w konsoli. 
                        Console.WriteLine("SocketException: {0}", e);               // Wypisanie błędu w konsoli.
                        BladOtwarciaEth = 1;
                    }
                }

                Stream1 = Klient1.GetStream();                // Pobranie strumienia - Klient 1.
                SWrite = new BinaryWriter(Stream1);            // Strumień zapisu nr 1.
                Sread = new BinaryReader(Stream1);             // Strumień odczytu nr 1.
            }

            while (!isStop)//dziala w petli
            {

                Thread.Sleep(500);

                try
                {
                    serial.WriteLine("U");//

                    linia = serial.ReadLine(); //odbior

                    Console.WriteLine("Odebrano napiecie: " + linia);

                    int wartosc = Int32.Parse(linia);

                    if (wartosc > 10)
                    {
                        message = "1";
                        SWrite.Write(Convert.ToByte(message));
                    }

                    if (wartosc < 10)
                    {
                        message = "2";
                        SWrite.Write(Convert.ToByte(message));
                    }

                    serial.WriteLine("I");// 

                    linia = serial.ReadLine(); //odbior

                    wartosc = Int32.Parse(linia);

                    if (wartosc > 5)
                    {
                        message = "11";
                        SWrite.Write(Convert.ToByte(message));
                    }

                    if (wartosc < 5)
                    {
                        message = "22";
                        SWrite.Write(Convert.ToByte(message));
                    }

                    Console.WriteLine("Odebrano natezenie: " + linia);
                }

                catch
                {
                   Console.WriteLine("Blad odbioru danych.");
                }
            }
            serial.Close();
        }

Błędy jakie się pojawiają to:

Error 1 Use of unassigned local variable 'serial' C:\Users\Marcin\Desktop\SCRLabCw5\DevKitWatekRs232Sterowanie\Program1.cs 228 17 DevKitWatekRs232Sterowanie
Error 2 Use of unassigned local variable 'SWrite' C:\Users\Marcin\Desktop\SCRLabCw5\DevKitWatekRs232Sterowanie\Program1.cs 193 29 DevKitWatekRs232Sterowanie

1

Nie wiem czemu używasz VS 2008, ale błąd wszystko mówi, co masz źle. U same góry masz deklaracje zmiennych serial i SWrite. Musisz przypisać im jakąś wartość zanim ich "użyjesz".

Zrób

SerialPort serial = new SerialPort();
BinaryWriter SWrite = new BinaryWriter();

Nie mam jak sprawdzić, czy konstruktory mają jakieś parametry. Musisz dostosować to pod siebie.

0

Tylko taka wersja współpracuje z systemem windows CE Embedded na module devkit na uczelni.

Został tylko taki błąd po wprowadzeniu drugiej linii w Twoim kodzie:

Error 1 'System.IO.BinaryWriter.BinaryWriter()' is inaccessible due to its protection level C:\Users\Marcin\Desktop\SCRLabCw5\DevKitWatekRs232Sterowanie\Program1.cs 50 39 DevKitWatekRs232Sterowanie

Dzięki!

0

To jest to o czym pisałem. BinaryWriter ma konstruktor, który przyjmuje jakieś parametry. Nie wiem jak to jest w starym .NET Framework pod VS 2008, ale u mnie pokazuje, że przyjmuyje Stream output. W twoim przypadku może zadziałać

BinaryWriter SWrite = new BinaryWriter(Stream1);

Twój Stream1 to NetworkStream.

0

Próbowałem w ten sposób, niestety wyskakuje błąd:

Error 1 Use of unassigned local variable 'Stream1' C:\Users\Marcin\Desktop\SCRLabCw5\DevKitWatekRs232Sterowanie\Program1.cs 50 56 DevKitWatekRs232Sterowanie

1

Wróć do pierwszej lekcji i dowiedz się czym jest deklaracja i inicjalizacja zmiennych. @AdamWox już ci o tym pisał w pierwszym poście.

0

Deklaracja to informacja dla kompilatora, że taka zmienna już istnieje.
Inicjalizacja to przypisanie wartości do zmiennej

Mógłbym prosić o pomoc bo w tym przypadku naprawdę mnie to przerasta.

0

Zasada jest taka sama. Patrz "punkt 1", błąd ten sam, rozwiązanie to samo. Masz NetworkStream Stream1, a musisz zrobić NetworkStream Stream1 = new NetworkStream(). Znając życie pewnie tutaj też trzeba coś podać jako parametr konstruktora, więc domyślam się, że wrócisz z błędem. Kombinuj, google'uj, poradź sobie ✌️

0

Straciłem wczoraj na te błędy 12 godzin więc już mi głowa paruje próbowałem co mogłem więc zwróciłem się po pomoc, a dostaję odpowiedź poradź sobie. No dobrze dzięki.

0

Wszystko to jest null

String linia;
String PortSzeregowy;
String PortSzeregowyCaly;
SerialPort serial;
String Adres1;
String Port1;
TcpClient Klient1;
NetworkStream Stream1;
BinaryWriter SWrite;
BinaryReader Sread;
String message;

Nie masz tam żadnych wartości. Jak chcesz żeby ci działało, jak nie masz zainicjalizowanych tych zmiennych? Jak BinaryWriter ma coś zapisać jak nie ma "strumienia" (Stream)? Jak NetworkStream ma coś odczytać jak nie ma obiektu Socket, z którego te dane przychodzą. Programowanie jeszcze nie doszło do takiego etapu, że wie co "podmiot liryczny" ma na myśli i sam sobie wszystko "dopisze". Musisz podać jakieś wartości tym zmiennym, bo inaczej ci to nie zadziała.

0

Celowo tak zrobiłem, ponieważ gdy były zadeklarowane i zainicjalizowane w warunku if wyskaiwały błędy w pętli while, że nie ma do nich dostępu. Po prostu chciałem uniknąć ponownego zestawiania połączenia co wywołanie tej funkcji. Stąd deklaracja przed warunkiem. Jeśli potrzebna jest inicjalizacja to chciałbym, aby była przeprowadzona w taki sposób by nie wykrzaczyło programu przed wejściem w warunek i nie było odnawiania bez potrzeby. Jeśli jest jakiś błąd w moim namyśle to przepraszam. Może tak się po prostu nie da.

Program jest tak napisany, że do pętli while przed inicjalizacją nie ma możliwości się dostać tylko kompilator tego nie rozumie.

1

No to jeszcze raz. Po tym ciągu deklaracji zmiennych masz IFA i dopiero w tym ifie inicjalizujesz zmienna serial. A jak program ci nie wejdzie w ten warunek, to później w pętli while próbujesz się odwołać do niezainicjalizowsnej zmiennej. To twoim zdaniem co się powinno tam zadziac?

0

Właśnie to jest sedno problemu, jak w minimalnym stopniu zainicjalizować zmienne, które są wymagane w pętli while, żeby program nie wykrzaczył się z powodu braku danych, które będą wysłane do zainicjowanych zmiennych dopiero w warunku if.

Program został tak napisany, że inicjalizacja zmiennych ma priorytet (pierwsze uruchomienie funkcji odpala warunek i całą inicjalizację, gdy skończy warunek będzie niespełniony i zostanie tylko pętla while, w której wszystkie zmienne będą już zainicjalizowane i można się do nich odwoływać)

Problem bardziej dotyczy komunikacji po Ethernecie, Swrite wymaga Strumień1 a Stumień1 pewnie Klienta1 (GetStream) i cała inicjalizacja wychodzi po za warunek if.

2

nie, problem polega na tym że nie ogarniesz podstaw. Zamiast deklarować te zmienne w funkcji to zadeklaruj je jako pola klasy.

0

Niestety mam wytyczne od doktora żeby komunikacja była w tej funkcji (deklaracja, inicjalizacja, komunikacja).

Nie jestem programistą po prostu dostałem takie zadanie na laboratorium i chciałem przeprowadzić jednorazową inicjalizację, jeśli się nie da to trudno.

Niestety jak dodam zmienne w klasie nad funkcją to są one jeszcze raz deklarowane, podejrzewam, że dalsza część programu za to odpowiada, uruchomiłem debugger i klasa Watek jest na nowo czytana:

    static void Main(string[] args)
    {
        Inicjalizacja = 0;

        var instance = new Watek();
        instance.ProcWatek();

        Inicjalizacja = 1;
        JuzOK = 1;
        Watek w1 = new Watek();//obiekt z procedura watku
        Thread t1 = null;//obiekt na watek. Na razie pusty!
        Console.WriteLine("Info:");
        Console.WriteLine("1-wlacza watek");
        Console.WriteLine("2-wylacza watek");
        Console.WriteLine("0-koniec programu");

        while (true)
        {
            zn = Console.ReadLine();//czyta klawisz

            if (zn == "0")//koniec programu
            {
                if ((t1 != null))
                { //sprawdzenie, czy watek juz nie dziala
                    Console.WriteLine("Watek ciagle działa!");
                    continue; //wraca na poczatek while
                }

                Console.WriteLine("Koniec pracy");

                break; //koniec
            }
            if (zn == "1")//wlacza watek
            {
                if ((t1 != null))
                { //sprawdzenie, czy watek juz nie dziala
                    Console.WriteLine("Watek juz działa!");
                    continue; //wraca na poczatek while
                }

                w1.isStop = false; //warunek dzialania watku
                t1 = new Thread(w1.ProcWatek); //obiekt watku
                t1.Start(); // uruchomienie w watku
                Console.WriteLine("Start watek");

            }
            if (zn == "2")//wylacza watek
            {
                if ((t1 == null))
                { //sprawdzenie, czy watek dziala
                    Console.WriteLine("Watek juz nie działa!");
                    continue; //wraca na poczatek while
                }
                w1.isStop = true;
                t1 = null;
                Console.WriteLine("Stop watek");
            }

        }
    }
0
bboylubsko napisał(a):

Właśnie to jest sedno problemu, jak w minimalnym stopniu zainicjalizować zmienne, które są wymagane w pętli while, żeby program nie wykrzaczył się z powodu braku danych, które będą wysłane do zainicjowanych zmiennych dopiero w warunku if.

Program został tak napisany, że inicjalizacja zmiennych ma priorytet (pierwsze uruchomienie funkcji odpala warunek i całą inicjalizację, gdy skończy warunek będzie niespełniony i zostanie tylko pętla while, w której wszystkie zmienne będą już zainicjalizowane i można się do nich odwoływać)

Problem bardziej dotyczy komunikacji po Ethernecie, Swrite wymaga Strumień1 a Stumień1 pewnie Klienta1 (GetStream) i cała inicjalizacja wychodzi po za warunek if.

Bosch, nawet nie mam siły, aby wypuktowac wszystkie herezje. W znajomości języka, w wyobrażaniu sobie działania kodu, w stawianiu załozeń (mikro-projektowaniu). Wziąłeś zadanie, które ciebie przerasta.

bboylubsko napisał(a):

Celowo tak zrobiłem, ponieważ gdy były zadeklarowane i zainicjalizowane w warunku if wyskaiwały błędy w pętli while, że nie ma do nich dostępu. Po prostu chciałem uniknąć ponownego zestawiania połączenia co wywołanie tej funkcji. Stąd deklaracja przed warunkiem. Jeśli potrzebna jest inicjalizacja to chciałbym, aby była przeprowadzona w taki sposób by nie wykrzaczyło programu przed wejściem w warunek i nie było odnawiania bez potrzeby. Jeśli jest jakiś błąd w moim namyśle to przepraszam. Może tak się po prostu nie da.

Program jest tak napisany, że do pętli while przed inicjalizacją nie ma możliwości się dostać tylko kompilator tego nie rozumie.

Jak są zmiennymi w fukjci, to i tak lecą w powietrze, i w drugim wejsciu do niej ich znów nie ma (są null / puste).

Ale po co ja ci tłumaczę ...
Moze @johnny_Be_good się z tobą dogada

0
bboylubsko napisał(a):

Właśnie to jest sedno problemu, jak w minimalnym stopniu zainicjalizować zmienne, które są wymagane w pętli while, żeby program nie wykrzaczył się z powodu braku danych, które będą wysłane do zainicjowanych zmiennych dopiero w warunku if.

Program został tak napisany, że inicjalizacja zmiennych ma priorytet (pierwsze uruchomienie funkcji odpala warunek i całą inicjalizację, gdy skończy warunek będzie niespełniony i zostanie tylko pętla while, w której wszystkie zmienne będą już zainicjalizowane i można się do nich odwoływać)

Problem bardziej dotyczy komunikacji po Ethernecie, Swrite wymaga Strumień1 a Stumień1 pewnie Klienta1 (GetStream) i cała inicjalizacja wychodzi po za warunek if.

Bosch, nawet nie mam siły, aby wypuktowac wszystkie herezje. W rozumieniu jezyka, w wyobrażaniu sobie "jak to działa", w słownictwie, w stawianiu załozeń (mikro-projektowaniu)

bboylubsko napisał(a):

Celowo tak zrobiłem, ponieważ gdy były zadeklarowane i zainicjalizowane w warunku if wyskaiwały błędy w pętli while, że nie ma do nich dostępu. Po prostu chciałem uniknąć ponownego zestawiania połączenia co wywołanie tej funkcji. Stąd deklaracja przed warunkiem. Jeśli potrzebna jest inicjalizacja to chciałbym, aby była przeprowadzona w taki sposób by nie wykrzaczyło programu przed wejściem w warunek i nie było odnawiania bez potrzeby. Jeśli jest jakiś błąd w moim namyśle to przepraszam. Może tak się po prostu nie da.

Program jest tak napisany, że do pętli while przed inicjalizacją nie ma możliwości się dostać tylko kompilator tego nie rozumie.

Oczywiście winny jest głupi kompilator, który nie rozumie autora.

Twój stan rozpaczy najlepiej oddają komentarze (wybór)

bboylubsko napisał(a):
                 PortSzeregowy = Console.ReadLine();  // Przypisz do zmiennej Port1 odczytane dane z konsoli.

                serial = new SerialPort();//Deklaracja obiektu

Genialny fragment, nie będący komentarzem

                catch
                {
                    Console.WriteLine("Błąd otwarcia portu - Możliwe zajęcie.");
                    Console.WriteLine("\n");
                }
                Console.Write("Podaj adres IP serwera pomiarowego: ");      // Wypisz tekst w konsoli.
                Adres1 = Console.ReadLine();                         // Przypisz do zmiennej Adres1
                Console.Write("\n");                                        // Wypisz tekst w konsoli.
                Klient1 = new TcpClient();                        // Program łączy się do serwera jako klient 1.
0
bboylubsko napisał(a):

Niestety mam wytyczne od doktora żeby

Uczelnie są pełne sadystów.. Naczelny pro ... szeryf IV RP musi kazać szeregowym w tym wypadku ZROBIĆ dochodzenie

0

Gdzie masz deklaracje klasy/struktury Watek?

1

Udało się zrobić tak jak napisałem udostępniam kod, może ktoś skorzysta (profesjonalista pewnie zrobi to lepiej, ale cóż). Jak nie pasuje to proszę skasować mój wątek - nie jestem programistą:

using System;
using System.Threading;
using System.IO.Ports;
using System.Net.Sockets;
using System.Net;
using System.IO;

namespace JedenWatek
{
    class Program
    {
        static int BladIP1 = 0;
        static int BladPort1 = 0;
        static int Port1i = 0;
        static int BladCOM = 0;
        static int PortSzeregowyi = 0;
        static int BladOtwarciaEth = 0;
        static String zn;
        static int Inicjalizacja = 0;
        static int JuzOK = 0;

        class Watek        // Klasa z procedura watku
        {
            String linia;
            String PortSzeregowy;
            String PortSzeregowyCaly;
            String Adres1;
            String Port1;
            TcpClient Klient1;
            NetworkStream Stream1;
            SerialPort serial;
            BinaryWriter SWrite;
            BinaryReader Sread;
            String message;
            
            public bool isStop = false;

            public void ProcWatek()            // Procedura uruchamiana w watku
            {


                if (Inicjalizacja == 0)
                {
                    isStop = true;
                }
                else
                {
                    isStop = false;
                }

                if (Inicjalizacja == 0)
                {
                    Console.Write("Podaj port szeregowy do otwarcia [1-10]: ");
                    PortSzeregowy = Console.ReadLine();                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.
                    PortSzeregowyCaly = "COM" + PortSzeregowy;

                    SprawdzPortCOM(PortSzeregowy);

                    while (string.IsNullOrEmpty(PortSzeregowy) || BladCOM == 1)
                    {
                        Console.WriteLine("Podaj poprawny port szeregowy do otwarcia [1-10]: ");
                        PortSzeregowy = "COM" + Console.ReadLine();                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.
                        SprawdzPortCOM(PortSzeregowy);
                    }

                    serial = new SerialPort();//Deklaracja obiektu
                    serial.PortName = PortSzeregowyCaly;//port w DEVKIT!
                    serial.BaudRate = 115200;
                    serial.Parity = Parity.None;
                    serial.DataBits = 8;
                    serial.StopBits = StopBits.One;
                    serial.Handshake = Handshake.None;

                    try
                    {
                        serial.Open();//otwiera port
                    }

                    catch
                    {
                        Console.WriteLine("Błąd otwarcia portu - Możliwe zajęcie.");
                        Console.WriteLine("\n");
                    }

                    Console.Write("Podaj adres IP serwera pomiarowego: ");      // Wypisz tekst w konsoli.
                    Adres1 = Console.ReadLine();                         // Przypisz do zmiennej Adres1 odczytane dane z konsoli.
                    SprawdzAdres1(Adres1);                                      // Sprwdź poprawność adresu IP serwera pomiarowego

                    Console.Write("Podaj port serwera pomiarowego: ");          // Wypisz tekst w konsoli.
                    Port1 = Console.ReadLine();                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.

                    SprawdzPort1(Port1);                                        // Sprawdź poprawność danych zmiennej Port1.

                    while (string.IsNullOrEmpty(Adres1) || BladIP1 == 1)
                    {
                        Console.Write("\nPodaj poprawny adres IP serwera pomiarowego: ");    // Wypisz tekst w konsoli.
                        Adres1 = Console.ReadLine();                                         // Przypisz do zmiennej Adres1 odczytane dane z konsoli.
                        SprawdzAdres1(Adres1);                                               // Sprwdź poprawność adresu IP serwera pomiarowego.
                    }

                    while (string.IsNullOrEmpty(Port1) || BladPort1 == 1)
                    {
                        Console.Write("\nPodaj poprawny port serwera pomiarowego: ");        // Wypisz tekst w konsoli.
                        Port1 = Console.ReadLine();                                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.
                        SprawdzPort1(Port1);                                                 // Sprawdź poprawność danych zmiennej Port1.
                    }

                    Console.Write("\n");                                        // Wypisz tekst w konsoli.

                    Klient1 = new TcpClient();                        // Program łączy się do serwera jako klient 1.

                    try
                    {
                        BladOtwarciaEth = 0;
                        Klient1.Connect(IPAddress.Parse(Adres1), Port1i);           // Adres IP i port serwera do którego trzeba się podłączyć (pomiarowy).
                    }

                    catch (SocketException e)
                    {
                        Console.WriteLine("Błąd inicjalizacji połączenia: \n");     // Wypisz tekst w konsoli. 
                        Console.WriteLine("SocketException: {0}", e);               // Wypisanie błędu w konsoli.
                        BladOtwarciaEth = 1;
                    }

                    while (BladOtwarciaEth == 1)
                    {
                        Console.Write("Podaj poprawny adres IP serwera pomiarowego: ");      // Wypisz tekst w konsoli.
                        Adres1 = Console.ReadLine();                         // Przypisz do zmiennej Adres1 odczytane dane z konsoli.
                        SprawdzAdres1(Adres1);                                      // Sprwdź poprawność adresu IP serwera pomiarowego

                        Console.Write("Podaj poprawny port serwera pomiarowego: ");          // Wypisz tekst w konsoli.
                        Port1 = Console.ReadLine();                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.

                        SprawdzPort1(Port1);                                        // Sprawdź poprawność danych zmiennej Port1.

                        while (string.IsNullOrEmpty(Adres1) || BladIP1 == 1)
                        {
                            Console.Write("\nPodaj poprawny adres IP serwera pomiarowego: ");    // Wypisz tekst w konsoli.
                            Adres1 = Console.ReadLine();                                         // Przypisz do zmiennej Adres1 odczytane dane z konsoli.
                            SprawdzAdres1(Adres1);                                               // Sprwdź poprawność adresu IP serwera pomiarowego.
                        }

                        while (string.IsNullOrEmpty(Port1) || BladPort1 == 1)
                        {
                            Console.Write("\nPodaj poprawny port serwera pomiarowego: ");        // Wypisz tekst w konsoli.
                            Port1 = Console.ReadLine();                                          // Przypisz do zmiennej Port1 odczytane dane z konsoli.
                            SprawdzPort1(Port1);                                                 // Sprawdź poprawność danych zmiennej Port1.
                        }

                        Console.Write("\n");                                        // Wypisz tekst w konsoli.                                   // Sprawdź poprawność danych zmiennej Port1.

                        try
                        {
                            Klient1.Connect(IPAddress.Parse(Adres1), Port1i);           // Adres IP i port serwera do którego trzeba się podłączyć (pomiarowy).
                            BladOtwarciaEth = 0;
                        }

                        catch (SocketException e)
                        {
                            Console.WriteLine("Błąd inicjalizacji połączenia: \n");     // Wypisz tekst w konsoli. 
                            Console.WriteLine("SocketException: {0}", e);               // Wypisanie błędu w konsoli.
                            BladOtwarciaEth = 1;
                        }
                    }

                    Stream1 = Klient1.GetStream();                // Pobranie strumienia - Klient 1.
                    SWrite = new BinaryWriter(Stream1);            // Strumień zapisu nr 1.
                    Sread = new BinaryReader(Stream1);             // Strumień odczytu nr 1.
                    Inicjalizacja = 1;
                }

                while (!isStop)//dziala w petli
                {
                    Thread.Sleep(500);

                    try
                    {
                        serial.WriteLine("U");

                        linia = serial.ReadLine();

                        Console.WriteLine("Odebrano napięcie: " + linia);

                        int wartosc = Int32.Parse(linia);

                        if (wartosc > 10)
                        {
                            message = "1";
                            SWrite.Write(Convert.ToByte(message));
                        }

                        if (wartosc < 10)
                        {
                            message = "2";
                            SWrite.Write(Convert.ToByte(message));
                        }

                        serial.WriteLine("I");

                        linia = serial.ReadLine();

                        wartosc = Int32.Parse(linia);


                        if (wartosc > 5)
                        {
                            message = "11";
                            SWrite.Write(Convert.ToByte(message));
                        }

                        if (wartosc < 5)
                        {
                            message = "22";
                            SWrite.Write(Convert.ToByte(message));
                        }

                        Console.WriteLine("Odebrano natężenie: " + linia);
                        Console.Write("\n");                                        // Wypisz tekst w konsoli.

                    }

                    catch
                    {
                       Console.WriteLine("Błąd odbioru danych.");
                    }

                }
                if (JuzOK == 1)
                {
                    serial.Close();
                }
            }


            /// <summary>
            /// Program glowny
            /// </summary>
            /// <param name="args"></param>
            /// 
            private static void SprawdzPortCOM(string PortSzeregowy)
            {
                try                                              // --Sprawdź możliwość konwersji--
                {
                    BladCOM = 0;                                 // Status błędu konwersji = 0 -> OK.
                    PortSzeregowyi = int.Parse(PortSzeregowy);   // Próba konewrsji zmiennej Port1 na typ int.

                    if (PortSzeregowyi < 1 || PortSzeregowyi > 10)
                    {
                        BladCOM = 1;                                 // Status błędu konwersji = 1 -> NOK.
                    }
                }

                catch                                            // --Błąd przy próbie konwersji--
                {
                    BladCOM = 1;                                 // Status błędu konwersji = 1 -> NOK.
                }
            }
        }



        private static void SprawdzAdres1(string ipAddress)
        {
            try                                                             // --Sprawdź możliwość konwersji--
            {
                BladIP1 = 0;                                                // Status błędu konwersji = 0 -> OK.
                IPAddress address = IPAddress.Parse(ipAddress);             // Próba konewrsji.
            }

            catch                                                           // --Błąd przy próbie konwersji--
            {
                BladIP1 = 1;                                                // Status błędu konwersji = 1 -> NOK.
            }
        }

        private static void SprawdzPort1(string Port1)
        {
            try                                              // --Sprawdź możliwość konwersji--
            {
                BladPort1 = 0;                               // Status błędu konwersji = 0 -> OK.
                Port1i = int.Parse(Port1);                   // Próba konewrsji zmiennej Port1 na typ int.
            }

            catch                                            // --Błąd przy próbie konwersji--
            {
                BladPort1 = 1;                               // Status błędu konwersji = 1 -> NOK.
            }
        }



        static void Main(string[] args)
        {
            Inicjalizacja = 0;
            Watek w1 = new Watek();//obiekt z procedura watku
            w1.ProcWatek();
            Thread t1 = null;//obiekt na watek. Na razie pusty!
            JuzOK = 1;

            Console.WriteLine("Info:");
            Console.WriteLine("1-wlacza watek");
            Console.WriteLine("2-wylacza watek");
            Console.WriteLine("0-koniec programu");

            while (true)
            {
                zn = Console.ReadLine();//czyta klawisz

                if (zn == "0")//koniec programu
                {
                    if ((t1 != null))
                    { //sprawdzenie, czy watek juz nie dziala
                        Console.WriteLine("Watek ciagle działa!");
                        continue; //wraca na poczatek while
                    }

                    Console.WriteLine("Koniec pracy");

                    break; //koniec
                }
                if (zn == "1")//wlacza watek
                {

                    if (Inicjalizacja == 0)
                    {
                        JuzOK = 0;
                        w1.ProcWatek();
                        JuzOK = 1;
                    }

                    if ((t1 != null))
                    { //sprawdzenie, czy watek juz nie dziala
                        Console.WriteLine("Watek juz działa!");
                        continue; //wraca na poczatek while
                    }

                    w1.isStop = false; //warunek dzialania watku
                    t1 = new Thread(w1.ProcWatek); //obiekt watku
                    t1.Start(); // uruchomienie w watku
                    Console.WriteLine("Start watek");
                }
                if (zn == "2")//wylacza watek
                {
                    if ((t1 == null))
                    { //sprawdzenie, czy watek dziala
                        Console.WriteLine("Watek juz nie działa!");
                        continue; //wraca na poczatek while
                    }
                    w1.isStop = true;
                    t1 = null;
                    Console.WriteLine("Stop watek");
                    Inicjalizacja = 0;
                }

            }
        }
    }
}

Jak ktoś chciałby pokazać swoje umiejętności programistyczne i udowodnić swoją wyższość nad mniej obeznanymi może to zrobić - cały kod jest dostępny.
Mi się udało w ten sposób - jak ktoś zrobi lepiej to będę miał na przyszłość wskazówkę jak robić bo programowanie jest ciekawe - lecz potrzeba czasu na zgłębienie pewnych zagadnień, którego po prostu na studiach nie mam. Nawet będę wdzięczny za wytknięcie błędów - zawsze coś co pcha do przodu.

Film prezentujący działanie programu:

0
  1. epoka piksela łupanego się skończyła
  2. visual studio 2008 jest przestarzałe
  3. embedded linux daje znacznie większe możliwości

polecam sprawdzić Yocto Linux

1 użytkowników online, w tym zalogowanych: 0, gości: 1