Browsed by
Category: C#

SonarQube

SonarQube

7 axesSonarQube is an open platform to manage code quality. As such, it covers the 7 axes of code quality.

For some time a technology that is very popular with Java developers, but Microsoft has been working hard with Sonar Source to support it, starting from the release of Visual Studio 2015 for the .NET platform. The result is a great free Code Analysis tool to clarify Technical Debt, but also to show that it is eliminated.

Below a webinar (Dutch) from Delta-N about SonarQube.

SonarQube Dashboard Example

Measuring light strength with a Netduino

Measuring light strength with a Netduino

Light sensor schemaMeasuring the light strength is pretty simple when you own a Netduino.

You only need a normal resistor and a Light Dependent Resistor (LDR) which should be connected to the Netduino as shown in the schema.

With these few lines of code you can read the value from the LDR.

This code will open the A0 analog input port and read the value from it.

It returns a value between 0 and 100. 0 means bright and 100 means dark. In this example the value is inverted, so 0 means dark and 100 means bright.

[code]
public static void ReadLightSensor()
{
int minValue = 0;
int maxValue = 100;
int lightingInterval = 15 * 60 * 1000;

// Open the analog port
var lightSensor = new SecretLabs.NETMF.Hardware.AnalogInput(Pins.GPIO_PIN_A0);

// Set the value range between 0 and 100
lightSensor.SetRange(minValue, maxValue);

while (true)
{
// Read the value and invert it: 0 = dark, 100 = bright
var lightSensorValue = maxValue – lightSensor.Read();

// Do something with the value

Thread.Sleep(lightingInterval);
}
}
[/code]

If you show the measured values in a chart it will look like this:
Light strength chart

Netduino plus 2: First steps

Netduino plus 2: First steps

NetduinoI while ago I bought a Netduino plus 2. This open-source electronics prototyping platform is based on the .Net Micro Framework. The advantage of the plus 2 is, the presence of a network connection. This  connection makes it possible to connect the Netduino to the internet.

After setting up the development environment (Visual C# 2010, .Net Micro Framework, .Net Micro Framework Toolbox and Netduino SDK) to programming can start.

Netduino Plus 2

In this post I will show some code I used for my first steps into progamming the Netduino. The program will use the on-board button and LED.  When the button is pressed, a URL will be called and when the response from the URL is ok, the LED will blink.

This is the C# code which will run on the Netduino

[code]

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.NetduinoPlus;
using Toolbox.NETMF.NET;

namespace ButtonPress
{
public class Program
{
private const string _Server = "example.com";

public static void Main()
{
// Initialize onboard LED
var led = new OutputPort(Pins.ONBOARD_LED, false);

// Initialize onboard button
var button = new InputPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled);

while (true)
{
// Read button state
var buttonPressed = button.Read();

// If the button was pressed, send info to URL
if (buttonPressed)
{
// Send information
var ack = SendInformation2Url();

// If send was ok, blink LED once
if (ack)
{
BlinkLED(led, 1);
}
else // otherwise blink LED 3 times
{
BlinkLED(led, 3);
}
}
}
}
}
[/code]

Code for calling a URL

[code]
// Send information to URL
private static bool SendInformation2Url()
{
var result = false;

var socket = new IntegratedSocket(_Server, 80);
var session = new HTTP_Client(socket);

var response = session.Get("/buttonpress.php");
if (response.ResponseCode == 200)
{
result = true;
}

return result;
}
[/code]

The code for blinking the LED

[code]
// Blink the LED
private static void BlinkLED(OutputPort led, int count)
{
for (int i = 0; i < count; i++)
{
led.Write(true);
Thread.Sleep(250);
led.Write(false);
Thread.Sleep(250);
}
}
[/code]

This is the code behind the buttonpress.php:

[code]
<?php
$fp = fopen(‘buttonspress.log’, ‘a’);
fprintf($fp, "%s: button was pressed\n", date(‘Y-m-d H:i:s’));
fclose($fp);
?>
[/code]

This is all the code you need for reading the on-board button state, calling a URL and letting the on-board LED blink.

Generate XML-file from your internal data

Generate XML-file from your internal data

Are you a .Net programmer and ever wanted to write your internal data to an XML-file without wanting to do the writing yourself? Well here’s some example code which can be useful for you.

First some classes representing the internal data.

[csharp]
using System.Collections.ObjectModel;

namespace XmlSerializer
{
public class DataContainer
{
public JustSomeData Data1;
public Collection Data2;
}
}
[/csharp]
[csharp]
namespace XmlSerializer
{
public class SomeMoreData
{
public long Id;
public string Name;
public int Age;
}
}
[/csharp]

The internal data will be written to a XML-file using the XmlSerializer. The following code shows a method which will initialize the internal data and will write this data to a XML-file.

[csharp highlight=”41,42-51″]
private void ShowXmlSerialization()
{
#region Init

// Main data
var dataContainer = new DataContainer();
dataContainer.Data2 = new Collection<SomeMoreData>();

#endregion Init

#region Generate some data

// Just some data
var justSomeData = new JustSomeData()
{
Id = 1,
Code = "Demo",
Description = "Just some demo data"
};

// Add it to the main data
dataContainer.Data1 = justSomeData;

// Some more data
dataContainer.Data2.Clear();
for (int i = 1; i <= 5; i++)
{
var someMoreData = new SomeMoreData();

someMoreData.Id = i;
someMoreData.Name = string.Format("Name {0}", i);
someMoreData.Age = i * 3 + i * 10;

dataContainer.Data2.Add(someMoreData);
}

#endregion Generate some data

#region Serialize

// Serialize the data
var serializer = new System.Xml.Serialization.XmlSerializer(dataContainer.GetType());

#endregion Serialize

#region Write to file

// Write it to file
var filename = "JustSomeData.xml";
Stream writer = new FileStream(filename, FileMode.Create);
serializer.Serialize(writer, dataContainer);

#endregion Write to file
}
[/csharp]

The generated XML-file will look like:

[xml]
<?xml version="1.0"?>
<DataContainer xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Data1>
<Id>1</Id>
<Code>Demo</Code>
<Description>Just some demo data</Description>
</Data1>
<Data2>
<SomeMoreData>
<Id>1</Id>
<Name>Name 1</Name>
<Age>13</Age>
</SomeMoreData>
<SomeMoreData>
<Id>2</Id>
<Name>Name 2</Name>
<Age>26</Age>
</SomeMoreData>
<SomeMoreData>
<Id>3</Id>
<Name>Name 3</Name>
<Age>39</Age>
</SomeMoreData>
<SomeMoreData>
<Id>4</Id>
<Name>Name 4</Name>
<Age>52</Age>
</SomeMoreData>
<SomeMoreData>
<Id>5</Id>
<Name>Name 5</Name>
<Age>65</Age>
</SomeMoreData>
</Data2>
</DataContainer>
[/xml]