Schallschutz B16, östlich Weichering

Hier die offizielle Antwort des Staatlichen Bauamtes Ingolstadt zum Thema Schallschutz beim Ausbau der B16

Sehr geehrter Herr Schmidt,

vielen Dank für Ihre Anfrage vom 24.07.2016, in dem Sie den Lärmschutz beim Ausbau der B16 im Bereich Weichering ansprechen. Hierzu können wir Ihnen Folgendes mitteilen:

Nach Art. 74 Abs. 2 Bayer. Verwaltungsverfahrensgesetz (BayVwVfG) i.V. mit § 41 Abs. 1 Bundes-Immissionsschutzgesetz (BImSchG) ist beim Neubau von Straßen sicherzustellen, dass durch diese keine schädlichen Umwelteinwirkungen durch Verkehrsgeräusche hervorgerufen werden, die nach dem Stand der Technik vermeidbar sind. Aufgrund des § 43 Abs. 1 Nr. 1 BImSchG wurde die "16. Verordnung zur Durchführung des Bundes-Immissionsschutzgesetzes (Verkehrslärmschutzverordnung - 16. BImSchV)" erlassen, in der der Anwendungsbereich, die Immissionsgrenzwerte (IGW) und die Berechnung des Beurteilungspegels geregelt sind. Nach § 1 Abs. 1 der 16. BImSchV sind für den Neubau einer Bundesstraße die Grundsätze der Lärmvorsorge maßgebend. Die dabei einzuhaltenden IGW nach § 2 Abs. 1 der 16. BImSchV wurden für das Planfeststellungsverfahren zum dreistreifigen Ausbau östlich Weichering ermittelt und in den damalig ausgelegten Unterlagen in einem schalltechnischen Gutachten aufgeführt. Die schalltechnischen Berechnungen erfolgten nach den "Richtlinien für den Lärmschutz an Straßen - Ausgabe 1990 - (RLS-1990)". Die Pegelberechnungen wurden dabei für ausgewählte repräsentative Gebäude durchgeführt. Um die Immissionsgrenzwerte einhalten zu können, werden Abhilfemaßnahmen entsprechend des Planfeststellungsbeschlusses in Form eines Lärmschutzwalles im Abschnitt östlich Weichering ausgeführt.

Am 16.03.2016 wurde der erste Referentenentwurf des Bundesverkehrswegeplans (BVWP) 2030 veröffentlicht. Damit wurde der Öffentlichkeit die Möglichkeit gegeben, zu den dort enthaltenen Projekten innerhalb von 6 Wochen Stellung zu nehmen. Diese werden auf sinnvolle Hinweise aus fachlich-inhaltlichen oder rechtlichen Gründen vom Bundesministerium für Verkehr und digitale Infrastruktur geprüft und ggf. in den BVWP übernommen. Anschließend wird eine überarbeitete Fassung für den Kabinettbeschluss der Bundesregierung zur Annahme des BVWP 2030 vorgelegt. Auf Grundlage des BVWP werden die Bedarfspläne aufgestellt, die abschließend festlegen, welche Verkehrsinfrastrukturprojekte in welcher Dringlichkeit geplant und aus dem Bundeshaushalt finanziert werden sollen. In dem vorliegenden Entwurf des BVWP ist der 4-streifige Ausbau der B 16 zwischen Neuburg a. d. Donau und der Autobahn A 9 in den vordringlichen Bedarf eingestuft. Mit Verabschiedung des BVWP durch das Bundeskabinett erhält das Staatliche Bauamt Ingolstadt Planungsauftrag für den 4-streifigen Ausbau. In diesem Rahmen werden dann die Belange des Lärmschutzes erneut geprüft werden.

Mit freundlichen Grüßen
Stefanie Giestl-Rieß

Abteilungsleiterin
Staatliches Bauamt Ingolstadt
Abteilung Planung
Elbrachtstraße 20
85049 Ingolstadt

Copy: Jan Böhmermann Schmähkritik – Barbara Erdogan…

Da wieder fleissig depubliziert wird, hier die Kopie des Gedichtes von Jan Böhmermann für den türkischen Präsidenten…

Kickoff Arduino Projekt: Selbstbau AllInOne Sensorenpaket für mein Smarthome

Der Virus Smarthome/Heimautomatisierung ereilte mich letzten November und seither werkelt ein RaspberryPi2 mit FHEM– und Kodi-Installation. Fhem, die sehr flexible Smarthome-Software und Kodi als Medienverwaltung funktionieren bereits prächtig. SSL Zertifikat zur sicheren Steuerung über das Internet per Handy von überall auf der Welt ist gegeben. Lernbedarf bzgl der Programmierung in PERL und besonders die bisher noch fehlende Usability wird mich noch lange auf Trab halten.

Bildschirmfoto vom 2015-11-22 21:18:08 Bildschirmfoto vom 2016-01-30 23-33-43

Aber wo es aktuell richtig fehlt, ist die Ausstattung mit Sensoren und Aktoren. Diese erst stellen einen Mehrwert von vernetzten Informationen im Zuhause dar. Auch wenn es einige vorgefertigte Lowcost-Varianten im Bereich Smarthome-Ausstattung gibt, blättert man mit etwas Anspruch gut und gerne 50-80€ pro Gerät auf den Tisch.

Bei meiner Suche nach einem Kombigerät für Temperatur, Luftdruck, Luftfeuchtigkeit, aber auch CO²-Werte und weitere Gase (Feueralarm etc.), stieß ich sowohl an die Angebots- als auch an die Kostengrenze.

Von der Arduino-Plattform hatte ich zwar irgendwann in der Vergangenheit etwas gehört, aber nach einigen Youtube-Videos war es recht schnell klar:

Auf der Basis werde ich mir für jeden Raum ein kostengünstiges Sensorenpaket bauen und per LAN/WLAN an meine Zentrale anbinden.

Das passiert natürlich nach 2-3 Tagen Erstbeschäftigung mit Arduino nun auf dummdreisten Anfängerniveau, aber dank unzähliger Youtube-Anleitungen und Beispielen macht das richtig Spass.  Ein neues Hobby ist geboren :)

Bildschirmfoto vom 2016-01-30 22-25-33

Hier mein Hardware Setup:img_20160129_144453.jpg

  • Ein Funduino Starterpaket (amazon link) das alle wichtige Hardware-Komponenten für erste Gehversuche mitbringt.
  • WLAN Modul ESP8266 (amazon link)
  • DHT22 Temperatur- und Luftfeuchtemessung (amazon link)
  • Ethernet Aufsatz Arduino Shield (amazon link)

Das erste Design für das Sensorenpaket per Fritzing und Überlegungen in welcher Art Gehäuse man so etwas schick unterbringen kann.

Bildschirmfoto vom 2016-01-30 22-39-01

Mein erster Testcode auf Basis FIRMATA (wegen Fhem-Integration)

/*
* Firmata is a generic protocol for communicating with microcontrollers
* from software on a host computer. It is intended to work with
* any host computer software package.
*
* To download a host software package, please clink on the following link
* to open the download page in your default browser.
*
* http://firmata.org/wiki/Download
*/

/*
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2009-2011 Jeff Hoefs. All rights reserved.
Copyright (C) 2012 Julian Gaultier. All rights reserved.
Copyright (C) 2015 Rick Waldron. All rights reserved.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
*/
#include <Servo.h>
#include <Wire.h>
#include <Firmata.h>

#define I2C_WRITE B00000000
#define I2C_READ B00001000
#define I2C_READ_CONTINUOUSLY B00010000
#define I2C_STOP_READING B00011000
#define I2C_READ_WRITE_MODE_MASK B00011000
#define I2C_10BIT_ADDRESS_MODE_MASK B00100000

#define MAX_QUERIES 8
#define MINIMUM_SAMPLING_INTERVAL 10

#define REGISTER_NOT_SPECIFIED -1
#define PING_READ 0x75

//TMP36 Pin Variables
int sensorPin = 5; //the analog pin the TMP36’s Vout (sense) pin is connected to
//the resolution is 10 mV / degree centigrade with a
//500 mV offset to allow for negative temperatures
int piezo = 2;
int bewegung = 3;
int bewegungsstatus = 0;

int licht = 4;

#define trigPin 13
#define echoPin 12

//#include <NewPing.h>

//Definimos los Pines de Conexion
//Pin Trigger a Digital 5
//#define TRIGGER_PIN 13
//Pin Echo a Digital 6
//#define ECHO_PIN 12
//Constante de Distancia Maxima en este caso 2 Metros
//#define MAX_DISTANCE 200

//Creamos un Objeto de la Libreria NewPing
//NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
/*
*
* setup() – this function runs once when you turn your Arduino on
* We initialize the serial connection with the computer
*/

// PING_READ is for use with HCSR04 and similar „ultrasonic ping“ components

/*==============================================================================
* GLOBAL VARIABLES
*============================================================================*/

// analog inputs
int analogInputsToReport = 0; // bitwise array to store pin reporting

// digital input ports
byte reportPINs[TOTAL_PORTS]; // 1 = report this port, 0 = silence
byte previousPINs[TOTAL_PORTS]; // previous 8 bits sent

// pins configuration
byte pinConfig[TOTAL_PINS]; // configuration of every pin
byte portConfigInputs[TOTAL_PORTS]; // each bit: 1 = pin in INPUT, 0 = anything else
int pinState[TOTAL_PINS]; // any value that has been written

// timer variables
unsigned long currentMillis; // store the current value from millis()
unsigned long previousMillis; // for comparison with currentMillis
int samplingInterval = 19; // how often to run the main loop (in ms)

// i2c data
struct i2c_device_info {
byte addr;
byte reg;
byte bytes;
};

// for i2c read continuous more
i2c_device_info query[MAX_QUERIES];

byte i2cRxData[32];
boolean isI2CEnabled = false;
signed char queryIndex = -1;

// default delay time between i2c read request and Wire.requestFrom()
unsigned int i2cReadDelayTime = 0;

Servo servos[MAX_SERVOS];
/*==============================================================================
* FUNCTIONS
*============================================================================*/

void readAndReportData(byte address, int theRegister, byte numBytes) {
// allow I2C requests that don’t require a register read
// for example, some devices using an interrupt pin to signify new data available
// do not always require the register read so upon interrupt you call Wire.requestFrom()
if (theRegister != REGISTER_NOT_SPECIFIED) {
Wire.beginTransmission(address);
Wire.write((byte)theRegister);
Wire.endTransmission();
delayMicroseconds(i2cReadDelayTime); // delay is necessary for some devices such as WiiNunchuck
} else {
theRegister = 0; // fill the register with a dummy value
}

Wire.requestFrom(address, numBytes); // all bytes are returned in requestFrom

// check to be sure correct number of bytes were returned by slave
if (numBytes == Wire.available()) {
i2cRxData[0] = address;
i2cRxData[1] = theRegister;
for (int i = 0; i < numBytes; i++) {
i2cRxData[2 + i] = Wire.read();
}
} else {
if (numBytes > Wire.available()) {
Firmata.sendString(„I2C Read Error: Too many bytes received“);
} else {
Firmata.sendString(„I2C Read Error: Too few bytes received“);
}
}

// send slave address, register and received bytes
Firmata.sendSysex(SYSEX_I2C_REPLY, numBytes + 2, i2cRxData);
}

void outputPort(byte portNumber, byte portValue, byte forceSend) {
// pins not configured as INPUT are cleared to zeros
portValue = portValue & portConfigInputs[portNumber];
// only send if the value is different than previously sent
if (forceSend || previousPINs[portNumber] != portValue) {
Firmata.sendDigitalPort(portNumber, portValue);
previousPINs[portNumber] = portValue;
}
}

/* —————————————————————————–
* check all the active digital inputs for change of state, then add any events
* to the Serial output queue using Serial.print() */
void checkDigitalInputs(void) {
/* Using non-looping code allows constants to be given to readPort().
* The compiler will apply substantial optimizations if the inputs
* to readPort() are compile-time constants. */
if (TOTAL_PORTS > 0 && reportPINs[0]) outputPort(0, readPort(0, portConfigInputs[0]), false);
if (TOTAL_PORTS > 1 && reportPINs[1]) outputPort(1, readPort(1, portConfigInputs[1]), false);
if (TOTAL_PORTS > 2 && reportPINs[2]) outputPort(2, readPort(2, portConfigInputs[2]), false);
if (TOTAL_PORTS > 3 && reportPINs[3]) outputPort(3, readPort(3, portConfigInputs[3]), false);
if (TOTAL_PORTS > 4 && reportPINs[4]) outputPort(4, readPort(4, portConfigInputs[4]), false);
if (TOTAL_PORTS > 5 && reportPINs[5]) outputPort(5, readPort(5, portConfigInputs[5]), false);
if (TOTAL_PORTS > 6 && reportPINs[6]) outputPort(6, readPort(6, portConfigInputs[6]), false);
if (TOTAL_PORTS > 7 && reportPINs[7]) outputPort(7, readPort(7, portConfigInputs[7]), false);
if (TOTAL_PORTS > 8 && reportPINs[8]) outputPort(8, readPort(8, portConfigInputs[8]), false);
if (TOTAL_PORTS > 9 && reportPINs[9]) outputPort(9, readPort(9, portConfigInputs[9]), false);
if (TOTAL_PORTS > 10 && reportPINs[10]) outputPort(10, readPort(10, portConfigInputs[10]), false);
if (TOTAL_PORTS > 11 && reportPINs[11]) outputPort(11, readPort(11, portConfigInputs[11]), false);
if (TOTAL_PORTS > 12 && reportPINs[12]) outputPort(12, readPort(12, portConfigInputs[12]), false);
if (TOTAL_PORTS > 13 && reportPINs[13]) outputPort(13, readPort(13, portConfigInputs[13]), false);
if (TOTAL_PORTS > 14 && reportPINs[14]) outputPort(14, readPort(14, portConfigInputs[14]), false);
if (TOTAL_PORTS > 15 && reportPINs[15]) outputPort(15, readPort(15, portConfigInputs[15]), false);
}

// —————————————————————————–
/* sets the pin mode to the correct state and sets the relevant bits in the
* two bit-arrays that track Digital I/O and PWM status
*/
void setPinModeCallback(byte pin, int mode) {
if (pinConfig[pin] == I2C && isI2CEnabled && mode != I2C) {
// disable i2c so pins can be used for other functions
// the following if statements should reconfigure the pins properly
disableI2CPins();
}
if (IS_PIN_SERVO(pin) && mode != SERVO && servos[PIN_TO_SERVO(pin)].attached()) {
servos[PIN_TO_SERVO(pin)].detach();
}
if (IS_PIN_ANALOG(pin)) {
reportAnalogCallback(PIN_TO_ANALOG(pin), mode == ANALOG ? 1 : 0); // turn on/off reporting
}
if (IS_PIN_DIGITAL(pin)) {
if (mode == INPUT) {
portConfigInputs[pin/8] |= (1 << (pin & 7));
} else {
portConfigInputs[pin/8] &= ~(1 << (pin & 7));
}
}
pinState[pin] = 0;
switch(mode) {
case ANALOG:
if (IS_PIN_ANALOG(pin)) {
if (IS_PIN_DIGITAL(pin)) {
pinMode(PIN_TO_DIGITAL(pin), INPUT); // disable output driver
digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable internal pull-ups
}
pinConfig[pin] = ANALOG;
}
break;
case INPUT:
if (IS_PIN_DIGITAL(pin)) {
pinMode(PIN_TO_DIGITAL(pin), INPUT); // disable output driver
digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable internal pull-ups
pinConfig[pin] = INPUT;
}
break;
case OUTPUT:
if (IS_PIN_DIGITAL(pin)) {
digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable PWM
pinMode(PIN_TO_DIGITAL(pin), OUTPUT);
pinConfig[pin] = OUTPUT;
}
break;
case PWM:
if (IS_PIN_PWM(pin)) {
pinMode(PIN_TO_PWM(pin), OUTPUT);
analogWrite(PIN_TO_PWM(pin), 0);
pinConfig[pin] = PWM;
}
break;
case SERVO:
if (IS_PIN_SERVO(pin)) {
pinConfig[pin] = SERVO;
if (!servos[PIN_TO_SERVO(pin)].attached()) {
servos[PIN_TO_SERVO(pin)].attach(PIN_TO_DIGITAL(pin));
}
}
break;
case I2C:
if (IS_PIN_I2C(pin)) {
// mark the pin as i2c
// the user must call I2C_CONFIG to enable I2C for a device
pinConfig[pin] = I2C;
}
break;
default:
Firmata.sendString(„Unknown pin mode“); // TODO: put error msgs in EEPROM
}
// TODO: save status to EEPROM here, if changed
}

void analogWriteCallback(byte pin, int value) {
if (pin < TOTAL_PINS) {
switch(pinConfig[pin]) {
case SERVO:
if (IS_PIN_SERVO(pin))
servos[PIN_TO_SERVO(pin)].write(value);
pinState[pin] = value;
break;
case PWM:
if (IS_PIN_PWM(pin))
analogWrite(PIN_TO_PWM(pin), value);
pinState[pin] = value;
break;
}
}
}

void digitalWriteCallback(byte port, int value) {
byte pin, lastPin, mask=1, pinWriteMask=0;

if (port < TOTAL_PORTS) {
// create a mask of the pins on this port that are writable.
lastPin = port*8+8;
if (lastPin > TOTAL_PINS) lastPin = TOTAL_PINS;
for (pin=port*8; pin < lastPin; pin++) {
// do not disturb non-digital pins (eg, Rx & Tx)
if (IS_PIN_DIGITAL(pin)) {
// only write to OUTPUT and INPUT (enables pullup)
// do not touch pins in PWM, ANALOG, SERVO or other modes
if (pinConfig[pin] == OUTPUT || pinConfig[pin] == INPUT) {
pinWriteMask |= mask;
pinState[pin] = ((byte)value & mask) ? 1 : 0;
}
}
mask = mask << 1;
}
writePort(port, (byte)value, pinWriteMask);
}
}
// —————————————————————————–
/* sets bits in a bit array (int) to toggle the reporting of the analogIns
*/
//void FirmataClass::setAnalogPinReporting(byte pin, byte state) {
//}
void reportAnalogCallback(byte analogPin, int value) {
if (analogPin < TOTAL_ANALOG_PINS) {
if (value == 0) {
analogInputsToReport = analogInputsToReport &~ (1 << analogPin);
} else {
analogInputsToReport = analogInputsToReport | (1 << analogPin);
}
}
// TODO: save status to EEPROM here, if changed
}

void reportDigitalCallback(byte port, int value) {
if (port < TOTAL_PORTS) {
reportPINs[port] = (byte)value;
}
// do not disable analog reporting on these 8 pins, to allow some
// pins used for digital, others analog. Instead, allow both types
// of reporting to be enabled, but check if the pin is configured
// as analog when sampling the analog inputs. Likewise, while
// scanning digital pins, portConfigInputs will mask off values from any
// pins configured as analog
}

/*==============================================================================
* SYSEX-BASED commands
*============================================================================*/

void sysexCallback(byte command, byte argc, byte *argv) {
byte mode;
byte slaveAddress;
byte slaveRegister;
byte data;
unsigned int delayTime;

switch(command) {
case I2C_REQUEST:
mode = argv[1] & I2C_READ_WRITE_MODE_MASK;
if (argv[1] & I2C_10BIT_ADDRESS_MODE_MASK) {
Firmata.sendString(„10-bit addressing not supported“);
return;
}
else {
slaveAddress = argv[0];
}

switch (mode) {
case I2C_WRITE:
Wire.beginTransmission(slaveAddress);
for (byte i = 2; i < argc; i += 2) {
data = argv[i] + (argv[i + 1] << 7);
Wire.write((byte)data);
}
Wire.endTransmission();
delayMicroseconds(70);

break;

case I2C_READ:
case I2C_READ_CONTINUOUSLY:
if (argc == 6) {
// a slave register is specified
slaveRegister = argv[2] + (argv[3] << 7);
data = argv[4] + (argv[5] << 7); // bytes to read
} else {
// a slave register is NOT specified
slaveRegister = (int)REGISTER_NOT_SPECIFIED;
data = argv[2] + (argv[3] << 7); // bytes to read
}

if (mode == I2C_READ) {
readAndReportData(slaveAddress, slaveRegister, data);
} else {
if ((queryIndex + 1) >= MAX_QUERIES) {
Firmata.sendString(„too many queries“);
break;
}
queryIndex++;
query[queryIndex].addr = slaveAddress;
query[queryIndex].reg = slaveRegister;
query[queryIndex].bytes = data;
}

break;

case I2C_STOP_READING:
byte queryIndexToSkip;
// if read continuous mode is enabled for only 1 i2c device, disable
// read continuous reporting for that device
if (queryIndex <= 0) {
queryIndex = -1;
} else {
// if read continuous mode is enabled for multiple devices,
// determine which device to stop reading and remove it’s data from
// the array, shifiting other array data to fill the space
for (byte i = 0; i < queryIndex + 1; i++) {
if (query[i].addr == slaveAddress) {
queryIndexToSkip = i;

break;
}
}

for (byte i = queryIndexToSkip; i < queryIndex + 1; i++) {
if (i < MAX_QUERIES) {
query[i].addr = query[i + 1].addr;
query[i].reg = query[i + 1].reg;
query[i].bytes = query[i + 1].bytes;
}
}
queryIndex–;
}

break;
default:

break;
}
break;
case I2C_CONFIG:
delayTime = (argv[0] + (argv[1] << 7));

if (delayTime > 0) {
i2cReadDelayTime = delayTime;
}

if (!isI2CEnabled) {
enableI2CPins();
}

break;
case SERVO_CONFIG:
if (argc > 4) {
// these vars are here for clarity, they’ll optimized away by the compiler
byte pin = argv[0];
int minPulse = argv[1] + (argv[2] << 7);
int maxPulse = argv[3] + (argv[4] << 7);

if (IS_PIN_SERVO(pin)) {
if (servos[PIN_TO_SERVO(pin)].attached()) {
servos[PIN_TO_SERVO(pin)].detach();
}
servos[PIN_TO_SERVO(pin)].attach(PIN_TO_DIGITAL(pin), minPulse, maxPulse);
setPinModeCallback(pin, SERVO);
}
}
break;
case SAMPLING_INTERVAL:
if (argc > 1) {
samplingInterval = argv[0] + (argv[1] << 7);
if (samplingInterval < MINIMUM_SAMPLING_INTERVAL) {
samplingInterval = MINIMUM_SAMPLING_INTERVAL;
}
} else {
//Firmata.sendString(„Not enough data“);
}
break;
case EXTENDED_ANALOG:
if (argc > 1) {
int val = argv[1];
if (argc > 2) {
val |= (argv[2] << 7);
}
if (argc > 3) {
val |= (argv[3] << 14);
}
analogWriteCallback(argv[0], val);
}
break;
case CAPABILITY_QUERY:
Serial.write(START_SYSEX);
Serial.write(CAPABILITY_RESPONSE);
for (byte pin=0; pin < TOTAL_PINS; pin++) {
if (IS_PIN_DIGITAL(pin)) {
Serial.write((byte)INPUT);
Serial.write(1);
Serial.write((byte)OUTPUT);
Serial.write(1);
Serial.write((byte)PING_READ);
Serial.write(1);
}
if (IS_PIN_ANALOG(pin)) {
Serial.write(ANALOG);
Serial.write(10);
}
if (IS_PIN_PWM(pin)) {
Serial.write(PWM);
Serial.write(8);
}
if (IS_PIN_SERVO(pin)) {
Serial.write(SERVO);
Serial.write(14);
}
if (IS_PIN_I2C(pin)) {
Serial.write(I2C);
Serial.write(1); // to do: determine appropriate value
}
Serial.write(127);
}
Serial.write(END_SYSEX);
break;
case PIN_STATE_QUERY:
if (argc > 0) {
byte pin = argv[0];
Serial.write(START_SYSEX);
Serial.write(PIN_STATE_RESPONSE);
Serial.write(pin);
if (pin < TOTAL_PINS) {
Serial.write((byte)pinConfig[pin]);
Serial.write((byte)pinState[pin] & 0x7F);
if (pinState[pin] & 0xFF80) {
Serial.write((byte)(pinState[pin] >> 7) & 0x7F);
}
if (pinState[pin] & 0xC000) {
Serial.write((byte)(pinState[pin] >> 14) & 0x7F);
}
}
Serial.write(END_SYSEX);
}
break;
case ANALOG_MAPPING_QUERY:
Serial.write(START_SYSEX);
Serial.write(ANALOG_MAPPING_RESPONSE);
for (byte pin=0; pin < TOTAL_PINS; pin++) {
Serial.write(IS_PIN_ANALOG(pin) ? PIN_TO_ANALOG(pin) : 127);
}
Serial.write(END_SYSEX);
break;
case PING_READ: {
byte pulseDurationArray[4] = {
(argv[2] & 0x7F) | ((argv[3] & 0x7F) << 7),
(argv[4] & 0x7F) | ((argv[5] & 0x7F) << 7),
(argv[6] & 0x7F) | ((argv[7] & 0x7F) << 7),
(argv[8] & 0x7F) | ((argv[9] & 0x7F) << 7)
};
unsigned long pulseDuration = ((unsigned long)pulseDurationArray[0] << 24)
+ ((unsigned long)pulseDurationArray[1] << 16)
+ ((unsigned long)pulseDurationArray[2] << 8)
+ ((unsigned long)pulseDurationArray[3]);
if (argv[1] == HIGH){
pinMode(argv[0],OUTPUT);
digitalWrite(argv[0],LOW);
delayMicroseconds(2);
digitalWrite(argv[0],HIGH);
delayMicroseconds(pulseDuration);
digitalWrite(argv[0],LOW);
} else {
digitalWrite(argv[0],HIGH);
delayMicroseconds(2);
digitalWrite(argv[0],LOW);
delayMicroseconds(pulseDuration);
digitalWrite(argv[0],HIGH);
}
unsigned long duration;
byte responseArray[5];
byte timeoutArray[4] = {
(argv[10] & 0x7F) | ((argv[11] & 0x7F) << 7),
(argv[12] & 0x7F) | ((argv[13] & 0x7F) << 7),
(argv[14] & 0x7F) | ((argv[15] & 0x7F) << 7),
(argv[16] & 0x7F) | ((argv[17] & 0x7F) << 7)
};
unsigned long timeout = ((unsigned long)timeoutArray[0] << 24) +
((unsigned long)timeoutArray[1] << 16) +
((unsigned long)timeoutArray[2] << 8) +
((unsigned long)timeoutArray[3]);

pinMode(argv[0],INPUT);
duration = pulseIn(argv[0], argv[1],timeout);
responseArray[0] = argv[0];
responseArray[1] = (((unsigned long)duration >> 24) & 0xFF);
responseArray[2] = (((unsigned long)duration >> 16) & 0xFF);
responseArray[3] = (((unsigned long)duration >> 8) & 0xFF);
responseArray[4] = (((unsigned long)duration & 0xFF));

Firmata.sendSysex(PING_READ, 5, responseArray);
break;
}
}
}

void enableI2CPins() {
for (byte i = 0; i < TOTAL_PINS; i++) {
if (IS_PIN_I2C(i)) {
// mark pins as i2c so they are ignore in non i2c data requests
setPinModeCallback(i, I2C);
}
}

isI2CEnabled = true;

// is there enough time before the first I2C request to call this here?
Wire.begin();
}

void disableI2CPins() {
isI2CEnabled = false;
queryIndex = -1;
}

void systemResetCallback() {
if (isI2CEnabled) {
disableI2CPins();
}
for (byte i = 0; i < TOTAL_PORTS; i++) {
reportPINs[i] = false; // by default, reporting off
portConfigInputs[i] = 0; // until activated
previousPINs[i] = 0;
}
// pins with analog capability default to analog input
// otherwise, pins default to digital output
for (byte i = 0; i < TOTAL_PINS; i++) {
if (IS_PIN_ANALOG(i)) {
// turns off pullup, configures everything
setPinModeCallback(i, ANALOG);
} else {
// sets the output to 0, configures portConfigInputs
setPinModeCallback(i, OUTPUT);
}
}
// by default, do not report any analog inputs
analogInputsToReport = 0;
}

void setup() {
Firmata.setFirmwareVersion(FIRMATA_MAJOR_VERSION, FIRMATA_MINOR_VERSION);
Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
Firmata.attach(DIGITAL_MESSAGE, digitalWriteCallback);
Firmata.attach(REPORT_ANALOG, reportAnalogCallback);
Firmata.attach(REPORT_DIGITAL, reportDigitalCallback);
Firmata.attach(SET_PIN_MODE, setPinModeCallback);
Firmata.attach(START_SYSEX, sysexCallback);
Firmata.attach(SYSTEM_RESET, systemResetCallback);

Firmata.begin(57600);
systemResetCallback(); // reset to default config

pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);

pinMode(piezo, OUTPUT);
pinMode(bewegung, INPUT);

}

void loop() {
byte pin, analogPin;

/* DIGITALREAD – as fast as possible, check for changes and output them to the
* FTDI buffer using Serial.print() */
checkDigitalInputs();

/* SERIALREAD – processing incoming messagse as soon as possible, while still
* checking digital inputs. */
while (Firmata.available()) {
Firmata.processInput();
}

/* SEND FTDI WRITE BUFFER – make sure that the FTDI buffer doesn’t go over
* 60 bytes. use a timer to sending an event character every 4 ms to
* trigger the buffer to dump. */

currentMillis = millis();
if (currentMillis – previousMillis > samplingInterval) {
previousMillis += samplingInterval;
/* ANALOGREAD – do all analogReads() at the configured sampling interval */
for (pin=0; pin<TOTAL_PINS; pin++) {
if (IS_PIN_ANALOG(pin) && pinConfig[pin] == ANALOG) {
analogPin = PIN_TO_ANALOG(pin);
if (analogInputsToReport & (1 << analogPin)) {
Firmata.sendAnalog(analogPin, analogRead(analogPin));
}
}
}
// report i2c data for all device with read continuous mode enabled
if (queryIndex > -1) {
for (byte i = 0; i < queryIndex + 1; i++) {
readAndReportData(query[i].addr, query[i].reg, query[i].bytes);
}
}
}
{
// delay(100);
// Obtenemos la medicion del tiempo de Rebote del sonido
// int uS = sonar.ping_median();
//Imprimos el String Distancia
// Serial.print(„Distancia: „);
// Calcular la distancia con base en una constante
//Serial.print(uS / US_ROUNDTRIP_CM);
//Serial.println(„cm“);

int duration, distance;
digitalWrite(trigPin, HIGH);
delayMicroseconds(1000);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = (duration/2) / 29.1;
Serial.print(distance); Serial.println(“ cm“);
delay(500);

//getting the voltage reading from the temperature sensor
int reading = analogRead(sensorPin);

// converting that reading to voltage, for 3.3v arduino use 3.3
float voltage = reading * 5.0;
voltage /= 1024.0;

// now print out the temperature
float temperatureC = (voltage – 0.5) * 100 ; //converting from 10 mv per degree wit 500 mV offset
//to degrees ((voltage – 500mV) times 100)
Serial.print(temperatureC); Serial.println(“ C°“);

delay(1000); //waiting a second

bewegungsstatus = digitalRead(bewegung);
if (bewegungsstatus == HIGH)
{
digitalWrite(piezo, HIGH);
delay(10);
digitalWrite(piezo, LOW);
//print ob Bewegung erkannt
Serial.print(bewegung); Serial.println(“ Bewegung erkannt“);
}
else
{
digitalWrite(piezo, LOW);
}
{
licht = analogRead(4);
Serial.print(licht); Serial.println(“ Raumhelligkeit“);

if (licht < 880) {
digitalWrite(4, HIGH);
}
else {
digitalWrite(4, LOW);
}

}
}
}

 

Mein (remote) #32C3 Fahrplan

Zwischen den Weihnachtsfeiertagen und Neujahr findet jährlich »Der Kongress« des Chaos Computer Club statt.  Der Besuch der Veranstaltung wurde mittlerweile von einigen Bundesländern als anerkannter Bildungsurlaub klassifiziert. Komprimiertes und sehr oft kurzweiliges Wissen zu den Themen, die einen selbst interessieren – was will man mehr…

Danke an die Organisatoren für dieses Angebot zwischen den Feiertagen!

Mein persönlicher Fahrplan für die #32C3 Livestreams:

Sonntag 27.12.2015

NSA-Untersuchungsausschuss: Zwischen Aufklärungswillen und Mauern aus Schweigen

The exhaust emission scandal („Dieselgate“)

How the Great Firewall discovers hidden circumvention servers

Shooting lasers into space – for science!

Montag 28.12.2015

The state of internet Censorship

Evolution of Brain-Computer Interfaces

Mobile Censorship in Iran

Das Zahnrad aus Fleisch – Expeditionen ins Kommentierreich

Fnord-Jahresrückblick

Dienstag 29.12.2015

„Nach bestem Wissen und Gewissen“ – Floskeln in der Politik

Computational Meta-Psychology

Vehicle2Vehicle Communication based on IEEE 802.11p

The price of dissent

The architecture of a street level panopticon

Media coverage and the public in the surveillance society

Intelexit

Stromtankstellen – eine neue öffentliche Infrastruktur

Technology and Mass Atrocity Prevention ODER Maritime Robotics

Mittwoch 30.12.2015

Desaster communication

A New Kid on the Block

Predicting Crime in a Big Data World

 

 

 

 

 

 

 

 

 

 

Erste Schritte mit FHEM – Hardware, Software und Code. #Hausautomation

Genau eine Woche nach der ersten ernsthaften Beschäftigung mit dem Thema Hausautomatisierung gibt es folgenden Status:

Bildschirmfoto vom 2015-11-22 21:19:09

Aber der Reihe nach. Zu allererst war mein größtes Problem der HDMI-Anschluss vom Raspberry Pi 2, weil mein alter Gamer-Monitor nur VGA und DVI besitzt. Folglich musste der Fernseher herhalten – zum Leidwesen meiner Frau – bis SSH-Zugriff möglich war.

Bildschirmfoto vom 2015-11-22 21:18:08

Die Installation von FHEM auf Raspbian verlief absolut problemlos, geholfen hat mir hier besonders der Beitrag auf voizechat. Zum flashen des CUL mit der aktuellen Firmware gibt es auch eine sehr gute lückenlose Anleitung.

Die Konfiguration des Backups vom RPi auf das NAS war, obwohl die Anleitung top ist, sehr tricky da das gemountete Laufwerk nicht auf Anhieb funktionierte.

Seitdem das erfolgreich eingerichtet ist, wurde mit einigen FHEM-Möglichkeiten gespielt.

Bildschirmfoto vom 2015-11-22 21:19:52

Die wichtigsten Programmierungen betreffen das Design des Darkstyle, Dashboard und die Einbindung aller möglichen Module und Features. Für den HomeMatic Actor wurden zwei erste Gehversuche programmiert:

  1. Bei Anwesenheit meines Handys im heimischen WLAN wird eine Wohnzimmerlampe aktiviert. Ein Watchdog überwacht dies und setzt bei Abwesenheit auch den Aktor in den Status off – auf gut deutsch: Mit mir im Raum geht ein Lichtlein an :)

# PresenceHandyBen
define Handybenpresence PRESENCE lan-ping 192.168.178.148 30 50
define Handyben dummy
attr Handyben event-on-change-reading state
attr Handyben group FHEM
define Benmode notify Handybenpresence:present set Handyben on
define Handybendoda watchdog Handybenpresence:present 00:01 set Handyben on;; setstate Handybendoda defined;; set testneo on
attr Handybendoda group FHEM
attr Handybendoda regexp1WontReactivate 1
attr Handybendoda room FHEM
define Handybenweg watchdog Handybenpresence:absent 00:01 set Handyben off;; setstate Handybenweg defined;; set testneo off
attr Handybenweg group FHEM
attr Handybenweg regexp1WontReactivate 1
attr Handybenweg room FHEM

2. Mittels at Befehl wurde ein täglicher Lichtwecker um 6 Uhr morgens eingerichtet.

define LichtWecker at *06:00 { if (!$we) { fhem(„set testneo on“) } }

Die nächsten Wochen werden davon geprägt sein, wie ich die Programmiersprache (FHEM+PERL) und Logiken lernen werde. Das Forum und Wiki sind aber klasse.

Interessant sind auch die Nutzungsstatistiken von FHEM. Das scheint eine „.de only Show“ zu sein

 

KickOff: Die wunderbare Welt der Hausautomation mit #FHEM & Co

Zwar wurde bisher weder ein Grundstück gefunden, geschweige denn gekauft noch ist vor 2017/18 das Thema Smart Home / Heimautomatisierung überhaupt ein Thema, aber die letzten Stunden hat es mich zugegebenermaßen etwas erwischt :)

tirreG

FHEM – Freundliche Hausautomation und EnergieMessung

Anleitung für Beginner

forum_22336

Nach einigen Youtube Demos und Tutorials, wie man mittels FHEM sein Zuhause automatisiert, habe ich heute folgende Zutaten für eine Verprobung organisiert:

 

 

 

  • CUL Funkmodul  IMG_9949_2

 

 

 

 

 

 

Ab Mitte der Woche wird programmiert und getestet.

 

Wer aktuell auch in den Startlöchern zum Thema steckt oder sogar im Raum Ingolstadt Praxiserfahrung  in Haus oder Wohnung sammelt, melde dich gerne!

Junge Familie sucht Grundstück – Hilfsmittel Immobiliensuche per Scout und Immowelt

Nach der ausgiebigen Analyse der Immobilienblase in Ingolstadt und der etwas unkonventionellen Grundstückssuche in der südöstlichen Region rund um Ingolstadt ein kleines Update:

Bisher privat angefragte Makler und im Baugeschäft tätige Bekannte: 7

Rücklauf über Wochen und Monate: 0

Dieser Grundstücksmarkt in und um Ingolstadt ist kaputt, ich möchte einen neuen haben :)

Zur Unterstützung der Suche habe ich jeweils bei Immoscout24 (24,99€ / 30 Tage) und Immowelt (14,99€ / 30 Tage) eine online-Suchanzeige aufgegeben. Mal sehen, ob überhaupt und welche Qualität an Angeboten da die nächsten Tage eintrudelt…

Bildschirmfoto vom 2015-11-03 07:35:21

65 Profilbesucher von Mitternacht bis sieben Uhr frühmorgens kann ich trotz einiger Interneterfahrung auch nicht wirklich deuten. Entweder haben Makler in der Region ihre Käufersuche so optimiert, dass als Folge meiner Suchanzeige ganz viele Mails verschickt wurden. Oder aber – was realistischer ist – es so viele Menschen gibt, die die öffentlichen Profile mit einem Partnerportal verwechseln…

Besichtigungen von Grundstücken über die Onlineportale Scout24 und Immowelt fanden bisher 3 statt. Erschwingliche Angebote sind tatsächlich kaum online und wenn dann zu absolut überzogenen Preisen.

Pendeln zu 30km+ entfernten normalen Grundstückspreisen um die 50-90€/m² kommt nach einem Selbstversuch nicht in Frage. Die persönlich brauchbare Grenze liegt bei circa 20km. Wobei ich mir das in der Pampa schon vorstellen könnte, aber eben nicht für täglich 1-1,5 Stunden Pendelei zwischen Arbeit und Wohnort…

Für das Baugebiet „Am Schafberg II“ in Reichertshofen werden wir uns bewerben. Die Aussicht auf Erfolg liegt zwar im einstelligen Prozentbereich, aber unter Umständen kommt das dortige Einheimischenmodell inkl der Kinderregelung für Neubürger positiv hinzu – Einheimische bekommen pro Lebensjahr einen Punkt. Zugereiste pro Kind 10.

Update folgt.

Das Abschiebelager Ingolstadt Nordost

***Update***

Die Regierung von Oberbayern in Ausführung eines Herrn Possart verlangt die Depublizierung der Bilder und Videoaufnahmen von der Baustelle des Abschiebelagers Ingolstadt Nordost.  Da es bei einer Anzeige sehr leicht zu einer Anklage wegen Hausfriedensbruch kommen kann, beuge ich mich dieser Aufforderung. Das ist der erste Fall von staatlicher Zensur, der mich persönlich trifft. Es fühlt sich nicht gut an.

Die Berichterstattung aus dem Abschiebe- und Internierungslager Nordost wird ab jetzt verstärkt.

/***Update***

***Update2***

Die Regierung von Oberbayern hat trotz erfülltem Ultimatum und totaler Kooperation Strafanzeige wegen Hausfriedensbruch auf der Baustelle gestellt. Die Staatsanwaltschaft Ingolstadt stellt das Verfahren wegen Geringfügigkeit (  §153a StPO) unter einer Geldauflage von 300€ für die Lebenshilfe für Behinderte der Region 10 ein.

Merke: Spart euch grundsätzlich die Kooperation mit Regierungsbeamten…

/***Update2***

 

Nachfolgend wird das Abschiebe- (und Internierungslager) „Containerdorf Marie Curie“ der Stadt Ingolstadt beschrieben.

Bildschirmfoto-vom-2015-11-01-220223v2

 

Im Nordosten des Stadtgebietes Ingolstadt, nahe dem Ingolstadt Village und der Gunvor-Raffinerie, wurde ein Abschiebelager für bis zu 500 Menschen gebaut.

Bildschirmfoto vom 2015-11-01 22:56:30

Neben den Abschiebelagern in der Max-Immelmann-Kaserne und dem P3 in der Manchinger Straße bietet Ingolstadt nun ca. 1500 Plätze für Schnellabschiebungen von sogenannten Wirtschaftsflüchtlingen vom Balkan.

20151006_123836

Laut offizieller Sprachregelung heißen solche Abschiebe- und Internierungslager neuerdings „Aufnahme- und Rückführungszentrum für Asylbewerber ohne Bleibeperspektive“. Der Flüchtlingsrat Bayern kommentiert das folgendermaßen:

Hier werden Flüchtlinge qua Herkunft kaserniert und isoliert, um sie am Fließband abzuschieben. Das individuelle Asylrecht verkommt zur Farce, wenn Asylanträge ohnehin nur summarisch geprüft werden und Asylsuchende kaum mehr eine Chance haben, Beratung und Rechtsmittel zu nutzen. Vor allem Minderheitenangehörige aus den Balkan-Staaten haben häufig wichtige Schutzgründe. Dass diese in einem Abschiebezentrum geltend gemacht werden können, ist kaum zu erwarten

 

Ingolstadt hat in den 1920er Jahren bereits Erfahrung, was Internierungs- und Abschiebelager angeht. Damals wurden im Fort Prinz Karl sogenannte Ostjuden mittels „Schutzhaft“ interniert und peu a peu zwangsweise abgeschoben. Die Polizei durchforstete damals die Großstädte Bayerns, um Ostjuden die teilweise bereits 20 Jahre dort lebten abzuschieben. Das damalige Internierungslager liegt 3,8km vom Containerdorf Marie Curie entfernt.

Ostjuden in Ingolstadt

Beides befindet sich im Nirgendwo Ingolstadts. Die einzige Busverbindung (Linie 20) fährt zwar stündlich, aber bis auf einen Dönerladen, einem Großhandel-Supermarkt und einem Outlet-Shopping-Center gibt es wenig Möglichkeiten der Betätigung.

Abschiebe- und Internierungslager Ingolstadt

Der Bauträger ist die Gemeinnützige Wohnungsbaugesellschaft GmbH deren Eigentumsverhältnisse wie folgt aufgestellt sind

Gesellschafter Stammeinlage % – Anteil Eintrittsjahr
Stadt Ingolstadt 22.837.540 € 54,61 % 1934
Audi AG Ingolstadt 4.190.651 € 10,02 % 1949
Sparkasse Ingolstadt 2.629.832 € 6,29 % 1963
4 weitere Gesellschafter 670.708 € 1,60 % 1971-1988
eigene Anteile GWG 11.490.915 € 27,48 %
Gesamtstammkapital 41.819.646 € 100,00 %

Bildschirmfoto vom 2015-11-01 23:16:58

Pressemitteilung der Grünen in Ingolstadt

Presseschau zum Thema Abschiebelager in Ingolstadt: Augsburger Allgemeine,  Ingolstadt Reporter,  Blickpunkt Ingolstadt, Donaukurier, Ingolstadt Today

Weitere Berichte folgen, alsbald Menschen dort untergebracht sind.

#VDS – das Datengrab unserer Freiheit, Demokratie und Zukunft

Am Freitag soll – mal wieder – eine pauschale Speicherung aller unserer Verbindungsdaten beschlossen werden.

Folgenden Mail ging eben an alle Bundestagsabgeordneten der Bundesrepublik Deutschland:

Sehr geehrte Damen und Herren,

bitte stimmen Sie der Vorratsdatenspeicherung nicht zu, weil dieses
Datengrab das Grab unserer Freiheit, Demokratie und Zukunft ist.
Metadaten sind ebenso wenig Spielzeug wie Atomraketen.

Vielen Dank und Gruß aus Ingolstadt!


Die Hoffnung auf Vernunft stirbt zuletzt... :)

big-vorratsdaten-katze