Quick Guide für Raspberry Pi: C/C++ mit Geany für Newbies

Atmel, PIC, VEX, Fischertechnik

Moderator: Moderatoren

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies (Baustelle)

Beitragvon HaWe » 22. Jan 2016 20:08

( I2C ) Ultraschall Sensoren Devantech SRF-02 und SRF-08 :

Bild Bild

Interface: I2C

Bezugsquellen:
z.B.:
http://www.exp-tech.de/srf02-ultrasonic-ranger
http://www.exp-tech.de/srf08-high-perfo ... ger-finder
http://www.robot-electronics.co.uk/htm/srf02techI2C.htm
http://www.ebay.de/sch/i.html?_from=R40 ... 9&_sacat=0


Literatur, Source Codes und Treiber :
http://www.robot-electronics.co.uk/htm/ ... amples.htm


Beispiel-Sourcecode:

Code: Alles auswählen

// SRF02 example coder for the Raspberry pi
//
// This code will work for the SRF02/ 10/ 235 and 08.
// It will take a ranging from the module and print results
// to the screen.
//
// By James Henderson, 2016.

#include <stdio.h>
#include <stdlib.h>
#include <linux/i2c-dev.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

int main(int argc, char **argv)
{
   printf("**** SRF02/10/235 example program ****\n");
   
   int fd;                                      // File descrition
   // For older raspberry pi modules use "/dev/i2c-0" instead of "/dev/i2c-1" for the i2c port
   char *fileName = "/dev/i2c-1";               // Name of the port we will be using
   int  address = 0x70;                         // Address of the SRF02 shifted right one bit
   unsigned char buf[10];                       // Buffer for data being read/ written on the i2c bus
   
   if ((fd = open(fileName, O_RDWR)) < 0) {     // Open port for reading and writing
      printf("Failed to open i2c port\n");
      exit(1);
   }
   
   if (ioctl(fd, I2C_SLAVE, address) < 0) {     // Set the port options and set the address of the device
      printf("Unable to get bus access to talk to slave\n");
      exit(1);
   }
   
   buf[0] = 0;                                  // Commands for performing a ranging
   buf[1] = 81;
   
   if ((write(fd, buf, 2)) != 2) {              // Write commands to the i2c port
      printf("Error writing to i2c slave\n");
      exit(1);
   }
   
   usleep(900000);                              // This sleep waits for the ping to come back
   
   buf[0] = 0;                                  // This is the register we wish to read from
   
   if ((write(fd, buf, 1)) != 1) {              // Send the register to read from
      printf("Error writing to i2c slave\n");
      exit(1);
   }
   
   if (read(fd, buf, 4) != 4) {                 // Read back data into buf[]
      printf("Unable to read from slave\n");
      exit(1);
   }
   else {
      unsigned char highByte = buf[2];
      unsigned char lowByte = buf[3];
      unsigned int result = highByte;            // Calculate range as a word value
      result <<= 8;
      result += lowByte;
      printf("Software v: %d\n",buf[0]);
      printf("Range was: %u\n",result);
   }
   
   close(fd);   
   
   return 0;
}

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies (Baustelle)

Beitragvon HaWe » 22. Jan 2016 20:08

( I2C ) Board MD25 - Dual H Bridge Motor Drive :
(MD25 - Dual 12Volt 2.8Amp H Bridge Motor Drive, i2c Motortreiberplatine für Encodermotoren)

Bild
https://www.robot-electronics.co.uk/htm/md25tech.htm

passende Encodermotoren :
EMG30 - Getriebemotor mit Encodern :
Bild
https://www.robot-electronics.co.uk/htm/emg30.htm

Bezugsquellen z.B.:
http://www.roboter-teile.de/Oxid/Motor- ... -MD25.html
http://www.exp-tech.de/emg30-getriebemo ... -drehgeber

Beispiel für die Ansteuerung :
Quelle: http://www.robot-electronics.co.uk/htm/ ... amples.htm
http://www.robot-electronics.co.uk/files/rpi_md25.c

Code: Alles auswählen

// MD25 example c code for the Raspberry pi.
//
// Drives both motors untill an encoder count of over 0x2000
// is reached and stops the motors. Displays the current decoder value.
//
// By James Henderson, 2016

#include <stdio.h>
#include <stdlib.h>
#include <linux/i2c-dev.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

long readEncoderValues(void);                        // Reads encoder data for both motors and displays to the screen
void resetEncoders(void);                           // Resets the encoders to 0
void driveMotors(void);                              // Drive the motors forwards
void stopMotors(void);                              // Stop the motors

int fd;                                          // File descrition
// For older raspberry pi modules use "/dev/i2c-0" instead of "/dev/i2c-1" for the i2c port
   char *fileName = "/dev/i2c-1";                        // Name of the port we will be using
int  address = 0x58;                              // Address of MD25 shifted one bit                              
unsigned char buf[10];                              // Buffer for data being read/ written on the i2c bus

int main(int argc, char **argv)
{
   printf("**** MD25 test program ****\n");
      
   if ((fd = open(fileName, O_RDWR)) < 0) {               // Open port for reading and writing
      printf("Failed to open i2c port\n");
      exit(1);
   }
   
   if (ioctl(fd, I2C_SLAVE, address) < 0) {               // Set the port options and set the address of the device we wish to speak to
      printf("Unable to get bus access to talk to slave\n");
      exit(1);
   }
   
   buf[0] = 13;                                    // This is the register we wish to read software version from
   
   if ((write(fd, buf, 1)) != 1) {                        // Send regiter to read software from from
      printf("Error writing to i2c slave\n");
      exit(1);
   }
   
   if (read(fd, buf, 1) != 1) {                        // Read back data into buf[]
      printf("Unable to read from slave\n");
      exit(1);
   }
   else {
      printf("Software version: %u\n", buf[0]);
   }
   
   resetEncoders();                                 // Reset the encoder values to 0
   
   while(readEncoderValues() < 0x2000) {                  // Check the value of encoder 1 and stop after it has traveled a set distance
       driveMotors();
       usleep(200000);                              // This sleep just gives us a bit of time to read what was printed to the screen in driveMortors()
   }
   
   stopMotors();
   return 0;
}

void resetEncoders(void) {
   buf[0] = 16;                                    // Command register
   buf[1] = 32;                                    // command to set decoders back to zero
   
   if ((write(fd, buf, 2)) != 2) {
      printf("Error writing to i2c slave\n");
      exit(1);
   }
}

long readEncoderValues (void) {
   
   long encoder1, encoder2;
   
   buf[0] = 2;                                       // register for start of encoder values
   
   if ((write(fd, buf, 1)) != 1) {
      printf("Error writing to i2c slave\n");
      exit(1);
   }
   
   if (read(fd, buf, 8) != 8) {                        // Read back 8 bytes for the encoder values into buf[]
      printf("Unable to read from slave\n");
      exit(1);
   }
   else {
      encoder1 = (buf[0] <<24) + (buf[1] << 16) + (buf[2] << 8) + buf[3];   // Put encoder values together
      encoder2 = (buf[4] <<24) + (buf[5] << 16) + (buf[6] << 8) + buf[7];
      printf("Encoder 1: %08lX   Encoder 2: %08lX\n",encoder1, encoder2);
   }
   return encoder1;   
}

void driveMotors(void){
   buf[0] = 0;                                       // Register to set speed of motor 1
   buf[1] = 200;                                    // speed to be set
   
   if ((write(fd, buf, 2)) != 2) {
      printf("Error writing to i2c slave\n");
      exit(1);
   }
   
   buf[0] = 1;                                       // motor 2 speed
   buf[1] = 200;                                    
   
   if ((write(fd, buf, 2)) != 2) {
      printf("Error writing to i2c slave\n");
      exit(1);
   }
}

void stopMotors(void){
   buf[0] = 0;                                       
   buf[1] = 128;                                    // A speed of 128 stops the motor
   
   if ((write(fd, buf, 2)) != 2) {
      printf("Error writing to i2c slave\n");
      exit(1);
   }
   
   buf[0] = 1;                                       
   buf[1] = 128;                                    
   
   if ((write(fd, buf, 2)) != 2) {
      printf("Error writing to i2c slave\n");
      exit(1);
   }
}



Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies (Baustelle)

Beitragvon HaWe » 23. Jan 2016 10:18

Adafruit DC and Stepper Motor HAT for Raspberry Pi

Bild

https://learn.adafruit.com/adafruit-dc- ... g-software

nicht brauchbar und nicht empfehlenswert, da für C/C++ keine Libraries, kein Treiber-Sourcecode und kein Support

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies (Baustelle)

Beitragvon HaWe » 23. Jan 2016 10:18

(dig. GPIO) :
Pololu Dual MC33926 Motortreiber for Raspberry Pi

Bild

ein alternatives, sehr leistungsstarkes und kompaktes Motortreiber HAT mit einer etwas anderen Pin-Belegung und Steuer-Logik:

http://www.ebay.de/itm/272182305548?_tr ... EBIDX%3AIT



Code: Alles auswählen

MC33926
http://www.ebay.de/itm/272182305548?_trksid=p2060353.m2749.l2649&ssPageName=STRK%3AMEBIDX%3AIT

Default pin mappings

This table shows how the Raspberry Pi’s GPIO pins are used to interface with the motor drivers:
---------------------------------------------------------------------------------------------------------
RPi
GPIO     Motor driver pin    Description
---------------------------------------------------------------------------------------------------------
5    Motor 1 SF              Status flag output: When the driver is functioning normally,
                                this pin should be pulled high by the Raspberry Pi.
                                In the event of a driver fault , the driver IC drives SF low.
                                If either of the disable pins (D1 or D2) is disabling the outputs,
                                SF will also be low.
6    Motor 2 SF              dto.
---------------------------------------------------------------------------------------------------------
12    Motor 1 PWM             Motor speed input: A PWM (pulse-width modulation) signal on this pin
                                corresponds to a PWM output on the corresponding driver’s motor outputs.
                                When this pin is low, the motor brakes low.
                                When it is high, the motor is on.
                                The maximum allowed PWM frequency is 20 kHz.
13    Motor 2 PWM             dto.
---------------------------------------------------------------------------------------------------------
22    Motor 1 EN              Enable input: This pin is internally pulled low,
                                putting the motor driver IC into a low-current sleep mode
                                and disabling the motor outputs (setting them to high impedance).
                                EN must be driven high to enable the motor driver.
23    Motor 2 EN              dto.
---------------------------------------------------------------------------------------------------------
24    Motor 1 DIR             Motor direction input: When DIR is low, motor current flows
                                from output A to output B;
                                when DIR is high, current flows from B to A.
25    Motor 2 DIR             dto.
---------------------------------------------------------------------------------------------------------
 
Simplified motor control truth table

This table shows how the drivers’ control inputs affect the motor outputs:
---------------------------------------------------------------------------------------
Inputs                             Outputs
---------------------------------------------------------------------------------------
EN      DIR        PWM        MxA       MxB       operating mode
---------------------------------------------------------------------------------------
1        0         PWM      PWM(H/L)     L        forward/brake at speed PWM %
1        1         PWM         L      PWM(H/L)    reverse/brake at speed PWM %
1        X          0          L         L        brake low (outputs shorted to ground)
0        X          X          Z         Z        coast (outputs off)
---------------------------------------------------------------------------------------

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Quick Guide für Raspberry Pi: C/C++ mit Geany für Newbies

Beitragvon HaWe » 23. Jan 2016 10:18

Platzhalter

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies (Baustelle)

Beitragvon HaWe » 23. Jan 2016 10:18

Platzhalter

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies (Baustelle)

Beitragvon HaWe » 23. Jan 2016 10:20


DONATE / SPENDE:
Gefällt dir dieses Kompendium und möchtest du dafür einen kleinen Betrag über PAYPAL spenden ?
Dann klicke einfach auf diesen Link -
Ab einer Spende ab EUR 5,- kannst du auf Wunsch dieses Kompendium auch als kostenloses WORD.doc erhalten (per Email oder Download als .zip):

-> Ja, ich möchte etwas als Anerkennung spenden <-


Ein ganz herzliches Dankeschön! :prima:

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies (Baustelle)

Beitragvon HaWe » 23. Jan 2016 10:20

i2c Multiplexer für den Raspi:

( I2C ) MCP23017 : 16x I/O-Multiplexer

MCP23017.jpg

https://www.adafruit.com/product/732

Der Baustein arbeitet bereits ab 1,8 V Versorgungsspannung einwandfrei, was für den RasPi mit seinen 3.3V ideal ist,
außerdem unterstützt er Normal-, Fast- und High-speed I2C ( 100 kHz, 400 kHz, 1.7MHz).
Die Pins können bankweise (8er-Gruppen) in Output-oder Input-Modus gesetzt werden, im Input-Modus können wahlweise zusätzlich interne Pullps zugeschaltet werden (Tasten dann gegen Masse, d.h. LOW wenn gedrückt).
http://www.netzmafia.de/skripten/hardware/RasPi/Projekt-I2C-Expander/index.html
https://cdn-shop.adafruit.com/datasheets/mcp23017.pdf


Bild
MCP23017_4+4.jpg


Programmier-Links:
http://www.netzmafia.de/skripten/hardware/RasPi/Projekt-I2C-Expander/index.html
http://wiringpi.com/examples/testing-wiringpi-v2/
http://wiringpi.com/extensions/i2c-mcp23008-mcp23017/
http://raspi.tv/2013/using-the-mcp23017-port-expander-with-wiringpi2-to-give-you-16-new-gpio-ports-part-3
http://hertaville.com/interfacing-an-i2c-gpio-expander-mcp23017-to-the-raspberry-pi-using-c.html
https://github.com/ve3wwg/raspberry_pi/blob/master/mcp23017/mcp23017.c

MCP23017-1I1O_bb-1024x718.jpg



wiringPi Basis-Funktionen (Teststadium):
uint8_t data;
#define MCP23017_0_addr 0x20 // i2c base addr: 0x20...0x27 by A0-A2 low or high


// WiringPi I2C Setup: i2c-1, dev_addr=0x20
int fmcp23017_0= wiringPiI2CSetupInterface("/dev/i2c-1", MCP23017_0_addr);

xxxx

// init banks for read or write:
// SET I/O direction register 0x00 is bank A ( bank B == 0x01)
// set bank pins A or B 0x00 = output mode , 0xFF = input mode + internal pullups
wiringPiI2CWriteReg8 (fmcp23017_0, 0x00, 0x00); // bank A := init as output (0x00)
wiringPiI2CWriteReg8 (fmcp23017_0, 0x01, 0xff); // bank B := init as input_pullup (0xff)

// read data or write data to banks A or B:
// DATA register 0x12 = bank "A" ( bank "B" = 0x13)
wiringPiI2CWriteReg8 (fmcp23017_0, data, 0x12); // write data to bank A register (0x12)
data = wiringPiI2CReadReg8 (fmcp23017_0, 0x13); // read bank B data register (0x13)




Demo Code von Gordon Henderson:
WiringPi driver code (stress test): http://wiringpi.com/examples/testing-wiringpi-v2/

Code: Alles auswählen

/*
 * stress.c:
 *      WiringPi stress test
 *
 * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
 ***********************************************************************
 */

#include <stdio.h>
#include <wiringPi.h>
#include <mcp23s17.h>
#include <mcp23017.h>
#include <sr595.h>

// The first pin number for each device

#define BASE_SPI        123
#define BASE_I2C        456
#define BASE_SR         789

int main (void)
{
  int i, bit ;

  wiringPiSetup () ;
  mcp23017Setup (BASE_I2C, 0x20) ;
  mcp23s17Setup (BASE_SPI, 0, 0) ;
  sr595Setup    (BASE_SR, 10, 0, BASE_SPI, BASE_I2C) ;

  printf ("Raspberry Pi - MCP23S17 + MCP23017 + 74x595 Test\n") ;

// For the push button to stop it...

  pinMode         (BASE_I2C + 15, INPUT) ;
  pullUpDnControl (BASE_I2C + 15, PUD_UP) ;

  for (;;)
  {
    for (i = 0 ; i < 1024 ; ++i)
    {
      for (bit = 0 ; bit < 10 ; ++bit)
        digitalWrite (BASE_SR + bit, i & (1 << bit)) ;
      delay (5) ;
      while (digitalRead (BASE_I2C + 15) == 0)
        delay (1) ;
    }
  }
  return 0 ;
}



Code ohne wiringPi:
http://www.netzmafia.de/skripten/hardwa ... index.html

expander_lib.h

Code: Alles auswählen

#ifndef _EXPANDERLIB_H_
#define _EXPANDERLIB_H_

/* Richtungsregister von Port A und Port B */
#define IODIRA 0x00
#define IODIRB 0x01

/* Datenregister Port A und Port B */
#define GPIOA 0x12
#define GPIOB 0x13

/* Register um Logik-Polaritaet umzustellen */
#define IPOLA 0x02
#define IPOLB 0x03

/* Interne Pull-Up-Widerstände einschalten */
#define GPPUA 0x0C
#define GPPUB 0x0D

/* Pins am Port */
#define P1 0x01
#define P2 0x02
#define P3 0x04
#define P4 0x08
#define P5 0x10
#define P6 0x20
#define P7 0x40
#define P8 0x80


/* Struktur fuer den Expander-Datentyp */
struct expander
  {
  int address;      /* I2C-Bus-Adresse des Bausteines      */
  int directionA;   /* Datenrichtung Port A                */
  int directionB;   /* Datenrichtung Port B                */
  char* I2CBus;     /* I2C-Device ("/dev/i2c-1" für Bus 1) */
  };
/* Expander-Datentyp */
typedef struct expander mcp23017;

/* Init des Expanders; gibt den Expander zurück
 * address: I2C-Busadresse des Bausteines (i2cdetect -y 1)
 * directionA/B: Richtungen der Ports
 * I2CBus: Pfad zum I2CBus ("/dev/i2c-1" für Bus 1)
 */
mcp23017 init_mcp23017(int address, int directionA, int directionB, char* I2CBus);

/* Datenrichtung der Ports festlegen
 * richtungsregister: muss "IODIRA" oder "IODIRB" sein!
 * value: Zuordnung der Bits (Input: 1, Output: 0)
 * Bei den Eingangspins wird der Pullup-Widerstand eingeschaltet und die Logik umgekehrt
 */
void setdir_mcp23017(mcp23017 expander, int richtungsregister, int value);

/* Oeffnet den Bus und gibt Filedescriptor zurueck
 * (write_mcp23017 und read_mcp23017 übernehmen das selbst)
 */
int open_mcp23017(mcp23017 expander);

/* Schreibt in ein Register des Expanders
 * reg: Register in das geschrieben werden soll
 * value: Byte das geschrieben werden soll
 */
void write_mcp23017(mcp23017 expander, int reg, int value);

/* Liest Register des Expanders
 * reg: Register, das ausgelesen wird;
 * gibt ausgelesenen Registerwert zurück
 */
int read_mcp23017(mcp23017 expander, int reg);

#endif /* EXPANDERLIB_H */


expander_lib.c

Code: Alles auswählen

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/i2c-dev.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


#include "expander_lib.h"

/* defined in <linux/i2c-dev.h>
#define I2C_SLAVE 0x703 */


/* Init des Expanders; gibt den Expander zurück
 * address: I2C-Busadresse des Bausteines (i2cdetect -y 1)
 * directionA/B: Richtungen der Ports
 * I2CBus: Pfad zum I2CBus ("/dev/i2c-1" für Bus 1)
 */
mcp23017 init_mcp23017(int address, int directionA, int directionB, char* I2CBus)
{
  int fd;             /* Filehandle */
  mcp23017 expander;  /* Rueckgabedaten */

  /* Structure mit Daten fuellen */
  expander.address = address;
  expander.directionA = directionA;
  expander.directionB = directionB;
  expander.I2CBus = I2CBus;

  // Port-Richtung (Eingabe/Ausgabe) setzen
  fd = open_mcp23017(expander);
  setdir_mcp23017(expander, IODIRA, expander.directionA);
  setdir_mcp23017(expander, IODIRB, expander.directionB);
  close(fd);
  return expander;
}

/* Datenrichtung der Ports festlegen
 * richtungsregister: muss "IODIRA" oder "IODIRB" sein!
 * value: Zuordnung der Bits (Input: 1, Output: 0)
 * Bei den Eingangspins wird der Pullup-Widerstand eingeschaltet und die Logik umgekehrt
 */
void setdir_mcp23017(mcp23017 expander, int richtungsregister, int value)
{
  if(richtungsregister == IODIRA)
    {
    /* Datenrichtung schreiben */
    write_mcp23017(expander, IODIRA, value);
    /* Pull-Up-Widerstaende einschalten Port A */
    write_mcp23017(expander, GPPUA, value);
    /* Logik umkehren */
    write_mcp23017(expander, IPOLA, value);
    }
  else if(richtungsregister == IODIRB)
    {
    /* Datenrichtung schreiben */
    write_mcp23017(expander, IODIRB, value);
    /* Pull-Up-Widerstaende einschalten Port B */
    write_mcp23017(expander, GPPUB, value);
    /*Logik umkehren */
    write_mcp23017(expander, IPOLB, value);
    }
  else
    {
    printf("Richtungsregister falsch!\n");
    exit(1);
    }
}

/* Oeffnet den Bus und gibt Filedescriptor zurueck
 * (write_mcp23017 und read_mcp23017 übernehmen das selbst)
 */
int open_mcp23017(mcp23017 expander)
{
  int fd;
  if ((fd = open(expander.I2CBus, O_RDWR)) < 0)
    {
    printf("Failed to open the i2c bus\n");
    exit(1);
    }

  /* Spezifizieren der Adresse des slave device */
  if (ioctl(fd, I2C_SLAVE, expander.address) < 0)
    {
    printf("Failed to acquire bus access and/or talk to slave\n");
    exit(1);
    }
  return fd;
}

/* Schreibt in ein Register des Expanders
 * reg: Register in das geschrieben werden soll
 * value: Byte das geschrieben werden soll
 */
void write_mcp23017(mcp23017 expander, int reg, int value)
{
  int fd;
  fd = open_mcp23017(expander);
  if(i2c_smbus_write_byte_data(fd,reg,value) < 0)
    {
    printf("Failed to write to the i2c bus\n");
    exit(1);
    }
  close(fd);
}

/* Liest Register des Expanders
 * reg: Register, das ausgelesen wird;
 * gibt ausgelesenen Registerwert zurück
 */
int read_mcp23017(mcp23017 expander, int reg)
{
   int value,fd;
   fd = open_mcp23017(expander);
   if((value = i2c_smbus_read_byte_data(fd, reg)) < 0)
     {
     printf("Failed to read from the i2c bus\n");
     close(fd);
     exit(1);
     return 0;
     }
   else
     {
     close(fd);
     return value;
     }
}



Beispiel: Lauflicht

Code: Alles auswählen

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "expander_lib.h"

int main(int argc, char *argv[])
{
  mcp23017 expander;  /* Verwaltungs-Structure */
  int data = 0x01;    /* Ausgabewert */
  int down = 0;       /* Richtungsangabe */

  expander = init_mcp23017(0x20,0,0,"/dev/i2c-1");

  while(1)
    {
    /* beide Ports identisch "bedienen" */
    write_mcp23017(expander,GPIOA,data);
    write_mcp23017(expander,GPIOB,data);

    if (data == 0x80) /* ganz links - umdrehen */
      down = 1;
    if (data == 0x01) /* ganz rechts - umdrehen */
      down = 0;

    if (down)
       data = data >> 1;
    else
       data = data << 1;
    usleep(100000); /* 100 ms Pause */
    }

  return 0;
}



Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies (Baustelle)

Beitragvon HaWe » 23. Jan 2016 10:20

( I2C ) MCP23008 : 8x I/O Multiplexer

Bild

mit wiring Pi: s. http://wiringpi.com/extensions/i2c-mcp23008-mcp23017/


per i2c-dev.h, ohe wiringPi:

Schema zum Lesen von x Bytes vom Register y eines I2C Gerätes.

1) 1 Byte schreiben mit dem Wert y an das Gerät (file handle).
2) Lesen von x Bytes vom Gerät.

Code: Alles auswählen

    int  fd = open("/dev/i2c-1", O_RDWR);
    int result = ioctl(fd, I2C_SLAVE, ADDR);  // I2C_SLAVE: macro in i2c-dev.h;  ADDR = device address
    unsigned char buffer[x]; // x = buffer size
   
    buf[0] = regaddr;
    write(fd, buf, 1);
    c = read(fd, buf, x);
    if (c == x)
    {
       /* good read */
    }



für MCP23008 read 2 bytes (input registers):
write 1 Byte 0x09 to device (data address)
read 2 bytes (from data-address 0x09)

should get a value of 0xF0 with no inputs

Code: Alles auswählen


#include <linux/i2c-dev.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdint.h>
#include <errno.h>
#include <string.h>

#define   ADDR   0x20

#define   IODIR   0x00
#define   GPINTEN   0x02
#define   DEFVAL   0x03
#define   INTCON   0x04
#define   IOCON   0x05
#define   GPPU   0x06
#define   INTCAP   0x08
#define   GPIOA   0x09

#define a(...) (unsigned char[])__VA_ARGS__
int i, fd, result;
unsigned char buffer[60]={0};
unsigned char data;

int MCPinit(){
   printf("start\n");

   fd = open("/dev/i2c-1", O_RDWR);
   if (fd < 0) fprintf(stderr," Error Opening Device!\n");
   
   result = ioctl(fd, I2C_SLAVE, ADDR);
   if (result < 0) fprintf(stderr," Error  bus access!\n");
   
   write(fd, a({GPIOA,0xF0}), 2);
   write(fd, a({IODIR,0xF0}), 2);
   write(fd, a({INTCON,0xF0}), 2);
   write(fd, a({DEFVAL,0xF0}), 2);
   write(fd, a({GPINTEN,0xF0}), 2);
   write(fd, a({GPPU,0xF0}), 2);
}

int main(){   
   MCPinit();

  while(1){
      buffer[0] = 0x09;
      write(fd,buffer,1);
      result = read(fd, buffer, 2);
      if (result = 2){
         printf("Data read: %d %d \n", buffer[0], buffer[1] );
      }
   }
   
   return 0;
}

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies (Baustelle)

Beitragvon HaWe » 23. Jan 2016 10:20


DONATE / SPENDE:
Gefällt dir dieses Kompendium und möchtest du dafür einen kleinen Betrag über PAYPAL spenden ?
Dann klicke einfach auf diesen Link -
Ab einer Spende ab EUR 5,- kannst du auf Wunsch dieses Kompendium auch als kostenloses WORD.doc erhalten (per Email oder Download als .zip):

-> Ja, ich möchte etwas als Anerkennung spenden <-


Ein ganz herzliches Dankeschön! :prima:

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies

Beitragvon HaWe » 28. Feb 2016 11:27

SPI Multiplexer für den Raspi:

( SPI ) MCP23S17 : 16x I/O-Multiplexer

für den MCP23017 gibt es auch diese SPI Ausführung, per WiringPi ähnlich simpel zu programmieren wie die I2C Variante

http://wiringpi.com/extensions/spi-mcp23s08-mcp23s17/

In mcp23s17Setup(), there are 3 parameters: pinBase, spiPort and devId.

The pinBase is the new pin number of the first pin of the device - any number >= 64 that you like.
The spiPort is the CE line - 0 or 1
The devId is the devuce sub-address 0 through 7.

So if you have 2 mcp23s17's on the same SPI bus, then you initialise the first one with

mcp23s17Setup (base1, 0, 0);

and the second with

mcp23s17Setup (base2, 1, 0);

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies

Beitragvon HaWe » 28. Feb 2016 11:27

( I2C ) PCF8591: 4x ADC + 1x DAC

Bild
Bild

Der IC arbeitet nur mit bis zu 100kHz, allerdings bei 2,5-6,0V und ist also auch für den Pi mit 3,3V Spannung geeignet.
https://www.mikrocontroller.net/part/PCF8591

driver source code: Potentiometer als analoge Inputs steuern LED Helligkeit (analoger output) simultan:
http://wiringpi.com/examples/quick2wire-and-wiringpi/the-analog-interface-board/

Code: Alles auswählen

/*
 * bright.c:
 *      Vary the Q2W LED brightness with the analog card
 *
 * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
 ***********************************************************************
 */
#include <stdio.h>
#include <wiringPi.h>
#include <pcf8591.h>

#define LED               1
#define Q2W_ABASE       120

int main (void)
{
  int value ;

// Enable the on-goard GPIO
  wiringPiSetup () ;

// Add in the pcf8591 on the q2w board
  pcf8591Setup (Q2W_ABASE, 0x48) ;
  printf ("Raspberry Pi - Quick2Wire Analog Test\n") ;

// Setup the LED
  pinMode  (LED, PWM_OUTPUT) ;
  pwmWrite (LED, 0) ;
  for (;;)  {
    value = analogRead  (Q2W_ABASE + 0) ;
    pwmWrite (LED, value * 4) ;
    delay (5) ;
  }
  return 0 ;
}

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies

Beitragvon HaWe » 28. Feb 2016 11:27

Platzhalter

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies

Beitragvon HaWe » 28. Feb 2016 11:27


DONATE / SPENDE:
Gefällt dir dieses Kompendium und möchtest du dafür einen kleinen Betrag über PAYPAL spenden ?
Dann klicke einfach auf diesen Link -
Ab einer Spende ab EUR 5,- kannst du auf Wunsch dieses Kompendium auch als kostenloses WORD.doc erhalten (per Email oder Download als .zip):

-> Ja, ich möchte etwas als Anerkennung spenden <-


Ein ganz herzliches Dankeschön! :prima:

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 5402
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

Re: Quick Guide für Raspberry Pi: C/C++ mit Geany für Dummies

Beitragvon HaWe » 28. Feb 2016 11:28

( 1-wire ) DHT11 Humidity & Temperature Sensor Module :

Bild

Lit.: http://www.uugear.com/portfolio/dht11-h ... or-module/

Preis: ab 1 EUR (z.B. Ebay)

Power Supply: 3.3~5.5V DC
Output: 4 pin single row
Measurement Range: Humidity 20-90%RH, Temperature 0~50℃
Accuracy: Humidity +-5%RH, Temperature +-2℃
Resolution: Humidity 1%RH, Temperature 1℃
Interchangeability: Fully Interchange

Anschluss-Schema:
Raspberry Pi ——————– DHT11 Module
3.3v P1 —————————– VCC (V)
GND P6 —————————- GND (G)
GPIO4 P7 ————————– DATA (S)

Test-Code (nach http://www.uugear.com/portfolio/dht11-h ... or-module/)

Code: Alles auswählen

/*
 *  dht11.c:
 *   Simple test program to test the wiringPi functions
 *   DHT11 test
 */

#include <wiringPi.h>

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#define MAXTIMINGS   85
#define DHTPIN      7
int dht11_dat[5] = { 0, 0, 0, 0, 0 };

void read_dht11_dat()
{
   uint8_t laststate   = HIGH;
   uint8_t counter      = 0;
   uint8_t j      = 0, i;
   float   f; /* fahrenheit */

   dht11_dat[0] = dht11_dat[1] = dht11_dat[2] = dht11_dat[3] = dht11_dat[4] = 0;

   /* pull pin down for 18 milliseconds */
   pinMode( DHTPIN, OUTPUT );
   digitalWrite( DHTPIN, LOW );
   delay( 18 );
   /* then pull it up for 40 microseconds */
   digitalWrite( DHTPIN, HIGH );
   delayMicroseconds( 40 );
   /* prepare to read the pin */
   pinMode( DHTPIN, INPUT );

   /* detect change and read data */
   for ( i = 0; i < MAXTIMINGS; i++ )
   {
      counter = 0;
      while ( digitalRead( DHTPIN ) == laststate )
      {
         counter++;
         delayMicroseconds( 1 );
         if ( counter == 255 )
         {
            break;
         }
      }
      laststate = digitalRead( DHTPIN );

      if ( counter == 255 )
         break;

      /* ignore first 3 transitions */
      if ( (i >= 4) && (i % 2 == 0) )
      {
         /* shove each bit into the storage bytes */
         dht11_dat[j / 8] <<= 1;
         if ( counter > 16 )
            dht11_dat[j / 8] |= 1;
         j++;
      }
   }

   /*
    * check we read 40 bits (8bit x 5 ) + verify checksum in the last byte
    * print it out if data is good
    */
   if ( (j >= 40) &&
        (dht11_dat[4] == ( (dht11_dat[0] + dht11_dat[1] + dht11_dat[2] + dht11_dat[3]) & 0xFF) ) )
   {
      f = dht11_dat[2] * 9. / 5. + 32;
      printf( "Humidity = %d.%d %% Temperature = %d.%d *C (%.1f *F)\n",
         dht11_dat[0], dht11_dat[1], dht11_dat[2], dht11_dat[3], f );
   }else  {
      printf( "Data not good, skip\n" );
   }
}

int main( void )
{
   printf( "Raspberry Pi wiringPi DHT11 Temperature test program\n" );

   if ( wiringPiSetup() == -1 )
      exit( 1 );

   while ( 1 )
   {
      read_dht11_dat();
      delay( 1000 ); /* wait 1sec to refresh */
   }

   return(0);
}


Zurück zu „allgemeine / Nicht-Lego-Robotik und Elektronik“

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 8 Gäste

Lego Mindstorms EV3, NXT und RCX Forum : Haftungsauschluss