China Post – PCA9685 16-Channel 12-bit PWM Servo Motor Driver

PCA9685 16-Channel 12-bit PWM Servo Motor Driver
PCA9685 16-Channel 12-bit PWM Servo Motor Driver

PCA9685 – 16 Servo Motoren am Arduino

Der 16 Kanal Servo Treiber basiert auf dem Entwurf von Adafruit. In der China Variante ist er etwas günstiger. Die Platine hat 6 I2C  Adresspins. Damit wären 62 Treiber mit insgesamt 992 Ausgängen adressierbar. Das sollte reichen. Die Platinen kaskadiert man einfach mit einem 6-poligen Kabel hintereinander. Die Basisadresse des Boards ist 0x40 . Eine Lötbrücke bei A0 würde 0x41 ergeben.
Pegel und Betriebsspannung können 3,3 Volt als auch 5 Volt betragen.
Die Betriebsspannung setzt man am besten auf die des Mikrocontrollers. Damit hat man keine Pegel Probleme am I2C-Bus.
Die Servos sollte man auf jeden Fall über eine externe Spannungsquelle betreiben. Ein kleiner Stütz-Elko kann nachträglich eingelötet werden.
Die Ausgänge verfügen über 330 Ohm Widerstände um LED´s direkt zu treiben. Bei manchen Boards sind es 220 Ohm.

Der Arduino Uno wird wie folgt angeschlossen:

  • +5v -> VCC
  • GND -> GND
  • Analog 4 -> SDA
  • Analog 5 -> SCL

 



/*************************************************** 
  This is an example for our Adafruit 16-channel PWM & Servo driver
  Servo test - this will drive 16 servos, one after the other
  Pick one up today in the adafruit shop!
  ------> http://www.adafruit.com/products/815
  These displays use I2C to communicate, 2 pins are required to  
  interface. For Arduino UNOs, thats SCL -> Analog 5, SDA -> Analog 4
  Adafruit invests time and resources providing this open source code, 
  please support Adafruit and open-source hardware by purchasing 
  products from Adafruit!
  Written by Limor Fried/Ladyada for Adafruit Industries.  
  BSD license, all text above must be included in any redistribution
 ****************************************************/

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
// you can also call it with a different address you want
//Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x41);

// Depending on your servo make, the pulse width min and max may vary, you 
// want these to be as small/large as possible without hitting the hard stop
// for max range. You'll have to tweak them as necessary to match the servos you
// have!
#define SERVOMIN  150 // this is the 'minimum' pulse length count (out of 4096)
#define SERVOMAX  600 // this is the 'maximum' pulse length count (out of 4096)

// our servo # counter
uint8_t servonum = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("16 channel Servo test!");

  pwm.begin();
  
  pwm.setPWMFreq(60);  // Analog servos run at ~60 Hz updates

  yield();
}

// you can use this function if you'd like to set the pulse length in seconds
// e.g. setServoPulse(0, 0.001) is a ~1 millisecond pulse width. its not precise!
void setServoPulse(uint8_t n, double pulse) {
  double pulselength;
  
  pulselength = 1000000;   // 1,000,000 us per second
  pulselength /= 60;   // 60 Hz
  Serial.print(pulselength); Serial.println(" us per period"); 
  pulselength /= 4096;  // 12 bits of resolution
  Serial.print(pulselength); Serial.println(" us per bit"); 
  pulse *= 1000;
  pulse /= pulselength;
  Serial.println(pulse);
  pwm.setPWM(n, 0, pulse);
}

void loop() {
  // Drive each servo one at a time
  Serial.println(servonum);
  for (uint16_t pulselen = SERVOMIN; pulselen < SERVOMAX; pulselen++) { pwm.setPWM(servonum, 0, pulselen); } delay(500); for (uint16_t pulselen = SERVOMAX; pulselen > SERVOMIN; pulselen--) {
    pwm.setPWM(servonum, 0, pulselen);
  }

  delay(500);

  servonum ++;
  if (servonum > 7) servonum = 0;
}

China Post – 8-fach7-Segment, Taster und LED für Arduino

TM1638
TM1638 im Einsatz

TM1638 LED 7-Segmentanzeigen und Taster am Arduino

Im Artikel China Post – Arduino Multi Function Shield hatte ich bereits ein Arduino Shield mit LED-Anzeigen vorgestellt.
Eine weitere Möglichkeit am Arduino 7-Segment Anzeigen zu betreiben ist der IC TM1638.
Der TM1638 kann 10 Stellen 7-Segment Anzeige und  ein 3 x 8 Tastenfeld steuern. In der Praxis wird oft weniger umgesetzt. Die hier beschriebene Platine steuert 8x 7-Segment Anzeigen, 8x LED und 8x Taster an. Für die Ansteuerung sind nur 3 Digital Pins am Arduino erforderlich.Es ist kein Shield, welches für die Montage praktischer wäre. Mit 5 Kabeln ist aber auch die Verdrahtung kein Problem und die restlichen Pins sind ohne Einschränkung nutzbar.

Die Kommunikation ist nicht so trivial wie eine LED-Ansteuerung per Schieberegister. Daher greift man am einfachsten auf die TM1638 Bibliothek von Rjbatista zurück.
https://github.com/rjbatista/tm1638-library

Funktionen des Testprogramm tm1638_functions_example

  1. führende Nullen
  2. ohne führende Nullen, Dezimalpunk
  3. führende Nullen, hexadezimal
  4. ohne führende Nullen, hexadezimal
  5. binär
  6. Durchzählen der Digits
  7. 4 Digit Text + 4 Digit Ziffern
  8. wechselnder Text

Weitere Beispielprogramme zeigen die Anwendung von Lauftext und die Ansteuerung einzelner LED’s.
Es können auch Taster gleichzeitig gedrückt werden.

Es gibt neben dieser Platine noch weitere Ausführungen mit mehr Tastern , bzw. als kaskadierbare Anzeige.
Der Preis für Module mit dem TM1638 beginnt bei 5€.

/*
Library examples for TM1638.

Copyright (C) 2011 Ricardo Batista <rjbatista at gmail dot com>

This program is free software: you can redistribute it and/or modify
it under the terms of the version 3 GNU General Public License as
published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <TM1638.h>
#include <InvertedTM1638.h>

#define NO_MODULES  1

// define a regular module and a inverted module

// TM1638 module1(DIO, CLC, STB); 


TM1638 module1(51, 52, 53);

TM1638* modules[NO_MODULES] = {
  &module1,
  
};
byte modes[NO_MODULES];

unsigned long startTime;

void setup() {
  startTime = millis();
  
  for (int i = 0; i < NO_MODULES; i++) { modules[i]->setupDisplay(true, 7);
    modes[i] = 0;
  }
}

void update(TM1638* module, byte* mode) {
  byte buttons = module->getButtons();
  unsigned long runningSecs = (millis() - startTime) / 1000;
  
  // button pressed - change mode
  if (buttons != 0) {
    *mode = buttons >> 1;
    module->clearDisplay();
    module->setLEDs(0);
  }

  switch (*mode) {
    case 0:
      module->setDisplayToDecNumber(runningSecs, 1 << 7); break; case 1: module->setDisplayToDecNumber(runningSecs, 1 << 6, false); break; case 2: module->setDisplayToHexNumber(runningSecs, 1 << 5); break; case 4: module->setDisplayToHexNumber(runningSecs, 1 << 4, false); break; case 8: module->setDisplayToBinNumber(runningSecs, 1 << 3); break; case 16: module->clearDisplayDigit((runningSecs - 1) % 8, 0);
      module->setDisplayDigit(runningSecs % 8, runningSecs % 8, 0);
      break;
    case 32:
      char s[8];
      sprintf(s, "Secs %03d", runningSecs % 999);
      module->setDisplayToString(s);
      break;
    case 64:
      if (runningSecs % 2 == 0) {
        module->setDisplayToString("TM1638  ");
      } else {
        module->setDisplayToString("LIBRARY ");
      }

      module->setLED(0, (runningSecs - 1) % 8);
      module->setLED(1 + runningSecs % 3, runningSecs % 8);
      break;
    case 65:
      module->setDisplayToError();
      break;

  }
}

void loop() {
  for (int i = 0; i < NO_MODULES; i++) {
    update(modules[i], &modes[i]);
  }
}



China Post – IRF520 MOS FET Treiber

IRF520 MOS FET Driver
IRF520 MOS FET Driver

FET Treiber für den Arduino

Eigentlich ist es fast Verschwendung eine Platine für einen einzelnen Treiber Transistor zu verwenden. Falls man aber wirklich nur einen Hochstromausgang für den Arduino braucht, ist dieses Platine bequemer als ein Breadboard. Bei größeren Strömen benötigt man aber einen Kühlkörper.
Die Treiberplatine gibt es ab 2€. Den IRF520 bekommt man einzeln für 50 Cent.

Anwendungen IRF520 Platine

  • Power LED´s
  • Pumpen
  • Relais
  • Magnetventile
  • Elektromagnete
  • Gleichstrommotoren ohne Richtungssteuerung

Technischen Daten IRF520 MOS FET Driver Treiber

  • N-Channel MOSFET
  • Ausgangslastspannung: 0-24V
  • Ausgangslaststrom: Drain-Source Widerstand: 0,27 Ohm
  • Max. Verlustleistung: 50 Watt

https://arduinodiy.wordpress.com/2012/05/02/using-mosfets-with-ttl-levels/

Eigentlich ist aber der IRF520 für 5 Volt Mikrocontroller Anwendungen nicht ideal. Bei einer Gate Source Spannung von 5 Volt schafft er 3,5 A Laststrom. Es reicht für einige Anwendungen, nutzt aber den FET bei weiten nicht aus. Mit 3,3 Volt Controllern geht gar nichts.

Besser ist es daher MOS FET mit Logic Pegel der Typenreihe IRL zu verwenden. Ein IRLZ44N wäre eine bessere Alternative. Er ist auch nur 10 Cent teurer als IRF520
Leider gibt es bisher bei eBay nur Module mit dem IRF520.

China Post – Arduino Multi Function Shield

Arduino Multi Function Shield
Arduino Multi Function Shield

Einfaches Test Shield für den Arduino

Es gibt leider nur wenige und meist recht teure Arduino Shields mit einer LED 7-Segmentanzeige. Bei diesem Multi Function Shield ist wenigsten eine kleine Anzeige dabei und teuer ist es auch nicht. Daneben bietet es noch weitere Features.
Eigentlich sind 7-Segmentanzeige günstig und in diversen Ausführungen enthalten. Das verdrahten einer mehrstelligen Anzeige macht aber nicht so richtig Spaß.
Das Shield bekommt man ab 5€ bei eBay. Da neben der Anzeige noch weitere Funktionen integriert sind bietet es die Möglichkeit viele Funktionen des Arduinos auszuprobieren, ohne das zusätzliche Bauteile oder Verdrahtungsaufwand erforderlich ist.

Funktionen des Arduino Multi Function Shield

  • 4 digit 7-segment LED Display mit 2x 74HC595 Schieberegister
  • 4x LED
  • 10K Potentiometer als analoger Eingang
  • 3 x Taster
  • Piezo Buzzer
  • Sockel für DS18B20 Temperature Sensor
  • Sockel für Infrarot Empfänger
  • Sockel für BT Modul



Anbei ein kleines Programm um einige Funktionen zu testen:

//*******************************************************************************
//*******************************************************************************/
// LED D1 ... D4
#define LED1 10 
#define LED2 11 
#define LED3 12 
#define LED4 13 
int LEDS[]  =  {10,11,12,13};

// Taster
#define KEY1 A1 
#define KEY2 A2  
#define KEY3 A3  
unsigned char KEYS[]  =  {A1, A2, A3};

// Potentiometer
#define Poti A0 
int Spannung = 0;

// Schieberegister für 7-Segment
int latchPin   = 4;
int clockPin   = 7;
int dataPin   = 8; 

// Buzzer
#define Buz 3 

// 7-Segment
unsigned char Dis_table[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0X80,0X90};  // Ziffern 0 bis 7	
unsigned char Dis_buf[]   = {0xF1,0xF2,0xF4,0xF8};          // Schaltet die Segmente
unsigned char disbuff[]  =  {0, 0, 0, 0};


int SUM = 0;
int Flag_up = 1;
int Flag_up1 = 1;


void setup ()
{
  
 // LED D1 ... D4 
 for(int i=10; i<=13; i++)
 {
   pinMode(i, OUTPUT);
   digitalWrite(i,HIGH);
 }
  
 // Taster A1 bis A3 
 for(int i=0; i<=2; i++)
 {
   pinMode(KEYS[i],INPUT);			
   //pinMode(KEYS[i],INPUT_PULLUP);		
 } 
   
 // Potentiometer
 //pinMode(Poti,INPUT);
  
 // Buzzer
 pinMode(Buz,OUTPUT);
 digitalWrite(Buz,HIGH);
  
 // 7-Segment 
  pinMode(latchPin,OUTPUT);
  pinMode(clockPin,OUTPUT);
  pinMode(dataPin,OUTPUT); 
  
  // Anzeige ausschalten
     for(char i=0; i<=3; i++)
  {
    digitalWrite(latchPin,LOW); 
    shiftOut(dataPin,clockPin,MSBFIRST,0xFF); 
    shiftOut(dataPin,clockPin,MSBFIRST,Dis_buf[i] );  												
    digitalWrite(latchPin,HIGH); 
    delay(2);				
  } 
 
  
  Serial.begin(9600);

}

void led()
{
    for(int i=0; i<=3; i++)
 {
   digitalWrite(LEDS[i],HIGH);
   delay(1000);
   digitalWrite(LEDS[i],LOW);
   delay(1000);
 }
}

void taster ()
{
  for(int i=0; i<=2; i++)
  {	
  if(digitalRead(KEYS[i]) == LOW)
  {
    delay(20);						
    if(digitalRead(KEYS[i]) == LOW)		
    {
      digitalWrite(LEDS[i],LOW);				
      while(digitalRead(KEYS[i]) == LOW);	
    }
  }
  digitalWrite(LEDS[i],HIGH);
  }
}

void analog()
{
 Spannung = analogRead(Poti);
 Spannung = map(Spannung, 0, 1023, 0, 5000);
 Serial.print("Spannung = ");
 Serial.println(Spannung);
 delay(500);		
}
 
void pwm ()
{
analogWrite(LED1,analogRead(Poti));
}

void buzzer ()
{
digitalWrite(Buz,LOW);
delay(10);
digitalWrite(Buz,HIGH);
delay(100);
}

void display1(void)
{
     for(char i=0; i<=3; i++)
  {
    digitalWrite(latchPin,LOW); 
    shiftOut(dataPin,clockPin,MSBFIRST,Dis_table[disbuff[i]]); 
    shiftOut(dataPin,clockPin,MSBFIRST,Dis_buf[i] );  												
    digitalWrite(latchPin,HIGH); 
    delay(2);				
  }
} 

void display()

{
  for(int i=0; i<=3; i++)
  
  {
    digitalWrite(latchPin,LOW);
    shiftOut(dataPin,clockPin,MSBFIRST,Dis_table[disbuff[i]]); 
    shiftOut(dataPin,clockPin,MSBFIRST,Dis_buf[i] );
    digitalWrite(latchPin,HIGH);
    delay(2);
    /*  
    Serial.print("Index Ziffer: ");
    Serial.print("Dezimal= ");
    Serial.print(Dis_buf[i]);
    Serial.print("Binaer= ");
    Serial.print(Dis_buf[i],BIN);
    Serial.print(" Ziffer - dezimal: ");
    Serial.print(Dis_table[disbuff[i]]);
    Serial.print(" Binear: ");
    Serial.println(Dis_table[disbuff[i]],BIN);
  */
  }
  
}

void no_multiplex ()
{
  
  for(char i=0; i<=3; i++)
    digitalWrite(latchPin,LOW); 
    shiftOut(dataPin,clockPin,MSBFIRST,0b1111111);
    shiftOut(dataPin,clockPin,MSBFIRST,0B11111111 );  
    digitalWrite(latchPin,HIGH);    
    delay(2);
 
    delay(1000);
}

void counter ()
{
    SUM++;								
    disbuff[0]=SUM/1000;		
    disbuff[1]=SUM%1000/100;	
    disbuff[2]=SUM%100/10;		
    disbuff[3]=SUM%10;				
 }


void loop()
{
 //taster (); 
 //led(); 
 //display();
 //counter();  
 //analog(); 
 //pwm();
 //buzzer();
 }

China Post – LM2596 Step-Down Regler mit Voltmeter

LM2596 Step-Down
LM2596 Step-Down Regler mit LED Voltmeter

LM2596 – Günstige Step-Down Spannungsregler

Moderne Step-Down Regler sind ein Segen. Früher musste man die überflüssige Spannung (besser Leistung) mit einem 78XX IC (Linearregler) wegbrutzeln. Aus China kommen diverse Schaltregler die auf dem LM2596 IC basieren. Die Leistungsdaten dieser Platinen sind in etwa gleich. Manche bieten eine LED-Anzeige für Ein- und Ausgangsspannung.
Die Spannung wird über ein Spindelpotentiometer eingestellt. Die Anzeige ist abschaltbar und zeigt wahlweise die Ein- oder Ausgangsspannung an.

Typische Werte eines LM2596 DC-DC Spannungsregler

  • Eingangsspannungsbereich: 4V-40V
  • Ausgangsspannungsbereich: 1.25V~37V
  • Ausgangsstrom: 2A (max. 3A)
  • Oszillatorfrequenz: 150 kHz
  • Schutzmechanismen: Temperatur, Strombegrenzung
  • optional: LED Voltmeter Ein- und Ausgangsspannung

Ich persönlich mag die Module mit dem LED-Voltmeter. Diese gibt es bereits ab 3€.

Die Einsatzmöglichkeiten sind vielfältig:

  • Power LED versorgen
  • einfaches Labornetzteil
  • Modellbaumotoren regeln (fischertechnik usw.)