ferdinandkeil.com

Archive for the ‘atmel’ tag

AVR Dragon mit avrdude nutzen

without comments

cmd_avrdude

Um den günstigen AVR Dragon Programmieradapter von Atmel mit dem verbreiteten, quelloffenen Tool avrdude nutzen zu können wird der libusb-win32 Treiber benötigt. Dieser lässt sich aufgrund der erforderlichen Signatur nicht ohne weiteres auf modernen Windows Systemen installieren. Abhilfe schafft hier das Tool Zadig. Einfach herunterladen, als Treiber libusb-win32 (v…) auswählen und auf Install Driver klicken. Fertig.

zadig_dialog

Written by Ferdinand

Juni 4th, 2015 at 23:34

Posted in Allgemein

Tagged with , , , , ,

Connect V-USB devices to the Internet with the TL-WR703N – Part 2

without comments

In the first part of this mini-series I established a basic communication between my device and the TL-WR703N. In this part I will request data from my device over USB and then push it to Cosm. Cosm is a service that can store and display sensor data, which is exactly what I want to do. Cosm recently became Xively (the third name-change in the history of the service…). The good news is, that the old API still works.

You can talk to Cosm over a REST API. I searched the web for a Lua implementation of this API and finally found some code by a guy named Shadock. To simplify usage I created a small Lua library:

-- save as 'luacosm.lua'

-- load libs
require("ltn12")
socket = require("socket")
http = require("socket.http")

-- cosm_put(apikey, feed, datastream, value)
-- Push's a value to the specified Cosm feed.
-- Has to be given an API-Key with the necessary permissions.
--
-- based on Shadock's code as published on
-- http://forum.micasaverde.com/index.php?topic=7396.0
function cosm_put(apikey, feed, datastream, value)
	local base_url = "http://api.cosm.com/v2/feeds/"
	local method = "PUT"

	local json_data = '{ "version":"1.0.0","datastreams":[ {"id":"' .. datastream .. '", "current_value":"' .. value .. '"}]}'
	local response_body = {}
	local response, status, header = http.request{
		method = method,
		url = base_url .. feed .. ".json",
		headers = {
			["Content-Type"] = "application/json",
			["Content-Length"] = string.len(json_data),
			["X-ApiKey"] = apikey
		},
		source = ltn12.source.string(json_data),
		sink = ltn12.sink.table(response_body)
	}
	return response, status, header
end

A short example shows how to use the library:

require("math")
require("luacosm")

local apikey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
local feedid = 123456
math.randomseed( os.time() )
local humidity = math.random(60, 80)
print("Humidity: " .. humidity .. "%relH")

local response, status, header = cosm_put(apikey, feedid, "Humidity", humidity)

To start sending data, you first have to create so called feed in Cosm. This gives you the feed ID. You also need your personal API key, which can also be found on the Cosm website. Then all that is left is pushing some data to your feed.
The code shown above runs on the firmware image Madox generated for the TL-WR703N. It ships with all necessary Lua libraries, so no need to compile anything.

After verifying that I can upload random data to Cosm, I still need to retrieve some real sensor readings from my device. Again I used V-USB and lualibusb1 to connect my device to the router. I adapted the script presented in the first part of the series for this purpose.

require("luacosm")

usb = require("libusb1")

PSCMD_STATUS =  1
PSCMD_ON =      2
PSCMD_OFF =     3

local apikey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
local feedid = 123456

local handle = usb.open_device_with_vid_pid(0x16C0, 0x05DC);
if ((usb.get_string_descriptor_ascii(handle, 1) ~= "www.ferdinandkeil.com")
	and (usb.get_string_descriptor_ascii(handle, 2) ~= "Humidor Steuerung")) then
	handle = nil;
end


if (handle~=nil) then
	print("Device successfully initialised!")
	
	local type = usb.LIBUSB_REQUEST_TYPE_VENDOR + usb.LIBUSB_RECIPIENT_DEVICE + usb.LIBUSB_ENDPOINT_IN
	local request = PSCMD_STATUS
	
	print("Request data from device...")
	local response = usb.control_transfer(handle, type, request, 0, 0, 8, 5000)
	
	local hi = string.byte(response, 2)
	local lo = string.byte(response, 1)
	local humidity = ( (hi*255) + lo ) / 100
	print("Measured Humidity: " .. humidity .. "%relH")

	print("Try to upload to Cosm...")
	local response, status, header = cosm_put(apikey, feedid, "Feuchtigkeit", humidity)
	print("Finished")
else
	print("Device initialisation failed!")
end

Now let’s go through some of the important parts of the code:

local handle = usb.open_device_with_vid_pid(0x16C0, 0x05DC);
if ((usb.get_string_descriptor_ascii(handle, 1) ~= "www.ferdinandkeil.com")
	and (usb.get_string_descriptor_ascii(handle, 2) ~= "Humidor Steuerung")) then
	handle = nil;
end

I still use the VID/PID supplied by Objective Development, but this time I tried to honour their license terms. They basically say you can use their VID/PID freely, but you have to give your device a unique descriptor. So I ask the device for its descriptor and only accept the one I have chosen for my device.

local hi = string.byte(response, 2)
local lo = string.byte(response, 1)
local humidity = ( (hi*255) + lo ) / 100

On the micro-controller side the humidity is a 16 bit value, so it is send as two bytes. On the router side I have to reassemble these two bytes into one value. That is done with the code shown above. string.byte(s, i) gives me the raw byte value for the i-th byte in string s. I then shift the high byte to the left (hi*255) and then add the low byte.
It took me some time to figure this one out, as I am accustomed to the way C handles data. But you can’t easily typecast variables in Lua, so you have to use some helper functions. Also there seems to be no shift operator, so you have to rely on multiplication and division.

Written by Ferdinand

August 7th, 2013 at 15:49

Humidor Steuerung – ein Hygrostat für die Zigarrenlagerung

with one comment

Vor mittlerweile fast drei Jahren habe ich auf dieser Seite die Schaltung für meinen Humidor Lüfter veröffentlicht. Die Schaltung entstand aus der Idee, die Luft im Humidor regelmäßig umzuwälzen um eine möglichst gleichmäßige Feuchtigkeitsverteilung zu erreichen. Die Schaltung funktioniert bis heute ohne Probleme – nachdem ich sie um eine Batterieüberwachung erweitert habe macht sie auch keine Akkus mehr kaputt. Aus der gleichen Zeit stammte die Idee ein digitales Hygrometer für die Zigarrenlagerung zu entwerfen.

IMG_0016-1600

Die erste Version der Humidor Steuerung

Die Idee blieb in der Planungsphase stecken, bis ich mir Anfang 2012 endlich einen Ruck gab das Ganze umzusetzen (auch bedingt durch den Fund passender LC-Displays in meiner Teile-Kiste). Daraus entstand die erste Version der Humidor Steuerung. Bei Jakob Kleinen’s Sammelbestellung im mikrocontroller.net Forum ließ ich zwei Platinen fertigen und baute sie anschließend auf. Bis auf einen kleinen Fehler bei der Beschaltung des Drehgebers lief die Steuerung ohne Problem. Aus einem Testprogramm entwickelte sich die Firmware mit allen nötigen Features. Meine Ergebnisse veröffentlichte ich im Zigarrenforum. Die positiven Kommentare dort ermutigten mich schließlich eine zweite, verbesserte Version zu entwerfen. Die möchte ich nun hier vorstellen.

humidor_controller_top 20121028_215039

Die neue, verbesserte Version

Die Steuerung ist letztlich ein Hygrostat mit integrierter Zeitschaltuhr um handelsübliche PC-Lüfter anzusteuern. Insgesamt stehen vier Lüfter-Kanäle zur Verfügung die unabhängig voneinander programmiert werden können. An den Sensor Anschluss können verschiedene Sensor-Typen angeschlossen werden, die Firmware erkennt den richtigen Typ dann automatisch. Nicht auf dem Bild zu sehen (weil auf der Rückseite) ist ein Summer, der bei unterschreiten einer eingestellten Feuchtigkeit Alarm gibt. Außerdem ist eine Alarm-LED integriert, die durch das Loch über dem Glock-Symbol scheint.

humidor_controller_v35_sch detail_luefter_kanal

Schaltplan und Beschaltung eines Lüfter-Kanals

Die Lüfter-Kanäle sind alle identisch aufgebaut. Der Summer ist an die 12V Versorgungsspannung angeschlossen und wird ähnlich wie die Lüfter geschaltet. Jeder Kanal verfügt über einen N-Kanal Schalt-MOSFET im SOT-23 Package. Mögliche Typen sind z.B. der IRLML2502 oder GF2304. Jeder Kanal kann mit mindestens 500mA belastet werden, damit kann die Schaltung nahezu alle erhältlichen Lüfter betreiben.
Zum Schutz des MOSFETs und zur Entstörung der Schaltung sind dem Lüfter eine Schutzdiode und eine Kondensator parallel geschaltet.

Die Steuerung kann über USB mit einer neuen Firmware geflasht werden. Dazu wurde der verbaute ATmega168 mit dem USBaspLoader programmiert. Um den Bootloader zu aktivieren muss der Drehgeber gedrückt werden wenn die Schaltung mit der Spannungsversorgung verbunden wird.

Die fertige Schaltung sitzt in einem Standard-Gehäuse wie eine Frontplatte. Es muss nur ein Loch für die Hohlstecker-Buchse gebohrt werden, die auf der Rückseite der Platine angeschlossen wird.

Das verwendete Display HMC16223SG ist leider nicht mehr erhältlich. Aufgrund seiner kleinen Abmessungen ist es perfekt für ein kompaktes Gerät geeignet. Einen adäquaten Ersatz konnte ich bisher nicht finden, die nächste Version wird wohl ein anderes Display verwenden.

Die Firmware für die Steuerung basiert auf meinem Taskmanager. Sie ist so weit wie möglich modular aufgebaut. Es wurde auch ein Menü-System verwendet, das auf dem Code des Butterfly GCC-Ports aufbaut.
Die Firmware um Funktionen für weitere Lüfterkanäle oder mehrere Sensoren zu erweitern, sollte kein Problem sein. Die aktuelle Firmware verbraucht ~10,5kB Flash, der Bootloader 4kB – es ist also noch Platz für Erweiterungen. Alternativ kann ein ATmega328 verbaut werden.

sensor_board_v10 20130320_133231-1600

Die Sensor-Platine: als 3D-Modell und fertig aufgebaut



Die Sensor-Platine ist mit folgenden Sensoren kompatibel:

Die Sensor-Platine wird mit 12V versorgt und hat einen lokalen Spannungsregler (LP2980-N), um Spannungsverluste über die Zuleitung sowie Störungen zu reduzieren.

Downloads

Die Firmware steht unter MIT Lizenz, die Hardware Quelldateien unter der TAPR Lizenz. Die Dateien sind hier zu finden:

Written by Ferdinand

März 20th, 2013 at 15:47