Arduino und MonsterMotorShield

Ein kleines Beispiel wie ihr mit dem Monster Motor Shield 2 Motoren ansteuern könnt:

[code]
/*
 * Das Monster Motor Shield kann mit diesem Sketch über den Seriellen Monitor gesteuert werden.
 * Einfach den Speed und die Richtung durch ein Komma getrennt eingeben.
 * Beispiel: 100,1
 * Dann drehen die Motoren mit der Geschwindigkeit 100 von 255 gegen den Uhrzeigersinn
 * Mögliche Werte:
 * Speed - 0 bis 255 (0 = Stop, 255 = volle Geschwindigkeit)
 * Richtung(Dir) - 0 bis 3 (0 = im Uhrzeigersinn, 1 = gegen den Uhrzeigersinn, 2 = Motoren drehen gegeneinander,
 * 3 = Motoren drehen umgekehrt gegeneinander)
 * Bei einem Fahrzeug mit 2 Motoren wäre das dann:
 * 0 = Vorwärts
 * 1 = Rückwärts
 * 2 = nach links drehen
 * 3 = nach rechts drehen
 *
 * VNH2SP30 pin definitions
 * inApin[2] = {7, 4};  // INA: Clockwise input
 * inBpin[2] = {8, 9}; // INB: Counter-clockwise input
 * pwmpin[2] = {5, 6}; // PWM input
 * cspin[2] = {2, 3}; // CS: Current sense ANALOG input
 * enpin[2] = {0, 1}; // EN: Status of switches output (Analog pin)
 *
 * http://arduinoinc.blogspot.de/
 */

#define CS_THRESHOLD 15   // Der max Strom der durch den Treiber auf Dauer unterstützt wird

int inApin[2] = {7, 4}; // IN-A: Im Uhrzeigersinn drehen, Motor0 and Motor1 (Check:"1.2 Hardware Monster Motor Shield").
int inBpin[2] = {8, 9}; // IN-B: Gegen den Uhrzeigersinn drehen, Motor0 and Motor1 (Check: "1.2 Hardware Monster Motor Shield").
int pwmpin[2] = {5, 6};            // PWM's input
int cspin[2] = {2, 3};              // Strom (A) Sensoren Motor 1/2

int statpin = 13;

int i=0;
int speedon = 0;
int speedaktuell = 0;
int dir = 0;
int diraktuell = 0;




void setup()                        
{
  Serial.begin(9600);
  Serial.println("Ready to start - Speed,Dir");
 
  pinMode(statpin, OUTPUT);
 
  for (int i=0; i<2; i++)
      {
        pinMode(inApin[i], OUTPUT);
        pinMode(inBpin[i], OUTPUT);
        pinMode(pwmpin[i], OUTPUT);
      }
     
  for (int i=0; i<2; i++)
      {
        digitalWrite(inApin[i], LOW);
        digitalWrite(inBpin[i], LOW);
      }
}



// **************************************************************

void loop()                         
{

  // Serielle Schnittstelle auslesen
  if (Serial.available() > 0)
  {
      // nach durch "," getrennte Werte lesen
      speedon = Serial.parseInt();
      dir = Serial.parseInt();
     
      if (Serial.read() == '\n')     // nach dem Ende der Zeile schauen
      {
        // Die Werte auf bestimmte Bereiche beschränken
        speedon = constrain(speedon, 0, 255);
        dir = constrain(dir, 0, 3);
      }
     
      Serial.println("Start");
      Serial.print("SpeedOn = ");
      Serial.println(speedon, DEC);
      Serial.print("Dir = ");
      Serial.println(dir, DEC);
  }
       
 
 
  beschleunigen(speedon, dir);
 
 
 
 
 
  // Auf neue Werte/Anweisungen warten und Überprüfen ob der motor nicht blockiert ist
 
  while(i!=0)
  {                                     
      if (Serial.available() > 0)
      {
        speedon = Serial.parseInt();
        dir = Serial.parseInt();
       
        if (Serial.read() == '\n')
        {
            speedon = constrain(speedon, 0, 255);
            dir = constrain(dir, 0, 3);
        }
       
        Serial.print("SpeedOn = ");
        Serial.println(speedon, DEC);
        Serial.print("Dir = ");
        Serial.println(dir, DEC);
      }
         
      if (dir != diraktuell) beschleunigen(1, diraktuell);
     
      if (speedaktuell != speedon) beschleunigen(speedon, dir);
     
      motorGo(dir, speedon);
     
      if (analogRead(cspin[0]) > CS_THRESHOLD)        
      {
        motorOff();
      }
     
  }
       
}
// **************************************************************



void beschleunigen(int endspeed, int dirx)
{
  // Beschleunigen des Motors auf "speedon"
  if (endspeed != 0)
  {
      if (endspeed > speedaktuell)  // Wenn die neue Geschwindigkeit größer ist, dann beschleunigen
      {
     
        Serial.println("beschleunigen");

        i = speedaktuell;
       
        while(i<endspeed)
        {
          motorGo(dirx, i);   // Den Motorspeed immer um 1/255 erhöhen     
          delay(50);                        
          i++;
                                  
          if (analogRead(cspin[0]) > CS_THRESHOLD) // Ist der Motor blockiert und der Strom wird zuhoch, abschalten.
          {
            motorOff();
          }
         
          digitalWrite(statpin, LOW);
     
        }
      }


      if (endspeed < speedaktuell)  // Wenn die neue Geschwindigkeit kleiner ist, dann entschleunigen
      {
     
        i = speedaktuell;
       
        Serial.println("entschleunigen");
       
        while(i>endspeed)
        {
          motorGo(dirx, i);   // Den Motorspeed immer um 1/255 erhöhen     
          delay(50);                        
          i--;
                                  
          if (analogRead(cspin[0]) > CS_THRESHOLD) // Ist der Motor blockiert und der Strom wird zuhoch, abschalten.
          {
            motorOff();
          }
         
          digitalWrite(statpin, LOW);
     
        }
      }
      Serial.println("Speed erreicht");
      diraktuell = dir;
      speedaktuell = endspeed;
      i=1;
  }
}



void motorOff()
{

  for (int i=0; i<2; i++)
  {
    digitalWrite(inApin[i], LOW);
    digitalWrite(inBpin[i], LOW);
  }
 
  analogWrite(pwmpin[0], 0);
  analogWrite(pwmpin[1], 0);
 
  i=0;
 
  digitalWrite(13, HIGH);
 
  Serial.println("Motor Locked");
 
  delay(1000);
}



void motorGo(uint8_t direct, uint8_t pwm)
{
    if (direct <=4)
    {
      if (direct == 0) // Go forward
      {
        digitalWrite(inBpin[0], LOW);
        digitalWrite(inBpin[1], LOW);
        digitalWrite(inApin[0], HIGH);
        digitalWrite(inApin[1], HIGH);
      }
         
      if (direct == 1)  // Go backward
      {
        digitalWrite(inApin[0], LOW);
        digitalWrite(inApin[1], LOW);
        digitalWrite(inBpin[0], HIGH);
        digitalWrite(inBpin[1], HIGH);
      }
 
      if (direct == 2)  // Go left
      {
        digitalWrite(inApin[0], LOW);
        digitalWrite(inBpin[1], LOW);
        digitalWrite(inBpin[0], HIGH);
        digitalWrite(inApin[1], HIGH);
      }
     
      if (direct == 3)  // Go right
      {
        digitalWrite(inBpin[0], LOW);
        digitalWrite(inApin[1], LOW);
        digitalWrite(inApin[0], HIGH);
        digitalWrite(inBpin[1], HIGH);
      }
       
      analogWrite(pwmpin[0], pwm);
      analogWrite(pwmpin[1], pwm);
    }
}
[/code]

ARDUINO und GPS - NMEA 0183 Protokoll lesen und auswerten

In diesem kleinen Post möchte ich mein Wissen zum bau eines kleinen GPS Moduls weitergeben. Ich musste selbe etwas aufwendiger suchen, um alle Informationen zu finden, die es mir dann recht schnell ermöglicht haben den GPS Receiver "HOLUX GM-210", mit dem NMEA 0183 Protokoll,
 die für mich interessanten Daten zu entlocken.

Was für Materialien hab ich benutzt?

• GPS Receiver HOLUX GM-210
• LCD 1602 (Idealer Weise mit UT-LCDmenueSensor Board)Wir
• ARDUINO Nano

Die Verdrahten des ARDUINOS mit dem GPS Receiver ist denkbar einfach, wenn man die richtigen Informationen hat. Wichtig ist es das man die TTL Datenanschlüsse (5V Signalpegel) benutzt und nicht die RS232 (12V Signalpegel) Anschlüsse.

Wir verbinden also den PIN2 vom GM-210 5V VDC mit den 5V Ausgang und den PIN4 Ground mit dem GND (Ground) am ARDUINO.

Jetzt noch den PIN3 Tx(TTL) mit einem Seriellen RxPin und den PIN5 Rx(TTL) mit dem TxPIN an dem ARDUINO.

So einfach ist die Hardware installiert.

Jetzt kommen wir zu der etwas größeren Aufgabe. Das Auslesen der Daten die uns das GPS sendet, und dann natürlich das Auswerten der Daten.
Denn wir wollen ja wissen wo wir sind, wie schnell wir sind und in welche Richtung wir uns bewegen.

Es stehen natürlich noch einige Daten mehr zu der Verfügung, aber die kann sich dann nach dem gleichen Prinzip jeder so anpassen wie er es gerne hätte.



Die Erklärung hab ich noch nicht ganz fertig, aber hier schon mal der Code:

*************************************************************


 #include <string.h>
 #include <ctype.h>

 #include <LiquidCrystal.h>
  // initialize the library with the numbers of the interface pins
  LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
 
 #include <SoftwareSerial.h>
  SoftwareSerial GPSserial(7, 6); // RX | TX

String inputString = "";         // a string to hold incoming data
boolean stringComplete = false;  // whether the string is complete



 void setup()
{

// initialize serial:
  Serial.begin(9600);
  GPSserial.begin(4800);
  // reserve 200 bytes for the inputString:
  inputString.reserve(200);

  lcd.begin(16, 2);
 
  lcd.print("GPS Modul");
  delay(2000);
 
}

 void loop()
 {
      serialEvent(); // Zeile einlesen
     
  // print the string when a newline arrives:
  if (stringComplete)
    {
      Serial.println(inputString);

      // you can also look for a substring in the middle of a string:
      // Ausgabe auf dem LCD
      if (inputString.substring(1,6) == "GPRMC")
        {
          Serial.println("Yes");
          String ausgabe = (inputString.substring(20, 29));
         
          lcd.clear();
         
          lcd.setCursor(0, 0);
          lcd.print("L:");
          lcd.setCursor(0, 1);
          lcd.print("B:");
         
          lcd.setCursor(3, 0);
          lcd.print(ausgabe);
          ausgabe = "";
          ausgabe = (inputString.substring(30, 31));
          lcd.setCursor(12, 0);
          lcd.print(ausgabe);
          ausgabe = "";
          ausgabe = (inputString.substring(32, 42));
          lcd.setCursor(3, 1);
          lcd.print(ausgabe);
          ausgabe = "";
          ausgabe = (inputString.substring(43, 44));
          lcd.setCursor(13, 1);
          lcd.print(ausgabe);
          ausgabe = "";
         
          delay(1000);
         
          int kommaS = inputString.indexOf(',', 46);
          ausgabe = (inputString.substring(45, kommaS - 1));
          float kmh = ausgabe.toFloat();
          kmh = kmh*1.852;

          lcd.clear();
         
          lcd.setCursor(0, 0);
          lcd.print("S:");
          lcd.setCursor(0, 1);
          lcd.print("W:");
 
          lcd.setCursor(3, 0);
          lcd.print(kmh, 6);
          ausgabe = "";
          int kommaW = inputString.indexOf(',', kommaS + 1);
          ausgabe = (inputString.substring(kommaS + 1, kommaW));
          lcd.setCursor(3, 1);
          lcd.print(ausgabe);
          ausgabe = "";
          delay(1000);
        }
     
      // clear the string:
      inputString = "";
      stringComplete = false;
    }
 }



 void serialEvent() {
  while (GPSserial.available())
    {
    // get the new byte:
    char inChar = (char)GPSserial.read();
   
    // add it to the inputString:
    inputString += inChar;
   
    // if the incoming character is a newline, set a flag
    // so the main loop can do something about it:
    if (inChar == '\n')
      {
        stringComplete = true;
      }
  }
}

Der kleine Laserplotter/-Cutter

Wie mein kleiner Laser-Plotter entstanden ist

Das Thema Laserplotter scheint im Internet und unter den E-Bastlern sehr verbreitet zu sein. Was mich aber nicht wunder, da es mich auch schnell gepackt hat und ich dem Fieber verfallen bin.

Also machte ich mich als erstes auf die Suche nach Informationen über Laser und über Schrittmotoren.

Was nicht ganz einfach war. Es gibt zwar viel im Netz, aber entweder ist es für Menschen die sich schon ausreichend mit der Technik auskennen geschrieben, oder mit nur sehr wenigen Informationen zu den Details.

Was ich hier versuchen möchte ist viele nützliche Informationen zusammen zu tragen und zu verlinken.

Der ARDUINO mit dem AFmotor Shield (L293D), 2 Stepper und ein Servo läuft ganz gut mit der Firmeware GcodeCNCdemo und zum senden der Daten (GCODE) teste ich gerade GcodeSender, auch von MarginallyClever.

Ausschneiden aus Kunststoff 

Da es immer noch Probleme mit der Einstellung von Stepps pro Millimeter gibt, muss eine neue Steuerung her.

Jetzt mit einem easyDriver Set und der GRBL Software. 

Für die nächste Ausbaustufe habe ich schon mal Material bestellt bei: www.alu-Profil-Technik.de

Superservice und gute Preise.

Facebookgruppe: Makerspace Minden

Messen mit dem Ultraschall Modul HC-SR04 mit Ausgabe am PC oder auf LCD

Informationen zum HC-SR04 (Robosoftsystem)

************************************************************************************
Start Quellcode
************************************************************************************
// Prozesortaktfrequent festlegen
#define F_CPU 16000000UL



// Baudrate
#define BAUD 19200UL

// Baudratenberechnung
#define UBRR_VAL ((F_CPU+BAUD*8) / (BAUD*16)-1)

// CR ist Zeilenumbruch
#define CR 0x0D


// Benötigte Bibliotheken hinzufügen
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>



// Variablen deklarieren
uint16_t rising, falling;     // Zum speichern der Timerwerte bei steigender und fallender Flanke
int counts;                         // Die Differenz der beiden Timerwerte (Signallänge in TimerTakten)
float dist;                          // Der berechnete Abstand in cm mit bis zu 6 Kommastellen
uint16_t us_per_count;    // Die Länge eines TimerTaktes in us



// ********************************************************************************************************************************************
// ****************************************************** Serielle Übertragung ****************************************************************
// UART-Init ATmega328P
void uart_init(void)
{
    // Baudrate einstellen
    UBRR0H = (unsigned char)(UBRR_VAL>>8);
    UBRR0L = (unsigned char)UBRR_VAL;
   
    // Receiver und Transmitter einschalten
    UCSR0B = (1<<RXEN0)|(1<<TXEN0);
   
    // Frame Format: Asynchron 8N1
    UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);
}



// Charakter schreiben (Ein Zeichen senden als ASCII)
void uart_putChar(unsigned char c)
{
    // Warten bis Sendepuffer leer ist
    while (!(UCSR0A & (1<<UDRE0)));
   
    // Daten in den Puffer schreiben und senden
    UDR0 = c;
}



// String senden (Einen Zeichenfolge in einzelne Zeichen zerlegen und an uart_putChar zum senden übergeben)
void uart_putStr(unsigned char *s)
{
    while (*s)
    {  
        // so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)"
        uart_putChar(*s);
        s++;
    }
}
// ********************************************************************************************************************************************





// ********************************************************************************************************************************************
// ************************************************* ISP **************************************************************************************

// Int. wenn die sich verändernde Flanke (von "1 nach 0 - fallende" oder von "0 nach 1 - steigende") erkannt wird. (An PIN PB0 (ARDUINO PIN 8))
ISR(TIMER1_CAPT_vect)
{
    if (TCCR1B & (1<<ICES1))     // (Wenn das Bit ICES1 im register TCCR1B = 1 ist, also einen steigende Flanke erkennt)
    {
        TCCR1B &= ~(1<<ICES1);     // (Erkennung umschalten auf fallende Flanke (Bit ICES1 im register TCCR1B = 0))
        rising = ICR1;                           // (Den beim auslösen des Int. im Register ICR1 gespeicherten Timer/Counter Wert in die Variable "rising" speichern)
    }
    else // (Wenn das Bit ICES1 im register TCCR1B = 0 ist, also einen fallende Flanke erkennt)
    {
        TCCR1B |= (1<<ICES1);     // (Erkennung umschalten auf steigende Flanke (Bit ICES1 im register TCCR1B = 1))
        falling = ICR1;                      // (Den beim auslösen des Int. im Register ICR1 gespeicherten Timer/Counter Wert in die Variable "falling" speichern)
        counts = falling - rising;        // die Differenz zwischen tEnd und tStart berechnen (z.B.: Steigende Flanke erkannt bei tStart=120, fallenden Flanke erkannt bei tEnd=670 - 670-120=tPuls=550)
        dist = (float)us_per_count * counts * 10 / 580;     // (Laufzeit Schall in Weg "cm" umrechnen)
    }
}



// Is triggered on timer match of OCR1A (Int. wenn der Vergleichswert in OCR1A erreicht ist)
ISR(TIMER1_COMPA_vect)
{
    // Generate a 12us pulse to trigger the HR-SR04
    PORTB ^= (1<<PIN2);
    _delay_us(12);
    PORTB ^= (1<<PIN2);
}
// ********************************************************************************************************************************************


int main(void)
{
    // Uart Init
    uart_init();
   
    unsigned char str[10];
   
    DDRB |= (1<<PIN2);      // PORTB PIN 2 as output
    DDRB |= (1<<PIN5);      // PORTB PIN 5 as output
   
   
   
    // ********************************************************************************************************************************************
    // *************************************************************** TIMER1 INIT ****************************************************************
    TCCR1B |= (1<<ICNC1) | (1<<CS10) | (1<<CS11) | (1<<WGM12);      //ICNC1:Rauschunterdrückung, CS10 and CS11: Prescale (Teiler) auf 64, WGM12: CTC-Modus auswählen
    TIMSK1 |= (1<<ICIE1) | (1<<OCIE1A);      // Int. auslösen bei: Erreichen von TOP, bei steigender bzw. fallender Flanke
    TCCR1B |= (1<<ICES1);      // Int. auslösen bei steigender Flanke
   
    // TOP berechnen (70ms Laufzeit für einene Cyclus): 16MHz/64 = 250000count/sek = 250000/1000 = 25000count/us / 100 * 70 = 17500 count/70ms
    OCR1A = 17500;


      
    // CPU-Takt / Prescale = Takte/Sek. 1Sek / Takt/Sek = 4 ( t = 4us/Takt)
    us_per_count = 4;

    sei();     //Interrupt global aktivieren


    // Endlosschleife
    while (1)
    {
        if (dist < 300)     // Wenn die Distanz innerhalb des Messbereiches (max. 300cm) liegt, ...
        {
            uart_putStr(dtostrf(dist, 1, 2, str));     // ... dann Ausgabe der Distanz mit 2 Stellen hinter dem Komma per Seriell
            uart_putStr(" cm");      // schreibe hinter dem Wert ein "cm"
            uart_putStr("\r");     // gehe zurück zum Anfang der Zeile
        }
        else     // Wenn nicht, ...
        {
            uart_putStr("ERROR");     // ... schreibe "ERROR" in dei Ausgabe
            uart_putStr("\r");     // gehe zurück zum Anfang der Zeile 
        }
       
       
        _delay_ms(250);
    }
}

**********************************************************************************
Ende Quellcode
**********************************************************************************



Diese Seiten habne mir geholfen das Projekt umzusetzen:

Attiny2313 Ultrasonic distance (HR-SR04) example

ATmega168/328-Arduino Pin Mapping
CONVERTWORLD.COM - Umrechnen von Einheiten ganz einfach

Mikrocontroller.net -High-Speed capture mit ATmega Timer

Infos über Timer auf Deutsch

Mikrocontroller.net - AVR-GCC-Tutorial/Die Timer und Zähler des AVR (passt nicht 100% zum ATmega328P aber man kann nützliche Infos finden die helfen zu verstehen)

RN-Wissen.de - Timer/Counter (Avr)

Vielen Dank!

Programmieren von AVR ATmega328P (ATmega 8Bit Prozessoren) in C und C++

Hallo zusammen,

Ich möchte in diesem Block meine persönlichen Erfahrungen in der Programmierung von Mikrocontrollern mit Euch teilen.

Ich werde diesen Blog Stück für Stück aufbauen und mit meinem Quellcode so wie mit interessanten Link versehen.

Wenn Ihr Ideen zu Projekten habt, lass mich das bitte wissen. Wenn Zeit und Muße stimmen, werde ich mich gerne daran beteiligen.

Geplante Versuche:

• Serielle Ausgabe UART
• ADC - Einen analogen Eingang nutzen
• Thermesensor
• PWM
• Ein Servo steuern
• LCD - ansteuern und benutzen
• ICP - Zeitmessung und Signalauswertung
• Ultraschall Modul HC-SR04
• Photodiode
• Funkmodul 433MHz