My Blog

API Management DTAP lessons learned

Sat, 04 Feb 2017 20:56:04 GMT

With API management we have seperate environments for Development, Test and Production.

The best way to move an API from one environment to the other is through GIT at this moment.

https://docs.microsoft.com/nl-nl/azure/api-management/api-management-configuration-repository-git

Visualize differences

After setting up the 3 GIT environments and cloning them locally

We use a 3 way merge tool (http://meldmerge.org) to display all 3 branches.

Best practices

Try to keep all files the same across all environments

Use properties for all Server URL's, (you need to set this from a policy through the set-backend-service expression, because the API ServerURL cannot contain properties at this moment yet (feb 2017)

Create a property "ENVIRONMENT" and use the "choose" policy expression to select parts of the policy you want to apply. This way all settings are always in GIT available. Future enhancement would be for instance use Azure Key Vault when it is supported by APIM. We use this for different ip-address restrictions on each environment.

Keep all GUIDS the same across all environments. You can change all guids on demand, except the "Product" guid, where all subscriptions are tied to. We even updated the default "group" guids (administrator, developer, guest) to be the same across all environments.

Properties can be exported through powershell.

Don't create new items in Production manually

Troubleshoot IIS Client Certificate issues

Sun, 11 Sep 2016 12:45:00 GMT

IIS has the option to require client certificates, but setting this up requires all settings to be set correctly.

The question

The customer question was that during a security audit, the server returned no root certificates, and not a list of trusted certificates. Error: No client certificate CA names sent

The command used: OpenSSL s_client -connect site.customer.com:443

A certificate trust list needs to be enabled

Investigating

The behavior to send the trusted issuer list by default is off in Server 2012 and newer. The default value of the SendTrustedIssuerList registry key is now 0 (off by default), instead of 1.

http://forums.iis.net/t/1223412.aspx?IIS+8+5+offers+all+client+certificates

HKLM\System\CurrentControlSet\Control\SecurityProviders\SCHANNEL\SendTrustedIssuerList = 1

https://technet.microsoft.com/en-au/library/dn786429.aspx

THere is a lot of false info regarding this on the internet, about "client certificate mapping" and "clientauthtrustmode"

NETSH HTTP SHOW SSLCERT

Should display a "Ctl store name" when configured correctly.

The solution

Enable "Negotiate client certificates" this will sent the list directly upon connecting

The real solution

The security requirement should be changed as well, displaying a list of trusted root certificates will help attackers, by adverstising what a valid certificate is.

A better security check would be that the security auditor test the connection with several valid certificates from different root CA's to validate that only the correct CA's are trusted.

Only checking what a server advertises is not a good idea.

Azure API management tips & tricks

Sun, 17 Apr 2016 19:20:27 GMT

Just some random notes on Azure API management:

Parse JWT in Azure API management policy:

@(context.Request.Headers.GetValueOrDefault("Authorization","").AsJwt()?.Subject)

API management and mobile services

http://giventocode.com/azure-api-management-and-azure-mobile-services#.VmFYAHldGpo

?$filter={filter}&$inlinecount={inlinecount}&$orderby={orderby}&$select={select}&$skip={skip}&$top={top}

Raspberry Pi and the dynamixel controller

Sat, 27 Apr 2013 12:55:00 GMT

Take a look at my new article about the Dynamixel servo's and how to control them from a Raspberry Pi without a CM controller

control-dynamixel-with-raspberrypi

Control Dynamixel AX-12 with NETMF

Sun, 01 Jan 2012 20:22:00 GMT

How to control multiple Robotis Dynamixel AX-12 from a .NET Micro Framework environment.

The first step is to wire everything up, we use port 0 and 1 for serial RX and TX, and digital port 2 for controlling the half duplex communication. For this we need an 74LS241, take a look at the setup:

http://robottini.altervista.org/dynamixel-ax-12a-and-arduino-how-to-use-the-serial-port

http://savageelectronics.blogspot.com/2011/01/arduino-y-dynamixel-ax-12.html

We need a 74LS241 connected this way:

Pin 2 to Pin 3 (data out to AX-12)
Pin 1 to Pin 19 (connected to Digital 2 on NETMF)
Pin 18 (connected to RX on NETMF)
Pin 17 (connected to TX on NETMF
Pin 10 to ground
Pin 20 to Vcc

The next step is controlling this from code, the TinyCLR wiki helps us a bit:

http://wiki.tinyclr.com/index.php?title=Dynamixel_AX12

Here is the code for initializing the serial port to 1.000.000 mbps:

SerialPort serial = new SerialPort("COM1", 1000000, Parity.None, 8, StopBits.One);
serial.ReadTimeout = 100;
serial.Open();

//fix the baud on COM1 to non-standard 1000000
Register U0FDR = new Register(0xE000C028);
U0FDR.Write((8 << 4) | 1);//fix the fractional divider register

AX12_PacketHandler AX12 = new AX12_PacketHandler(serial);
AX12.SetLimits(1, 205, 818);
AX12.move(1, 205);

Be sure to add references to:

Microsoft.SPOT.Hardware.SerialPorts
GHIElectronics.NETMF.Hardware (or other if you use another netmf board)
FEZPanda_GHIElectronics.NETMF.FEZ (or FEZ II or other)

And here is the library from TinyCLR, extended with some higher level functions:

using System;
using System.IO.Ports;
using Microsoft.SPOT;
using GHIElectronics.NETMF.Hardware.LowLevel;
using Microsoft.SPOT.Hardware;
using GHIElectronics.NETMF.FEZ;

namespace Dynamixel_AX12
{
    class AX12_PacketHandler
    {
        private SerialPort _ser;
        private byte[] _packet = new byte[20];
        public const byte BrodcastID = 0xfe;
        Register PINSEL0 = new Register(0xE002C000);
        OutputPort Direction_High;

        public enum Instruction : byte
        {
            AX_PING = 0x01,
            AX_READ_DATA = 0x02,
            AX_WRITE_DATA = 0x03,
            AX_REG_WRITE = 0x04,
            AX_ACTION = 0x05,
            AX_RESET = 0x06,
            AX_SYNC_WRITE = 0x83, 
        }

        public enum Address : byte
        {
            AX_ID = 0x01,
            AX_CW_LIMIT = 0x06,
            AX_CCW_LIMIT = 0x08,
            AX_LED = 0x19,
        }

        public AX12_PacketHandler(SerialPort ser)
        {
            if (ser.PortName != "COM1")
                throw new Exception("Only COM1 is supported for now");

            Direction_High = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.Di2, false);

            _ser = ser;
        }

        private byte CalcCRC()
        {
            int len = _packet[3] + 2;
            byte crc = 0;
            for (int i = 2; i < len + 1; i++)
            {
                crc += _packet[i];
            }
            return (byte)(0xFF - crc);
        }

        public void Send(byte ID, Instruction ins, byte[] param)
        {
            int length = 0;
            if (param != null)
            {
                length = param.Length;
            }

            _packet[0] = 0xFF;
            _packet[1] = 0XFF;
            _packet[2] = ID;
            _packet[3] = (byte)(length + 2);//len
            _packet[4] = (byte)ins;

            for (int i = 5; i < length + 5; i++)
            {
                _packet[i] = param[i - 5];
            }    
            _packet[length+5] = CalcCRC();

            // enable UART0 TX pin
            Direction_High.Write(true);

            // send data
            _ser.Write(_packet, 0, length+6);
            //wait till all is sent
            while (_ser.BytesToWrite > 0)
                ;

            //discard echo on RX
            _ser.DiscardInBuffer();
            // disconnect UART TX pin
            Direction_High.Write(false);

            //the response is now coming back so you must read it
        }

        public void ReadResponse(out byte ID, out byte len, out byte error, byte[] parameters)
        {
            int temp = _ser.Read(_packet, 0, _packet.Length);
            if (temp < 5)
            {
                ID = 0;
                len = 0;
                error = 0xff;
                return;// throw new Exception("reading too soon?");
            }
            Debug.Print("OK");
            if (_packet[0] != 0xff || _packet[1] != 0xff)
                throw new Exception("Unexpected data");

            ID = _packet[2];
            len = (byte)(_packet[3] - 2);
            error = _packet[4]; // 16 = CRC error
            for (int i = 0; i < len; i++)
            {
                parameters[i] = _packet[5 + i];
            }
        }

        public byte move(byte ID, int value)
        {
            byte len, error;
            byte[] buf = { 0x1E, (byte)value, (byte)(value >> 8)};

            Send(ID, AX12_PacketHandler.Instruction.AX_WRITE_DATA, buf);
            //Thread.Sleep(100);
            ReadResponse(out ID, out len, out error, null);

            if (error != 0)
                Debug.Print("error: " + error);

            return error;
        }

        public byte ping(byte ID)
        {
            byte len,error;

            Send(ID, AX12_PacketHandler.Instruction.AX_PING, null);
            //Thread.Sleep(100);
            ReadResponse(out ID, out len, out error, null);

            return error;
        }

        public byte ReadLimits(byte ID, out int CW, out int CCW)
        {
            byte len, error;
            byte[] par = new byte[20];
            byte[] buf = { 0x06, 0x04 };
            Send(ID, AX12_PacketHandler.Instruction.AX_READ_DATA, buf);
            //Thread.Sleep(100);
            ReadResponse(out ID, out len, out error, par);

            CW = par[0] + (par[1] << 8);
            CCW = par[2] + (par[3] << 8);
            return error;
        }

        // 511 is halfway (150 degrees)
        // use 205, 818 as limits for 180 degrees (150-90 to 150+90)
        public byte SetLimits(byte ID,  int CW,  int CCW)
        {
            byte len, error;
            byte[] buf = { 0x06, (byte)CW, (byte)(CW >> 8), (byte)CCW, (byte)(CCW >> 8) };

            Send(ID, AX12_PacketHandler.Instruction.AX_WRITE_DATA, buf);
            //Thread.Sleep(100);
            ReadResponse(out ID, out len, out error, null);

            return error;
        }
    }
}

Create BSB files for your KAP sea charts

Mon, 19 Dec 2011 20:25:00 GMT

Some sea charts are just released as KAP files, without the accompanying BSB file. If you run into problems importing the KAP files, there is a way to generate the BSB files.

For example, these New Zealand maps: http://mce66.altervista.org/software.html#Free_Nautical_Raster_Maps are without the BSB files. The KAP files are generated with the MapCal tools (http://www.dacust.com/inlandwaters/mapcal/) and the original New Zealand DIR file is also on the website.

From the MapCal site, download the MC2BSBH tool and run it on the directory with the KAP files. A BSB file is generated for every KAP file.

MC2BSBH chartcal.DIR -e BSB

Normally a BSB file can contain multiple references to KAP files (e.g. detail charts) but I still have to figure that out.

Analysis of sailboat electronics

Sat, 26 Nov 2011 20:25:00 GMT

What would be the ideal high end sailboat instrument system so let’s have a look at the components we need (not yet thinking about how to integrate them all):

Some displays on the mast (20/20, triton?)
Speed/log/depth sensors (airmar?)
Wind speed and direction sensor
Compass
Heel and Pitch sensor
Central CPU
Barometer and temperature

So what are our options, for the displays not much, these have to be waterproof and daylight readable. The 20/20s are nice, and maybe add some new Triton displays to replace some analogue displays.

Airmar has lots of nice sensors for the speed and depth. Airmar DST800?

For the windspeed, maybe the Airmar PB200, we still need a seperate compass for more accuracy.

The last components are more expensive and more easily replaced by custom components. “Merlin” did a lot of work, check out his site at http://sailboatinstruments.blogspot.com/

Tilt compensated compasses are available for around 20-40 euro, instead of the 500+ euros for a Airmar H2183. The same for heel, pitch and barometer sensors, 600 euros each. A CPU to calculate everything is around 100 euro, the only thing we need is the software to calculate this and add a waterproof case.

In some future posts I’ll go into some more details for writing the software and the calculations which need to be done.

B and G Wind bearings replacement

Sat, 26 Nov 2011 09:00:00 GMT

The official B & G bearings for the wind angle and wind speed are quite expensive. Why not buy some 3rd party bearings for 10% of the original price.

Type: SFR2-5ZZ

These should match the 213 and 496 Masthead units for Brookes and Gatehouse.
B&G part numbers 213-10-004 and 213-10-038 (Contact me for more information, or just google the part number for a local shop).

Replacement is quite easy, remove the MHU from the mast, and there is one screw (secured behind a sticker) to remove to seperate the top and bottom parts. just replace the bearings and your windspeed sensor should work fine for a few more years.

For the 213 MHU, take a look at the picture above, the screws to open the unit are marked by the red arrows.

This is a pdf with all the different parts and their numbers.

For the 496 unit, check out the pictures below (Thanks to JanW).

Generating OSM tiles with Python to Windows Azure Blob storage

Sun, 21 Aug 2011 08:00:00 GMT

The concept is to generate the tiles for an OpenStreetMap or OpenSeaMap server published to Windows Azure. The advantage of Windows Azure Blob storage is that we can enable the CDN support (content delivery network) to send the tiles more quickly to the visitor.

Download winazurestorage.py and modify it in 3 places to hold your account keys and change the functions to use the real storage and not the development versions. Don’t change the CLOUD_BLOB_HOST value!

DEVSTORE_ACCOUNT=”youraccountname”
DEVSTORE _SECRET_KEY=”yoursecretkey”
Class BlobStorage, change the host to CLOUD_BLOB_HOST

Test winazurestorage.py by calling test.py.

Create a Windows Azure blob container (in this scenario named “testcontainer”)

edit “generate_tiles.py”

Add the following at the top:

from windowsazurestorage import *

find the function “def render_tiles” and at the last line after the im.save(tile_uri,’png256′) add:

blobs = BlobStorage()
name = str(z) + “/” + str(x) + “/” + str(y) + “.png”
blobs.put_blob(“testcontainer”, name, im.tostring(‘png256′), “image/png”)

Run generate_tiles.py and watch the tiles appear in your Azure Blob Storage

Domotica links

Wed, 17 Aug 2011 08:00:00 GMT

Hierbij wat links voor het meten van je energie verbruik (gas, water, electriciteit) met behulp van bijvoorbeeld een arduino.

http://www.enymate.nl/
http://www.hekkers.net/domotica/HowToMonitorGasUsage.aspx
http://bwired.nl/How_rfxcom.asp
http://blog.richard.parker.name/2009/02/09/reading-a-gas-meter-with-an-arduino-part-1/
http://www.currentcost.com/
http://www.efergy.com/
http://openenergymonitor.org/

Voor het gebruik van een CNY70 is deze link misschien handig, aangezien de CNY niet altijd even scherp “ziet”

http://www.aaamc.nl/softio/cny/

future posts

Thu, 14 Jul 2011 08:00:00 GMT

Here’s my todo list for writing articles about:

Importing buoys for openseamap.org
Importing lights for openseamap.org
Sailboat instruments system breakdown
Inexpensive Sailboat instrument system
B&G analysis
RepRap
Arduino / FEZ Panda II
and more…