Anvilex P012.45-ATMega328P-AU-X Eagle Bibliothek

lib

Da ich sehr gern mit dem kleinen Board von Anvilex, speziell P012.45-ATMega328P-AU, arbeite, habe ich ein Bauteil für Eagle gebastelt. Damit kann man jetzt auch Platinen zum drunterstecken entwickeln.

Vielleicht braucht es ja jemand

 

DOWNLOAD Anvilex_p012.45.lbr

 

anv_board

lib

Weiter lesen

Bett-Kopf-Lampe

sl_bett

Da meine bessere Hälfte sehr gern Bücher liest und das ab und an im Bett macht, hat sie mich gebeten für ein Wenig mehr Licht zu sorgen. Nachttischleuchten reichen dafür nicht. Das konnte ich nachvollziehen.

Bei einem Besuch in einem Zoo-Geschäft kam mir auch “die” Idee. An einem Regal habe ich diese Hintergrundposter für Aquarien gesehen, die in transparenten Kunststoffröhren verkauft werden. Ein freundlicher Verkäufer hat 2 solcher Verpackungen für mich auftreiben können (Kosten: 0,-)

Beide Röhren verbunden zu einer und ein Wenig mit Aluklebefolie verschönert:

Foto 2013-07-29 10Foto 2013-07-29 1Foto 2013-07-29 3Foto 2013-07-29 2Foto 2013-07-29 4

Die Lampe soll logischerweise mit LED’s betrieben werden. Ich hatte noch ein Paar Rollen “billig”-Stripes hier, die wurden schnell in ein U-Profil eingeklebt.
Zum Einschalten wollte ich etwas besonderes verwenden und keinen einfachen Kippschalter. So kam mir die Idee Touch-Sensor zu verwenden. Den habe ich auf Atmega328P-Basis gelöst. HIER geht’s zu meinem Experiment damit hin. Der Atmega schaltet die LED’s mit Hilfe 2er Mosfets. Zwei, weil die Lampe je Hälfte steuerbar sein musste (damit ich nicht “verstrahlt” werde wärend die Freundin liest). Mosfets und der LM7805 (für die Stromversorgung des Atmegas) wurden mit Wärmeleitkleber auf das Profil befestigt:

Foto 2013-07-28 3Foto 2013-07-28 2Foto 2013-07-29 12

Alles in das Rohr verfrachtet. Als Abschlussdeckel dienen Tischbeindbeschläge aus einem Baumarkt. Diese sind auch mit Alufolie bezogen und dabei noch die verkabelung der Sensoren “angeklebt”.

Foto 2013-08-01 1Foto 2013-08-01 10Foto 2013-07-30 6Foto 2013-07-30 7

Alles an das Bett geschraubt und schon ist die Frau glücklich ;)

Weiter lesen

Capacitive Sensor mit Arduino in Einfach

IMG_5529

Für mein nächstes Projekt musste ich mir was überlegen: Lich ein- und ausschalten mit einem Schalter oder Taster wäre ja zu einfach. Also musste eine “komplizierte” Lösung her.

Wie wäre es mit Touch? Also einem berührungsempfindlichen Schalter. Man nennt es auch “Capacitive Sensor”. Es gibt IC’s, die die Auswertung der Berührung übernehmen können. Sowas wie AT42QT oder AD7746 oder EE102P. Das finde ich für meinen Bedarf zu überladen, zu kompliziert.

Der Arduino kann das auch allein! Auf Arduino Playground fand ich DIESE Anleitung/Funktion.

Diese ist sehr einfach zu implementieren. Hier ein Videoclip von meinem Experiment:

 

und Hier der Arduino-IDE Code:

 

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.
 
  This example code is in the public domain.
 */

int light;

void setup() {                
  Serial.begin(9600);
  // initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  pinMode(8, OUTPUT);     
  pinMode(10, OUTPUT);
}

void loop() {
  int sense = readCapacitivePin(12);
    Serial.println(sense);
if (sense > 8){
switch (light){
case 0:
 red();
 delay(1000);
 break;
case 1:
 green();
 delay(1000); 
 break;
}
}

}

uint8_t red(){
  digitalWrite(10, HIGH);   // set the LED on
  digitalWrite(8, LOW);    // set the LED off
  light = 1;
}

uint8_t green(){
  digitalWrite(8, HIGH);   // set the LED on
  digitalWrite(10, LOW);    // set the LED off
  light = 0;
}

// readCapacitivePin
//  Input: Arduino pin number
//  Output: A number, from 0 to 17 expressing
//  how much capacitance is on the pin
//  When you touch the pin, or whatever you have
//  attached to it, the number will get higher
#include "pins_arduino.h" // Arduino pre-1.0 needs this
uint8_t readCapacitivePin(int pinToMeasure) {
  // Variables used to translate from Arduino to AVR pin naming
  volatile uint8_t* port;
  volatile uint8_t* ddr;
  volatile uint8_t* pin;
  // Here we translate the input pin number from
  //  Arduino pin number to the AVR PORT, PIN, DDR,
  //  and which bit of those registers we care about.
  byte bitmask;
  port = portOutputRegister(digitalPinToPort(pinToMeasure));
  ddr = portModeRegister(digitalPinToPort(pinToMeasure));
  bitmask = digitalPinToBitMask(pinToMeasure);
  pin = portInputRegister(digitalPinToPort(pinToMeasure));
  // Discharge the pin first by setting it low and output
  *port &= ~(bitmask);
  *ddr  |= bitmask;
  delay(1);
  // Make the pin an input with the internal pull-up on
  *ddr &= ~(bitmask);
  *port |= bitmask;

  // Now see how long the pin to get pulled up. This manual unrolling of the loop
  // decreases the number of hardware cycles between each read of the pin,
  // thus increasing sensitivity.
  uint8_t cycles = 17;
       if (*pin & bitmask) { cycles =  0;}
  else if (*pin & bitmask) { cycles =  1;}
  else if (*pin & bitmask) { cycles =  2;}
  else if (*pin & bitmask) { cycles =  3;}
  else if (*pin & bitmask) { cycles =  4;}
  else if (*pin & bitmask) { cycles =  5;}
  else if (*pin & bitmask) { cycles =  6;}
  else if (*pin & bitmask) { cycles =  7;}
  else if (*pin & bitmask) { cycles =  8;}
  else if (*pin & bitmask) { cycles =  9;}
  else if (*pin & bitmask) { cycles = 10;}
  else if (*pin & bitmask) { cycles = 11;}
  else if (*pin & bitmask) { cycles = 12;}
  else if (*pin & bitmask) { cycles = 13;}
  else if (*pin & bitmask) { cycles = 14;}
  else if (*pin & bitmask) { cycles = 15;}
  else if (*pin & bitmask) { cycles = 16;}

  // Discharge the pin again by setting it low and output
  //  It's important to leave the pins low if you want to 
  //  be able to touch more than 1 sensor at a time - if
  //  the sensor is left pulled high, when you touch
  //  two sensors, your body will transfer the charge between
  //  sensors.
  *port &= ~(bitmask);
  *ddr  |= bitmask;

  return cycles;
}
Weiter lesen

NachttischLampe mit Effekt

lamp_slide

Nach meinem Experiment mit dem WS2803 Driver kam mir die Idee die fast ungenutze Lampe auf dem Nattisch zu modifizieren.

Nur sollte diese nicht nur Licht machen, sondern auch mit Effekt für Romantik sorgen ;)

Die schaltung ist extrem unkompliziert. an jedem der 18 Ausgänge des Drivers hängt eine Reihe aus 6 LED’s. Je ein Widerstand hält den Verbrauch im Zaun. Somit konnte ich 6 Reihen mit je 6 RGB-LED’s verwenden. Als Spannungsversorgung wird ein 24V Netzteil verwendet. Die Spannung für den Logischen Part der Schaltung reguliert ein LM7805.

Genau hier muss man bedenken, daß der Regler aund auch der WS2803 somit an der Grenze laufen. Ohne Widerstände in Reihe zu den LED’s schaltet der Chip sogar ab! Zum glück brennt er nicht einfach durch :)

Deswegen habe ich die beiden besagten Teile mit einem Kühler versehen. Jetzt werden die nach mehreren Stunden Betrieb (wenn die Lampe nur weiß leuchtet) einen Tick wärmer als die Körpertemperatur.

Alles auf eine 100×160 Platine gebannt. Die Platine längst in 4 gleiche Teile geschnitten. Die Teile im Viereck zu einander angeordnet und verlötet/verklebt. Das Schlimmste dabei ist, die vielen Verbindungen durchzukontaktieren.

Foto 2013-07-20 2Foto 2013-07-20 4Foto 2013-07-20 3Foto 2013-07-20 5

die Steuerung des WS2803 und die Generierung des Effektes übernimmt ein Atmega328P, den ich auf ein Stück Streifenrasterplatine gelötet habe. Eine sehr gute Anleitung dafür findet man HIER.

atmega

Die Kleine Platine fand im gebilde Ihren Platz. Nur den 6-poligen ICSP Anschluss habe ich draußen gelassen zum einfache Programmieren (mit einem USBasp).

Einen Taster zum Umschalten der Funktionen noch, und schon ist sie fertig:

Foto 2013-07-20 6Foto 2013-07-20 9Foto 2013-07-20 7

 

Nach dem heimischen Test ist auch der WAF seeeeehr hoch ausgefallen ;)

 

Hier noch der Quellcode für Arduino-IDE:

 

#include "SPI.h"
#include "Adafruit_WS2801.h"

// Programm um meine Effekt-Nachttisch-Lampe zu steuern
// getestet auf Atmega328p. Sollte aber auf jedem Arduino mit HW-SPI funktionieren
// Anpassung von Variablen wird wahrscheinlich notwendig werden.
//
// Ursprungs-Code stammt aus dem sample der Adafruit_WS2801 Bibliotek und
// dem Buttonsketch vom Arduino IDE
// Ich übernehme keine Haftung für Fehler, Schäden u.s.w.
// Benutzung auf eigene Gefahr 


uint8_t dataPin  = 7;
uint8_t clockPin = 8;

// Set the first variable to the NUMBER of pixels. 25 = 25 pixels in a row
Adafruit_WS2801 strip = Adafruit_WS2801(6, dataPin, clockPin, WS2801_GRB);

const int buttonPinnn = 9;     // the number of the pushbutton pin
int buttonState = 0; 


void setup() {
  pinMode(buttonPinnn, INPUT); 
  strip.begin();

// Weisses licht sofort nach dem Einschalten einblenden
fade_in();
licht();
}
int P = 1;
int T = 1; // Variable - Licht ist an

void loop() {
buttonState = digitalRead(buttonPinnn);
if (buttonState == HIGH){
  switch (T){
     case 1:
        fire_1();
        delay(500); // Pseudo-Entprellen
     break;
     case 0:
        licht();
        delay(500); // Pseudo-Entprellen
     break;
            }//switch Ende
  } //if-buttonstate Ende
else {
   if (T==1){
      licht();
      }  
   else{
      fire_1();
      }
  }//else buttonstate Ende 
} //---loop ende

//Initial Einschalten des weissen Lichts
void fade_in() {
  int L;
for (L=10; L < 256; L++){
 colorWipe(Color(L, L, L), 0);
// delay(0);
 T=2;
 }
}

// Alle LEDs weiss einschalten, var T auf "licht an" setzen 
void licht(){
for (int Li=0; Li < 6; Li++){
       strip.setPixelColor(Li, Color(255, 255, 255));
       strip.show();
       T = 1;
 }
}


// Kamin- oder Feuereffekt einschalten, var T auf "kamin an" setzen 
void fire_1(){
P = 0 + random(0, 6); //zufällige Grenze zw. rot und gelb
for (int L=0; L < P; L++){
       strip.setPixelColor(L, Color(255, 110, 0));
       strip.show();
    delay(random(50,200));
 }
for (int L=P; L < 6; L++){
       strip.setPixelColor(L, Color(255, 0, 0));
       strip.show();
 }
T=0;
 }

void colorWipe(uint32_t c, uint8_t wait) {
  int i;
  
  for (i=0; i < strip.numPixels(); i++) {
      strip.setPixelColor(i, c);
      strip.show();
      delay(1);
  }
T=1;
}

// Create a 24 bit color value from R,G,B
uint32_t Color(byte r, byte g, byte b)
{
  uint32_t c;
  c = r;
  c <<= 8;
  c |= g;
  c <<= 8;
  c |= b;
  return c;
}

Voraussetzung dafür ist die Adafruit Library für WS2801, die man HIER findet.

Weiter lesen