[C#] Inkomende json omzetten in array

[sunlight78]

Beste mensen,

Al enige tijd ben ik op zoek naar een manier om een json welke ik krijg uit een arduino om te zetten naar eenn array om status van iedere uitgang uit te lezen.

Op dit moment krijg ik netjes alle waardes door alleen kan ik ze niet omzetten naar een array en uitlezen.

Kan iemand mij in de juiste richting duwen?

Mijn code welke de status ophaalt ui de arduino is:

C#:

void initializeUdpReceive()
{
    receivingUdpClient = new UdpClient(6000);
    try
    {
        receivingUdpClient.BeginReceive(new AsyncCallback(receive), null);
    }
    catch (Exception e)
    {
        MessageBox.Show(e.StackTrace);
        Console.WriteLine(e.ToString());
    }
}
        
private void receive(IAsyncResult result)
{
    receivingIpEndPoint = new IPEndPoint(IPAddress.Any, 6000);
    Byte[] receiveBytes = receivingUdpClient.EndReceive(result, ref receivingIpEndPoint);
    string returnData = Encoding.ASCII.GetString(receiveBytes);
    Console.WriteLine("This is the message you received " +
                                                 returnData.ToString());
    Console.WriteLine("This message was sent from " +
                                receivingIpEndPoint.Address.ToString() +
                                " on their port number " +
                                receivingIpEndPoint.Port.ToString());
    receivingUdpClient.BeginReceive(new AsyncCallback(receive), null);
}

Deze geeft onderstaande json als output.

JavaScript:

{
  "data": [
    {
      "type": "D",
      "nr": 10,
      "val": 1
    },
    {
      "type": "D",
      "nr": 11,
      "val": 0
    },
    {
      "type": "D",
      "nr": 12,
      "val": 0
    },
// ... meer
    {
      "nr": 50,
      "val": 13.5
    },
    {
      "nr": 51,
      "val": -127
    },
// ... meer
  ]
}

[ Voor 35% gewijzigd door RobIII op 19-10-2016 17:33 . Reden: Code/json leesbaar gemaakt ]

[Afvalzak]

Ik zou hier even naar kijken:
https://github.com/bblanchon/ArduinoJson
Volgens mij moet het dan wel goedkomen


Edit: oh wacht, je wilt vanuit een C# applicatie de JSON parsen?
Dan zou ik deze pakken: http://www.newtonsoft.com/json

[ Voor 35% gewijzigd door Afvalzak op 19-10-2016 16:06 ]

[sunlight78]

Afvalzak schreef op woensdag 19 oktober 2016 @ 16:05:
Ik zou hier even naar kijken:
https://github.com/bblanchon/ArduinoJson
Volgens mij moet het dan wel goedkomen


Edit: oh wacht, je wilt vanuit een C# applicatie de JSON parsen?
Dan zou ik deze pakken: http://www.newtonsoft.com/json

Hallo,

Dank voor je reactie. Ik heb mijn arduino helemaal werkend en ook de data welke ik op vraag krijg ik netjes binnen in het output scherm. Wat ik nu nog moet doen is omzetten naar een array in c# , maar wat ik ook probeer ik heb er tot nu toe weinig geluk mee. Ik ga eens naar de link kijken.

Bedankt

[RobIII]

Newtonsoft.Json is inderdaad 't makkelijkst. Gewoon de nuget package installeren in je project.

C#:

struct Message
{
    public Record[] Data { get; set; }
}

struct Record
{
    public string Type { get; set; }
    public int Nr { get; set; }
    public double Val { get; set; }
}

private void receive(IAsyncResult result)
{
    // ...
    // ... string uit bytes vissen etc.
    // ...

    var myObject = JsonConvert.DeserializeObject<Message>(returnData);
}

Zoiets.

[epic007]

Nog een andere tip ipv BeginReceive en EndReceive zou ik ReceiveAsync gebruiken icm async / await

https://msdn.microsoft.co...ceiveasync(v=vs.110).aspx

http://blog.stephencleary.com/2012/02/async-and-await.html

[ Voor 14% gewijzigd door epic007 op 19-10-2016 18:15 ]

[sunlight78]

dank je voor de duw in de goede richting. Ik ga er eens mee stoeien.

[sunlight78]

RobIII schreef op woensdag 19 oktober 2016 @ 17:58:
Newtonsoft.Json is inderdaad 't makkelijkst. Gewoon de nuget package installeren in je project.

C#:

struct Message
{
    public Record[] Data { get; set; }
}

struct Record
{
    public string Type { get; set; }
    public int Nr { get; set; }
    public double Val { get; set; }
}

private void receive(IAsyncResult result)
{
    // ...
    // ... string uit bytes vissen etc.
    // ...

    var myObject = JsonConvert.DeserializeObject<Message>(returnData);
}

Zoiets.

Gaan we mee aan de gang

[ Voor 91% gewijzigd door sunlight78 op 19-10-2016 21:30 ]

[RobIII]

sunlight78 schreef op woensdag 19 oktober 2016 @ 20:35:

Euh, wil je even je post op orde maken want hier is weinig van te maken

[ Voor 43% gewijzigd door RobIII op 19-10-2016 20:58 ]

[sunlight78]

hoe kan het dat ik geen code meer kan toevoegen??

[RobIII]

Omdat je de [quote] hebt vernacheld?
Zo werken code tags. En als je ergens een [quote] hebt staan moet je die met een [/quote] of [/] wel weer netjes sluiten

[sunlight78]

Nou komt er nog een vraag in me op, Is het nu handiger om alles in een array te plaatsen of om direct de waarde van een bepaalde uitgang aan een int te koppelen? Ik moet namelijk met de waarde een afbeelding wel of niet op het scherm laten tonen. Dus als de val van id 1 0 is is er geen afbeelding en als de val 1 is wel.

Voorheen deed ik dit met:
JSONArray jsondata = input.getJSONArray("data");
hltfillStatus = jsondata.getJSONObject(6).getInt("val");

Maar dat is in processing

Als ik nu
int test = (receiveBytes [10]);
Console.WriteLine(test);

probeer krijg ik een waarde die ik niet thuis kan brengen

[ Voor 12% gewijzigd door sunlight78 op 19-10-2016 22:27 ]

[RobIII]

Wiedes, dat is een ASCII waarde (om precies te zijn: van het 10e karakter uit de JSON string). Maar ik denk dat je even terug moet naar de basics want je hebt geen benul wat je aan 't doen bent (nofi).

Kijk nog eens goed naar RobIII in "\[C#] Inkomende json omzetten in array" en dan vooral naar wat er in myobject zit naderhand (gebruik de debugger!). De oplossing staat er gewoon bijna letterlijk.

[ Voor 54% gewijzigd door RobIII op 19-10-2016 22:32 ]

[sunlight78]

Ok, na lang zoeken doe ik het nu zo

double hltFillStatus = (myObject.Data[6].Val);
Console.WriteLine(hltFillStatus);

Krijg netjes de waarde dus dat werkt. Alleen nu is hltFillStatus natuurlijk alleen in deze methode te gebruiken en niet daarbuiten. Moet ik nu het object via een return naar buiten zetten of is hier ook weer een andere manier voor.

Inderdaad beginner maar probeer iets te leren

[RobIII]

sunlight78 schreef op donderdag 20 oktober 2016 @ 23:12:
Alleen nu is hltFillStatus natuurlijk alleen in deze methode te gebruiken en niet daarbuiten. Moet ik nu het object via een return naar buiten zetten of is hier ook weer een andere manier voor.

Er valt niets te returnen; "iemand" heeft initializeUdpReceive() aangeroepen en allang antwoord (nou ja, void) gehad. Aan wie wil je dan iets returnen?

Je zult een event moeten raisen en een eventlistener moeten gebruiken (hint: check je DM nog eens...) of je zult een callback moeten meegeven aan initializeUdpReceive() of middels een property van je klasse en die callback dan vervolgens weer aanroepen in receive().

Zoiets dus:

C#:

using Newtonsoft.Json;
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

class Program
{
    static void Main(string[] args)
    {
        // Set up a receiver
        var receiver = new MyReceiver(IPAddress.Any, 6000);
        
        // Listen for MessageReceived event
        receiver.MessageReceived += (s, e) =>
        {
            Console.WriteLine("Message from " + e.RemoteIPEndPoint.ToString());

            // Here we have the actual message in the eventargs (e)
            // ...Do something with e.Message
            Console.WriteLine("Data items: " + e.Message.Data.Length);
        };

        // Start our receiver listening
        receiver.BeginReceive();

        // Wait until a key is pressed
        Console.ReadKey();
    }
}

// Our custom UDP receiver
public class MyReceiver
{
    private UdpClient _udpclient;
    
    // Will be raised each time a JSON message is received
    public event EventHandler<MessageReceivedEventArgs> MessageReceived = delegate { };
    // Returns the IPEndpoint we're listening on
    public IPEndPoint IPEndPoint { get; private set; }

    // Constructor
    public MyReceiver(IPAddress address, int port)
        : this(new IPEndPoint(address, port)) { }

    // Alternate Constructor
    public MyReceiver(IPEndPoint ipEndPoint)
    {
        this.IPEndPoint = ipEndPoint;
        _udpclient = new UdpClient(this.IPEndPoint);
    }

    // Starts listener
    public void BeginReceive()
    {
        _udpclient.BeginReceive(new AsyncCallback(EndReceive), null);
    }

    // Callback for BeginReceive; invoked when data arrived
    private void EndReceive(IAsyncResult result)
    {
        // Get the received data and the remote endpoint it came from
        IPEndPoint remoteEP = null;
        var receiveBytes = _udpclient.EndReceive(result, ref remoteEP);

        // Convert received bytes to a string and while we're at it, decode the JSON to a Message object
        var msg = JsonConvert.DeserializeObject<Message>(Encoding.ASCII.GetString(receiveBytes));

        // Raise event
        MessageReceived(this, new MessageReceivedEventArgs(msg, remoteEP));
        
        // Listen for more and have ourselves invoked when we do... lather, rinse, repeat.
        _udpclient.BeginReceive(new AsyncCallback(EndReceive), null);
    }
}

// Represents the event raised whenever data (or "a message") was received
public class MessageReceivedEventArgs : EventArgs
{
    public Message Message { get; private set; }
    public IPEndPoint RemoteIPEndPoint { get; private set; }

    public MessageReceivedEventArgs(Message message, IPEndPoint remoteEp)
    {
        this.Message = message;
        this.RemoteIPEndPoint = remoteEp;
    }
}

// Datastructures representing the JSON data
public struct Message
{
    public Record[] Data { get; set; }
}

public struct Record
{
    public string Type { get; set; }
    public int Nr { get; set; }
    public double Val { get; set; }
}

Je kunt ook nog eens kijken naar async/await maar, gezien de manier waarop je nu bezig bent, lijkt me dat voorlopig nog even niet slim. Async/await heeft nogal de neiging om zich "als een olievlek" door je applicatie uit te breiden en dat betekent dus flink verbouwen / onderhoud (of je applicatie is nog niet veel verder dan bovenstaand...)

[ Voor 69% gewijzigd door RobIII op 21-10-2016 00:24 ]