INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Nano als I/O Erweiterung für den RPi
12.01.2020, 17:59
Beitrag #17
RE: Nano als I/O Erweiterung für den RPi
Von der vorgeschlagenen Ausgabe der Bytes für die Du die CRC bildest sehe ich aber noch nichts.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.01.2020, 18:01 (Dieser Beitrag wurde zuletzt bearbeitet: 12.01.2020 18:02 von DerkleinePunk.)
Beitrag #18
RE: Nano als I/O Erweiterung für den RPi
Code:
#include "EEPROMHelper.h"
  
unsigned long eeprom_crc32(int pos) {
  return eeprom_crc32(pos, EEPROM.length());
}

unsigned long eeprom_crc32(int pos, int length) {
  unsigned long crc = ~0L;

  Serial.print(F("eeprom CRC Size "));
  Serial.print(length);
  Serial.println(F(" bytes"));

  length += pos;
  
  for (int index = pos ; index < length  ; ++index) {
    Serial.print(F("0x"));
    Serial.print(EEPROM[index], HEX);
    Serial.print(F(" "));
    crc = crc_table[(crc ^ EEPROM[index]) & 0x0f] ^ (crc >> 4);
    crc = crc_table[(crc ^ (EEPROM[index] >> 4)) & 0x0f] ^ (crc >> 4);
    crc = ~crc;
  }

  Serial.println();
  return crc;
}

Mach mal ist man einfach selten dämlich Postion und speicher Länge sollte man beachten.

Ausgabe :
eeprom CRC Size 9 bytes
0x1 0x5A 0xFF 0xFF 0xFF 0xE8 0x3 0x0 0x0
crc: 0x5AFFB3C8
crcProm: 0x5AFFB3C8
EEPROM good
Boot Done

Mein Projekt
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.01.2020, 18:05
Beitrag #19
RE: Nano als I/O Erweiterung für den RPi
Ok, aber wenn Du Deine Werte, die Du in den EEPROM speicherst sowieso im Code hardcodiert vorliegen hast, warum speicherst Du sie dann im EEPROM?

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.01.2020, 19:03 (Dieser Beitrag wurde zuletzt bearbeitet: 12.01.2020 19:03 von DerkleinePunk.)
Beitrag #20
RE: Nano als I/O Erweiterung für den RPi
Ok das kannst du nur sehen wenn du den Code Komplett an siehst. (Download Link)

Was du gesehen hast ist nur die Initialisierung die soll nur aus geführt werden wenn sich die Software version sich ändert (progd_flag).
Oder der EEProm nicht Initatilsiert bzw lese fehler hatte.

Code:
if((configuration.progd_flag == progdFlagDefault) && (crc == crcProm)) {
    DebugPrinter.println(F("EEPROM good"));
    return;
  }

Du kannst die Konfiguration per I²C Command verändern und dann Speichern das Funktioniert auch.
Habe gerade den Letzten stand mal hoch geladen.

Mein Projekt
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.01.2020, 19:13
Beitrag #21
RE: Nano als I/O Erweiterung für den RPi
In welchem Beitrag?

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.01.2020, 19:49
Beitrag #22
RE: Nano als I/O Erweiterung für den RPi
da du scheinbar nicht auf Links klicken möchtes:

Code:
//https://www.arduino.cc/en/Tutorial/BlinkWithoutDelay

#include <Wire.h>
#define SLAVE_ADDRESS 0x21
#include <EEPROM.h>
#include "EEPROMHelper.h"
#include "config.h"
#include "DebugPrinter.h"

//Pins
#define INT 2
#define PWM1 3
#define DIGI0 4
#define DIGI1 5
#define DIGI2 6
#define DIGI3 7
#define DIGI4 8
#define DIGI5 9
#define DIGI6 10
#define PWM2 11
#define DIGI7 12
//#define LED 13 LED_BUILTIN

word sensorWert = 0x0000;
word lastAD[6] = {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000};
word lastDIGIValue = 0;
config_t configuration;
unsigned long previousMillis = 0;

void saveConfig() {
  unsigned long crc = crc32(configuration);
  DebugPrinter.print(F("crc: 0x"));
  DebugPrinter.println(crc, HEX);
  EEPROM.put(0, crc);
  EEPROM.put(4, configuration);
}

void initializeEEPROM() {
  unsigned long crc;
  EEPROM.get(0, crc);
  EEPROM.get(4, configuration);
  unsigned long crcProm = eeprom_crc32(4, sizeof(configuration));
  DebugPrinter.print(F("crc: 0x"));
  DebugPrinter.println(crc, HEX);
  DebugPrinter.print(F("crcProm: 0x"));
  DebugPrinter.println(crcProm, HEX);
  if((configuration.progd_flag == progdFlagDefault) && (crc == crcProm)) {
    DebugPrinter.println(F("EEPROM good"));
    return;
  }
  DebugPrinter.print(F("progd_flag: 0x"));
  DebugPrinter.println(configuration.progd_flag, HEX);
  configuration.progd_flag = progdFlagDefault;
  configuration.interval = 1000;
  configuration.enableAD = 0xFF;
  configuration.enableDIGI = 0xFF;
  configuration.outputDIGI = 0x00;
  saveConfig();
  DebugPrinter.println(F("EEPROM init done"));
}

void configDIGI() {
  if(bitRead(configuration.outputDIGI, 0) == 1) {
     DebugPrinter.println(F("Set DIGI0 to OUTPUT"));
     pinMode(DIGI0, OUTPUT);
  } else {
     DebugPrinter.println(F("Set DIGI0 to INPUT"));
     pinMode(DIGI0, INPUT);
  }
  if(bitRead(configuration.outputDIGI, 1) == 1) {
     pinMode(DIGI1, OUTPUT);
  } else {
     pinMode(DIGI1, INPUT);
  }
  if(bitRead(configuration.outputDIGI, 2) == 1) {
     pinMode(DIGI2, OUTPUT);
  } else {
     pinMode(DIGI2, INPUT);
  }
  if(bitRead(configuration.outputDIGI, 3) == 1) {
     pinMode(DIGI3, OUTPUT);
  } else {
     pinMode(DIGI3, INPUT);
  }
  if(bitRead(configuration.outputDIGI, 4) == 1) {
     pinMode(DIGI4, OUTPUT);
  } else {
     pinMode(DIGI4, INPUT);
  }
  if(bitRead(configuration.outputDIGI, 5) == 1) {
     pinMode(DIGI5, OUTPUT);
  } else {
     pinMode(DIGI5, INPUT);
  }
  if(bitRead(configuration.outputDIGI, 6) == 1) {
     pinMode(DIGI6, OUTPUT);
  } else {
     pinMode(DIGI6, INPUT);
  }
  if(bitRead(configuration.outputDIGI, 7) == 1) {
     pinMode(DIGI7, OUTPUT);
  } else {
     pinMode(DIGI7, INPUT);
  }
}

void setup() {
  DebugPrinter.begin(9600);
  // Define the LED pin as Output
  pinMode (LED_BUILTIN, OUTPUT);
  pinMode (INT, OUTPUT);
  // PWM as Ouputs
  pinMode(PWM1, OUTPUT);
  pinMode(PWM2, OUTPUT);
  //muss nicht sein weil Default so Aber ich finde es besser wenn es da steht
  pinMode(DIGI0, INPUT);
  pinMode(DIGI1, INPUT);
  pinMode(DIGI2, INPUT);

  //Setup PWM
  TCCR2A = _BV(COM2A1) | _BV(COM2B1) | _BV(WGM20);
  //490.196Hz Timer 2 prescaler (64)
  TCCR2B = _BV(CS22);
  //30.637Hz Timer 2 prescaler (1024)
  //TCCR2B = _BV(CS22) | _BV(CS21) | _BV(CS20);
  
  OCR2A = 0xFF; // 100%
  OCR2B = 0xFF; // 100%
  
  Wire.begin(SLAVE_ADDRESS);
  Wire.onReceive(receiveData);
  Wire.onRequest(sendData);

  initializeEEPROM();
  configDIGI();
  DebugPrinter.printConfig(configuration);
  DebugPrinter.println(F("Boot Done"));
}

word getDigiValue(){
  word value = 0;
  if(bitRead(configuration.enableDIGI, 0) == 1 && bitRead(configuration.outputDIGI, 0) == 0) {
    //DebugPrinter.println(F("Read DIGI0"));
    value |= digitalRead(DIGI0);
  }
  if(bitRead(configuration.enableDIGI, 1) == 1 && bitRead(configuration.outputDIGI, 1) == 0) {
    value |= digitalRead(DIGI1) << 1;
  }
  if(bitRead(configuration.enableDIGI, 2) == 1 && bitRead(configuration.outputDIGI, 2) == 0) {
    value |= digitalRead(DIGI2) << 2;
  }
  if(bitRead(configuration.enableDIGI, 3) == 1 && bitRead(configuration.outputDIGI, 3) == 0) {
    value |= digitalRead(DIGI3) << 3;
  }
  if(bitRead(configuration.enableDIGI, 4) == 1 && bitRead(configuration.outputDIGI, 4) == 0) {
    value |= digitalRead(DIGI4) << 4;
  }
  if(bitRead(configuration.enableDIGI, 5) == 1 && bitRead(configuration.outputDIGI, 5) == 0) {
    value |= digitalRead(DIGI5) << 5;
  }
  if(bitRead(configuration.enableDIGI, 6) == 1 && bitRead(configuration.outputDIGI, 6) == 0) {
    value |= digitalRead(DIGI6) << 6;
  }
  if(bitRead(configuration.enableDIGI, 7) == 1 && bitRead(configuration.outputDIGI, 7) == 0) {
    value |= digitalRead(DIGI7) << 7;
  }
  return value;
}

void setAnswerBuffer(byte registerToRead) {
  switch(registerToRead) {
    case 0x00:
      sensorWert = lastAD[0];
      break;
    case 0x01:
      sensorWert = lastAD[1];
      break;
    case 0x02:
      sensorWert = lastAD[2];
      break;
    case 0x03:
      sensorWert = lastAD[3];
      break;
    case 0x04:
      sensorWert = lastAD[4];
      break;
    case 0x05:
      sensorWert = lastAD[5];
      break;
    case 0x06:
      sensorWert = OCR2A;
      break;
    case 0x07:
      sensorWert = OCR2B;
      break;
    case 0x08:
      sensorWert = getDigiValue();
      break;
    default:
      DebugPrinter.println(F("Unkown Register"));
  }
}

void setPollingInterval(byte intervalInt) {
  configuration.interval = intervalInt * 100;
  DebugPrinter.print(F("set Interval to "));
  DebugPrinter.println(configuration.interval);
}

void setPWM1Time(byte value) {
  OCR2A = value;
  DebugPrinter.print(F("set PWM1Time to "));
  DebugPrinter.println(value);
}

void setPWM2Time(byte value) {
  OCR2B = value;
  DebugPrinter.print(F("set PWM2Time to "));
  DebugPrinter.println(value);
}

void changeDIGI(byte value) {
  configuration.outputDIGI = value;
  configDIGI();
}

void receiveData(int byteCount){
  digitalWrite(LED_BUILTIN, HIGH);
  if(byteCount < 1) {
     DebugPrinter.print(F("ignore I²C Message"));
     return;
  }
  byte registerNumber = Wire.read();
  byte registerValue = 0x00;
  bool valueSet = false;
  if(byteCount >= 2) {
      registerValue = Wire.read();
      valueSet = true;
  }
  DebugPrinter.print(F("i²c received register: 0x"));
  DebugPrinter.print(registerNumber, HEX);
  DebugPrinter.print(F(" value: 0x"));
  DebugPrinter.print(registerValue, HEX);
  DebugPrinter.println();
  sensorWert = 0x0000;
  switch(registerNumber) {
    case 0x00:
    case 0x01:
    case 0x02:
    case 0x03:
    case 0x04:
    case 0x05:
    case 0x06:
    case 0x07:
    case 0x08:
      setAnswerBuffer(registerNumber);
      break;
    case 0x10:
      if(valueSet) {
        setPollingInterval(registerValue);
      };
    case 0x11:
      if(valueSet) {
        setPWM1Time(registerValue);
      } else {
        sensorWert = 0xFFFF;
      }
      break;
    case 0x12:
      if(valueSet) {
        setPWM2Time(registerValue);
      } else {
        sensorWert = 0xFFFF;
      }
      break;
    case 0x13:
      if(valueSet) {
        configuration.enableAD = registerValue;
      } else {
        sensorWert = 0xFFFF;
      }
      break;
    case 0x14:
      if(valueSet) {
        configuration.enableDIGI = registerValue;
      } else {
        sensorWert = 0xFFFF;
      }
      break;
    case 0x15:
      if(valueSet) {
        changeDIGI(registerValue);
      } else {
        sensorWert = 0xFFFF;
      }
      break;  
    case 0xF0:
      saveConfig();
      DebugPrinter.printConfig(configuration);
      break;
    default:
      sensorWert = 0xFFFF;
      break;
  }
  digitalWrite(LED_BUILTIN, LOW);
}

// callback for sending data
void sendData(){
  digitalWrite(LED_BUILTIN, HIGH);
  Wire.write(lowByte(sensorWert));
  Wire.write(highByte(sensorWert));
  digitalWrite(LED_BUILTIN, LOW);
  digitalWrite(INT, LOW);
}

bool readAd(byte adress) {
  bool valueChanged = false;
  if(bitRead(configuration.enableAD, adress) == 1) {
    word adValue = 0x00;
    //AD4 und AD5 Belegt durch I²C
    switch(adress) {
      case 0x00:
        adValue = analogRead(A0);
        break;
      case 0x01:
        adValue = analogRead(A1);
        break;
      case 0x02:
        adValue = analogRead(A2);
        break;
      case 0x03:
        adValue = analogRead(A3);
        break;
      case 0x04:
        adValue = analogRead(A6);
        break;
      case 0x05:
        adValue = analogRead(A7);
        break;
    }
    if(adValue != lastAD[adress]) {
      lastAD[adress] = adValue;
      valueChanged = true;
      DebugPrinter.print(F("AD"));
      DebugPrinter.print(adress, HEX);
      DebugPrinter.print(F(" has Value: "));
      DebugPrinter.print(lastAD[adress], HEX);
      DebugPrinter.println();
    }
  }
}

bool readAds() {
  bool valueChanged = false;
  for(byte i = 0; i < 6; ++i) {
    if(readAd(i)){
      valueChanged = true;
    }
  }
  return valueChanged;
}

void loop() {
  bool valueChanged = false;
  const unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= configuration.interval) {
    previousMillis = currentMillis;
    valueChanged = readAds();
  }
  if(valueChanged) {
    digitalWrite(INT, HIGH);
  } else {
    if(lastDIGIValue != getDigiValue()) {
      lastDIGIValue = getDigiValue();
      digitalWrite(INT, HIGH);
    }
  }
}

So sieht es zur Zeit aus.

Linux Consolen befehle für den PI:

i2cset -y 1 0x21 0x15 0x00 -> Alle definierten DIGI Pins auf Input umschalten
i2cget -y 1 0x21 0x08 w -> DIGI Pins abfragen
i2cget -y 1 0x21 0x00 w -> AD0 abfragen
i2cset -y 1 0x21 0xF0 -> Konfiguration im EEPROM speichern

Mein Projekt
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.01.2020, 20:00
Beitrag #23
RE: Nano als I/O Erweiterung für den RPi
Codes, um die es in Diskussionen hier im Forum geht, gehören auch hier ins Forum und nicht auf irgendwelche Server, von denen sie irgendwann gelöscht werden und dann fehlen hier die Informationen.
Du kannst auch zusätzlich ein ZIP-File anhängen, wenn die Codes zu groß werden.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.01.2020, 20:01
Beitrag #24
RE: Nano als I/O Erweiterung für den RPi
So das müsste jetzt die Vollständige Liste sein:

i2cget -y 1 0x21 0x00 w -> AD0 abfragen
i2cget -y 1 0x21 0x01 w -> AD1 abfragen
i2cget -y 1 0x21 0x02 w -> AD2 abfragen
i2cget -y 1 0x21 0x03 w -> AD3 abfragen
i2cget -y 1 0x21 0x04 w -> AD4 abfragen
i2cget -y 1 0x21 0x05 w -> AD5 abfragen
i2cget -y 1 0x21 0x06 w -> PWM 1 Abfragen
i2cget -y 1 0x21 0x07 w -> PWM 2 Abfragen
i2cget -y 1 0x21 0x08 w -> DIGI Pins abfragen
i2cset -y 1 0x21 0x10 0x10 -> Interval einstellen Value * 100 Ms
i2cset -y 1 0x21 0x11 0x10 -> PWM 1 einstellen
i2cset -y 1 0x21 0x12 0x10 -> PWM 2 einstellen
i2cset -y 1 0x21 0x13 0x03 -> AD's enable / disable 0x03 => 0 und 1 Enabled
i2cset -y 1 0x21 0x14 0x03 -> DIGI's enable / disable 0x03 => 0 und 1 Enabled
i2cset -y 1 0x21 0x15 0x00 -> DIGI Pins auf Input umschalten 0x00 alle da wo ne 1 ist Input
i2cset -y 1 0x21 0xF0 -> Konfiguration im EEPROM speichern

Mein Projekt
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Schaltuhr Erweiterung 433Mhz Funk volvodidi 17 537 12.01.2020 14:50
Letzter Beitrag: hotsystems
  Arduino Nano, Sensoren und Nextion MotD 24 8.604 30.08.2018 10:42
Letzter Beitrag: hotsystems
  Laser mit arduino nano TTL modulieren Wranox 0 3.124 30.07.2015 15:38
Letzter Beitrag: Wranox
  Linienfolger mit Arduino Nano reenoh 16 11.398 27.05.2015 11:04
Letzter Beitrag: reenoh
Wink DSLR mit Arduino Nano steuern. Eichner 12 11.752 25.03.2015 17:27
Letzter Beitrag: Eichner
Rainbow RC Beleuchtungsmodul mit Arduino Nano Kyrill 7 7.065 15.03.2015 14:02
Letzter Beitrag: querkopf71
  Erweiterung für SD: fprintf_, fgets_, fscanf_ HaWe 0 1.521 08.03.2015 17:23
Letzter Beitrag: HaWe

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste