Hallo, ich bräuchte hilfe beim anpassen einer Library eines Lambda Shields das für Arduino boards gedacht ist, leider komme ich nicht weiter den code so umzuschreiben, das er auf einem ESP32 läuft. Das Problem ist die SPI kommunikation, die ich nicht zum laufen bekomme. Auf einem UNO oder MEGA funktioniert alles einwandfrei. Ich nutze ein Levelshifter um von 5 Volt des Lambda shields auf die 3,3V vom ESP zu kommen. Hat jemand Lust mir auf die Sprünge zu helfen? Ich würde bei Erfolg auch was in die Kaffeetasse tun:-)
welsches?
was für einer, was für lib
Das lambdashield ist ein controlduino 01M11V00
Levelshifter habe ich bereits zwei ausprobiert, einmal den TXS0108E Logic Level Converter 8 Kanal und den TECNOIOT 4 Channel IIC I2 C Logic Levels Converter Bi-Directional Module 5V to 3.3V
#include "Arduino.h"
#include <Lambda.h>
#include <SPI.h>
#define Lambda_SPI_NSS 5////assign to pin 2 SPI select slave ////asigno al pin 2 SPI select slave
Lambda lambda1(Lambda_SPI_NSS);////assign to pin 2 SPI select slave ////asigno al pin 2 SPI select slave
void setup() {
Serial.begin(57600); ///Establish UART_USB communication with the arduino IDE//Establezco comunicacion UART_USB con la IDE de arduino
lambda1.SPIbeginsettings (1000000);//Sets up SPI communications with the lambda sensor module(long int bauds) //Establece comunicaciones SPI con el modulo de sonda lambda a una velocidad de (long int bauds)
lambda1.begin();//Turn on the lambda module, it will take a while as it has to warm up. //Enciende placa lambda, tardara un rato puesto que tiene que calentarse
}
void loop() {
lambda1.transmission();//En la misma transimision retraso para que al salir tenga ya el valor
String State_value=lambda1.stateTextRead();
float VbatValue=lambda1.vbatteryRead();
float O2Value=lambda1.O2Read();
float LambdaValue=lambda1.lambdaRead ();
float AFRValue=lambda1.afrGasolineRead ();//read the AFR va
Serial.print("\t");
Serial.print(" Estate: ");
// String State_value=lambda1.stateTextRead();
Serial.print(State_value);
//Serial.print("\n\r");
Serial.print("\t");
Serial.print(" %O2: ");
if (lambda1.validO2Read()!=true){
//float O2Value=lambda1.O2Read();
Serial.print(O2Value,2);//5
}else{
Serial.print("------");
}
Serial.print("\t");
Serial.print(" Lambda: ");
if (lambda1.validO2Read()!=true){
//float O2Value=lambda1.O2Read();
Serial.print(LambdaValue,3);//5
}else{
Serial.print("------");
}
Serial.print("\t");
Serial.print(" AFR Petrol: ");
if (lambda1.validO2Read()!=true){
//float O2Value=lambda1.O2Read();
Serial.print(AFRValue,2);//5
}else{
Serial.print("------");
}
Serial.print("\t");
//float VbatValue=lambda1.vbatteryRead();
Serial.print(" Vbat[V]: ");
Serial.print(VbatValue,1); //2
Serial.print("\t");
Serial.print(" diagnosis: ");
// String State_value=lambda1.stateTextRead();
Serial.print(lambda1.diagnosisRead());
Serial.print("\t");
Serial.print("\t");
Serial.print("\n\r");
delay (300);////Delay a time to limit the received data to the desired value.//Retraso un tiempo para limitar los datos recibidos, al valor desesado
}
hier die CPP Datei
/*
Controlduino-01M00V00.cpp - Library for the control and calculation of the lambda module "Controlduino-01M00V00".
Created by JMI, april 1, 2021.
Released into the public domain.
*/
/*Define included headers.*/
#include "Arduino.h"
#include <SPI.h>
#include "Lambda.h"
//Constructor, Select Slave
Lambda::Lambda(int NSS_PIN)
{
pinMode(NSS_PIN, OUTPUT);
_NSS_PIN = NSS_PIN;
digitalWrite(_NSS_PIN, HIGH);
}
/*Function*/
/*Function for transfering SPI data^.*/
void Lambda::transmission() {
digitalWrite(_NSS_PIN, LOW);
buildMessage ();
delayMicroseconds(150);
_chiplambda_MensajeEnviado._word0=_chiplambda_MensajeRecibido._word0;
_chiplambda_MensajeEnviado._word1=_chiplambda_MensajeRecibido._word1;
_chiplambda_MensajeEnviado._word2=_chiplambda_MensajeRecibido._word2;
_chiplambda_MensajeEnviado._word3=_chiplambda_MensajeRecibido._word3;
_chiplambda_MensajeEnviado._byte8=_chiplambda_MensajeRecibido._byte8;
_chiplambda_MensajeEnviado._COMPSPI=0b101;//
_chiplambda_MensajeEnviado._SPI_ERROR_12=0b00;//
_chiplambda_MensajeEnviado._word5=_chiplambda_MensajeRecibido._word5;
SPI.begin();
_chiplambda_MensajeRecibido._word0 = SPI.transfer16(_chiplambda_MensajeEnviado._word0);
_chiplambda_MensajeRecibido._word1 = SPI.transfer16(_chiplambda_MensajeEnviado._word1);
_chiplambda_MensajeRecibido._word2 = SPI.transfer16(_chiplambda_MensajeEnviado._word2);
_chiplambda_MensajeRecibido._word3 = SPI.transfer16(_chiplambda_MensajeEnviado._word3);
_chiplambda_MensajeRecibido._word4 = SPI.transfer16(_chiplambda_MensajeEnviado._word4);
_chiplambda_MensajeRecibido._word5 = SPI.transfer16(_chiplambda_MensajeEnviado._word5);
_chiplambda_MensajeRecibido._word6 = SPI.transfer16(_chiplambda_MensajeEnviado._word6);
_chiplambda_MensajeRecibido._word7 = SPI.transfer16(_chiplambda_MensajeEnviado._word7);
delayMicroseconds(150);
SPI.end();
delayMicroseconds(150);
digitalWrite(_NSS_PIN, HIGH);
}
/*On/Off functions*/
void Lambda::begin() {
#define SPImensaje_ON 0b11
_chiplambda_MensajeEnviado._ONN=SPImensaje_ON;
transmission();
}
void Lambda::end() {
#define SPImensaje_OFF 0b00;
_chiplambda_MensajeEnviado._ONN=SPImensaje_OFF;
transmission();
}
float Lambda::O2Read (){
#define O2_factor (float)0.000824625933278669
return (float)(((float)_chiplambda_MensajeRecibido._O2frac_signed)*O2_factor);
}
float Lambda::lambdaRead (){
#define lambda_factor (float)0.0000686655985351339000000
return (float)((unsigned int)(_chiplambda_MensajeRecibido._Lambdafrac_unsigned_64)*lambda_factor);
}
float Lambda::afrGenericRead (float Val_AFRstoichiometricGeneric ){
#define afrGeneric_factor (float)0.0000686655985351339000000//Modificar
return (float)((unsigned int)(_chiplambda_MensajeRecibido._Lambdafrac_unsigned_64)*Val_AFRstoichiometricGeneric*afrGeneric_factor);
}
float Lambda::afrGasolineRead (){
#define AFRGasoline_factor (float)0.00100938429846647 //gasoline petrol
return (float)((unsigned int)(_chiplambda_MensajeRecibido._Lambdafrac_unsigned_64)*AFRGasoline_factor);
}
float Lambda::afrGasoilRead (){
#define AFRGasoil_factor (float)0.000995651178759441 //diesel,gasoil
return (float)((unsigned int)(_chiplambda_MensajeRecibido._Lambdafrac_unsigned_64)*AFRGasoil_factor);
}
float Lambda::vbatteryRead(){
#define VBattery_factor (float)0.000839246207318303
return ((unsigned int)_chiplambda_MensajeRecibido._VBattery_frac_unsigned_55*VBattery_factor);
}
bool Lambda::validO2Read() {
//Añadir condicion de mensaje que llego del modulo sea válido
//Compruebo que la medida de O2 sea valida y la comunicacion funcione, es decir que el SPI_ERROR Del mensaje de out sea el adecuado, esto lo comprobare al leer
if(_chiplambda_MensajeRecibido._VAL_MEASURING_O2==1){return true;}else{return false;}
}
bool Lambda::validRead() {
//Añadir condicion de mensaje que llego del modulo sea válido
//Compruebo que el mensaje sea valido o y la comunicacion funcione
if(_chiplambda_MensajeRecibido._FLAG_State_Error==1){return true;}else{return false;}//el uno era que no hay error y es valido, falta comprobar el SPI que comunique bien con el modulo
}
int Lambda::counterModuleRead() {
return _chiplambda_MensajeRecibido._Count_Module;
}
int Lambda::counterSampleRead() {
return _chiplambda_MensajeRecibido._Count_100hz;
}
int Lambda::stateRead(){
return _chiplambda_MensajeRecibido._State;
}
String Lambda::stateTextRead(){
String stateTXT;
switch(_chiplambda_MensajeRecibido._State){
case 0:
stateTXT=" Unknown 0";
break;
case 1:
stateTXT="Measuring";
break;
case 2:
stateTXT="OFF";
break;
case 3:
stateTXT="ERROR";
break;
case 4:
stateTXT="Drying";
break;
case 5:
stateTXT="Heating";
break;
case 6:
stateTXT="Pre_Starting";
break;
case 7:
stateTXT="Starting";
break;
default:
stateTXT="Unknown";
break;
}
return stateTXT;
}
void Lambda::compensatePressurebar(float _pressure_value_){
#define _pressure__factor_bar (float)20479.6875
#define _max_P_bar (float)3.2
if (_pressure_value_>_max_P_bar){_pressure_value_=_max_P_bar;}
_chiplambda_MensajeEnviado._Compensation=(unsigned int)(_pressure_value_*_pressure__factor_bar);
}
void Lambda::compensatePressurePa(float _pressure_value_){
#define _pressure__factor_Pa (float)0.204796875
#define _max_P_Pa (float)320000
if (_pressure_value_>_max_P_Pa){_pressure_value_=_max_P_Pa;}
_chiplambda_MensajeEnviado._Compensation=(unsigned int)(_pressure_value_*_pressure__factor_Pa);
}
void Lambda::compensatePressureAtm(float _pressure_value_){
#define _pressure__factor_Atm (float)20751.0433297496
#define _max_P_Atm (float)3.158154458
if (_pressure_value_>_max_P_Atm){_pressure_value_=_max_P_Atm;}
_chiplambda_MensajeEnviado._Compensation=(unsigned int)(_pressure_value_*_pressure__factor_Atm);
}
void Lambda::compensatePressurePSI(float _pressure_value_){
#define _pressure__factor_PSI (float)1412.02474550625
#define _max_P_PSI (float)46.41207614
if (_pressure_value_>_max_P_PSI){_pressure_value_=_max_P_PSI;}
_chiplambda_MensajeEnviado._Compensation=(unsigned int)(_pressure_value_*_pressure__factor_PSI);
}
unsigned int Lambda::messageInWord(int Number){
switch(Number){
case 0:
return _chiplambda_MensajeRecibido._word0;
break;
case 1:
return _chiplambda_MensajeRecibido._word1;
break;
case 2:
return _chiplambda_MensajeRecibido._word2;
break;
case 3:
return _chiplambda_MensajeRecibido._word3;
break;
case 4:
return _chiplambda_MensajeRecibido._word4;
break;
case 5:
return _chiplambda_MensajeRecibido._word5;
break;
case 6:
return _chiplambda_MensajeRecibido._word6;
break;
case 7:
return _chiplambda_MensajeRecibido._word7;
break;
default:
return _chiplambda_MensajeRecibido._word0;
break;
}
}
unsigned int Lambda::messageOutWord(int Number){
switch(Number){
case 0:
return _chiplambda_MensajeEnviado._word0;
break;
case 1:
return _chiplambda_MensajeEnviado._word1;
break;
case 2:
return _chiplambda_MensajeEnviado._word2;
break;
case 3:
return _chiplambda_MensajeEnviado._word3;
break;
case 4:
return _chiplambda_MensajeEnviado._word4;
break;
case 5:
return _chiplambda_MensajeEnviado._word5;
break;
case 6:
return _chiplambda_MensajeEnviado._word6;
break;
case 7:
return _chiplambda_MensajeEnviado._word7;
break;
default:
return _chiplambda_MensajeEnviado._word0;
break;
}
}
String Lambda::diagnosisRead(){
String diagnosisTXT="";
diagnosisTXT="";
#define _SPI_ERROR_12_OK 0b00
if (_chiplambda_MensajeRecibido._SPI_ERROR_12!=_SPI_ERROR_12_OK){diagnosisTXT=diagnosisTXT+"Communication failure _SPI_ERROR_12, ";}
#define _COMPSPI_OK 0b101 //Modificar
if(_chiplambda_MensajeRecibido._COMPSPI!=_COMPSPI_OK){diagnosisTXT=diagnosisTXT+"Communication failure COMPSPI, ";}
if (_chiplambda_MensajeRecibido._Flag_Disconnected_Probe==true){diagnosisTXT=diagnosisTXT+"Disconnected Probe, ";}
if (_chiplambda_MensajeRecibido._OverHeat==true){diagnosisTXT=diagnosisTXT+"Overheat Probe, ";}
if (_chiplambda_MensajeRecibido._UnderHeat==true){diagnosisTXT=diagnosisTXT+"Underheat Probe, ";}
if (_chiplambda_MensajeRecibido._Low_Battery==true){diagnosisTXT=diagnosisTXT+"Low Battery, ";}
if (_chiplambda_MensajeRecibido._High_Battery==true){diagnosisTXT=diagnosisTXT+"High Battery, ";}
if (_chiplambda_MensajeRecibido._FLAG_State_Error==true){diagnosisTXT=diagnosisTXT+"Error in module, ";}
if (_chiplambda_MensajeRecibido._EQUILIBRIO==true){diagnosisTXT=diagnosisTXT+"Not in equilibrium, ";}
if (_chiplambda_MensajeRecibido._VAL_MEASURING_O2==true){diagnosisTXT=diagnosisTXT+"Invalid O2 measurement, ";}
if (diagnosisTXT==""){diagnosisTXT="OK";}
return diagnosisTXT;
}
/*Configure communications*/
void Lambda::SPIbeginsettings (unsigned long int Bauds) {
SPI.beginTransaction(SPISettings(Bauds, MSBFIRST, SPI_MODE1));
SPI.end();
digitalWrite(_NSS_PIN, HIGH);
}
void Lambda::SPIbegin () {
//SPI.begin();
SPI.begin(18, 19, 23, 5);
}
void Lambda::SPIend () {
SPI.endTransaction();
}
/*communication messages*/
void Lambda::adjustAir(){
_requestFlag._adjustAir=1;
}
void Lambda::timeAutoOff(unsigned int timeOff){
if (timeOff<=0x03FF){
_timeOFFVar=timeOff;
}else{_timeOFFVar=0x03FF;}
_requestFlag._timeAutoOff=1;
}
void Lambda::timeAutoOffMNV(unsigned int timeOff){
if (timeOff<=0x03FF){
_timeOFFVarMNV=timeOff;
}else{_timeOFFVarMNV=0x03FF;}
_requestFlag._timeAutoOffMNV=1;
}
void Lambda::reset_L9780(){
_requestFlag._reset_L9780=1;
}
void Lambda::reset_uC(){
_requestFlag._reset_uC=1;
}
void Lambda::cleanErrors(){
_requestFlag._cleanErrors=1;
}
void Lambda::FilterValue(unsigned int _FilterValue){//(0,63)
if (_FilterValue<=0x003F){
_FilterValueVar=_FilterValue;
}else{_FilterValueVar=0x003F;}
_requestFlag._FilterValue=1;
}
void Lambda::FilterValueMNV(unsigned int _FilterValue){//(0,63)
if (_FilterValue<=0x003F){
_FilterValueVarMNV=_FilterValue;
}else{_FilterValueVarMNV=0x003F;}
_requestFlag._FilterValueMNV=1;
}
void Lambda::EnableCompensaP(boolean _EnableCompensaP){
#define CompensacionP_On 0b0011//0x3
#define CompensacionP_Off 0x1100//0xC
if (_EnableCompensaP==true){
_EnableCompensaP_Var=CompensacionP_On;
}else{_EnableCompensaP_Var=CompensacionP_Off;}
_requestFlag._EnableCompensaP=1;
}
void Lambda::EnableCompensaP_MNV(boolean _EnableCompensaP){
#define CompensacionP_On 0b0011//0x3
#define CompensacionP_Off 0x1100//0xC
if (_EnableCompensaP==true){
_EnableCompensaP_VarMNV==CompensacionP_On;
}else{_EnableCompensaP_VarMNV=CompensacionP_Off;}
_requestFlag._EnableCompensaP_MNV=1;
}
void Lambda::requestCode(){
_requestFlag._requestCode=1;
}
void Lambda::requestValueAdjustAir(){
_requestFlag._requestValueAdjustAir=1;
}
void Lambda::reset_AjustAIR(){
_requestFlag._reset_uC_AjustAIR=1;
}
unsigned int Lambda::readReply(){
return _chiplambda_MensajeRecibido._word6;
}
void Lambda::buildMessage (){
#define _LambdaRequest_adjust 0xF0A6
#define _LambdaRequest_adjust_Pressure 0xF0A7
#define _LambdaRequest_timeAutoOff 0x4800
#define _LambdaRequest_timeAutoOffMNV 0x4400
#define _LambdaRequest_reset_L9780 0xAAEA
#define _LambdaRequest_reset_uC 0xA5E5
#define _LambdaRequest_cleanErrors 0xF666//Cambiado
#define _LambdaRequest_Normal 0xF51F
#define _LambdaRequest_FilterMV 0x68C0
#define _LambdaRequest_FilterMNV 0x6740
#define _LambdaRequest_CompensaP_MV 0x6D60
#define _LambdaRequest_CompensaP_MNV 0x6310
#define _LambdaRequest_requestCode 0xFF01
#define _LambdaRequest_requestValueAdjustAir 0xF0B7
#define _LambdaRequest_reset_uC_AjustAIR 0xA6E6
if(_requestFlag._word0==0){_chiplambda_MensajeEnviado._word6=_LambdaRequest_Normal;}else{
if(_requestFlag._adjustAir==1){_requestFlag._adjustAir=0;_chiplambda_MensajeEnviado._word6=_LambdaRequest_adjust;
}else if(_requestFlag._cleanErrors==1){
_requestFlag._cleanErrors=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_cleanErrors;
}else if(_requestFlag._requestCode==1){
_requestFlag._requestCode=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_requestCode;
}else if(_requestFlag._timeAutoOff==1){
_requestFlag._timeAutoOff=0;
_chiplambda_MensajeEnviado._word6=(_LambdaRequest_timeAutoOff)|( _timeOFFVar);
}else if(_requestFlag._EnableCompensaP==1){
_requestFlag._EnableCompensaP=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_CompensaP_MV|(_EnableCompensaP_Var);
}else if(_requestFlag._FilterValue==1){
_requestFlag._FilterValue=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_FilterMV|(_FilterValueVar);
}else if(_requestFlag._timeAutoOffMNV==1){
_requestFlag._timeAutoOffMNV=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_timeAutoOffMNV|(_timeOFFVarMNV);
}else if(_requestFlag._EnableCompensaP_MNV==1){
_requestFlag._EnableCompensaP_MNV=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_CompensaP_MNV|(_EnableCompensaP_VarMNV);
}else if(_requestFlag._FilterValueMNV==1){
_requestFlag._FilterValueMNV=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_FilterMNV|(_FilterValueVarMNV);
}else if(_requestFlag._reset_L9780==1){
_requestFlag._reset_L9780=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_reset_L9780;
}else if(_requestFlag._reset_uC==1){
_requestFlag._reset_uC=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_reset_uC;
}else if (_requestFlag._requestValueAdjustAir==1){
_requestFlag._requestValueAdjustAir=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_requestValueAdjustAir;
}else if (_requestFlag._reset_uC_AjustAIR==1){
_requestFlag._reset_uC_AjustAIR=0;
_chiplambda_MensajeEnviado._word6=_LambdaRequest_reset_uC_AjustAIR;
}
}
}
und hier die H-Datei
/*
Controlduino-01M00V00.h - Library for the control and calculation of the lambda module "Controlduino-01M00V00".
Created by Jose Manuel I, april 1, 2021.
Released into the public domain.
*/
#ifndef Controlduino_01M11V00_h
#define Controlduino_01M11V00_h
/*Define included headers.*/
#include <SPI.h>
#include "Arduino.h"
class Lambda
{
public:
typedef union{
struct{
//Word 0
signed _O2frac_signed:16;
//Word 1
unsigned _Lambdafrac_unsigned_64:16;
//Word 2
unsigned _VBattery_frac_unsigned_55:16;
//Word 3 lsb
unsigned _flagsInternal1:8;
//Word 3 msb
unsigned _flagsInternal2:5;
unsigned _Flag_Disconnected_Probe:1;
unsigned _OverHeat:1;
unsigned _UnderHeat:1;
//Word 4 lsb
unsigned _Low_Battery:1;
unsigned _High_Battery:1;
unsigned _FLAG_State_Error:1;
unsigned _EQUILIBRIO:1;
unsigned _VAL_MEASURING_O2:1;
unsigned _COMPSPI:3;
//Word 4 msb
//unsigned _SPI_ERROR_1:1;
//unsigned _SPI_ERROR_2:1;
unsigned _SPI_ERROR_12:2;
unsigned _ONN:2;
unsigned _REG:1;
unsigned _VER:3;
//Word 5
unsigned _State:4;
unsigned int _Count_Module:4;
unsigned _Count_100hz:8;
//Word 6 calibracion
unsigned _Calibration:16;
//Word 7 Compensacion
unsigned _Compensation:16;
};
struct{
unsigned int _byte0:8;
unsigned int _byte1:8;
unsigned int _byte2:8;
unsigned int _byte3:8;
unsigned int _byte4:8;
unsigned int _byte5:8;
unsigned int _byte6:8;
unsigned int _byte7:8;
unsigned int _byte8:8;
unsigned int _byte9:8;
unsigned int _byte10:8;
unsigned int _byte11:8;
unsigned int _byte12:8;
unsigned int _byte13:8;
unsigned int _byte14:8;
unsigned int _byte15:8;
};
struct{
unsigned int _word0:16;
unsigned int _word1:16;
unsigned int _word2:16;
unsigned int _word3:16;
unsigned int _word4:16;
unsigned int _word5:16;
unsigned int _word6:16;
unsigned int _word7:16;
};
}TYPE_ChipLambda_ST_L9780_arduino_SO;
TYPE_ChipLambda_ST_L9780_arduino_SO _chiplambda_MensajeEnviado;
TYPE_ChipLambda_ST_L9780_arduino_SO _chiplambda_MensajeRecibido;
/*Constructor*/
Lambda(int NSS_PIN);
/*functions*/
void begin();
void end();
float O2Read();
float lambdaRead();
float afrGenericRead (float);
float afrGasolineRead ();
float afrGasoilRead ();
float vbatteryRead();
String diagnosisRead();
int stateRead();
String stateTextRead();
bool validO2Read();
bool validRead();
int validReadTransmission();
int counterModuleRead();
int counterSampleRead();
unsigned int messageOutWord(int Number);
unsigned int messageInWord(int Number);
void transmission();
int transmissionb();
void SPIbegin ();
void SPIbeginsettings (unsigned long int);
void SPIend ();
void compensatePressurebar(float);
void compensatePressurePa(float);
void compensatePressureAtm(float);
void compensatePressurePSI(float);
void adjustAir();
void timeAutoOff(unsigned int);
void timeAutoOffMNV(unsigned int);
void reset_L9780();
void reset_uC();
void cleanErrors();
unsigned int readReply();
void requestCode();
void requestValueAdjustAir();
void reset_AjustAIR();
void FilterValue(unsigned int);//"0" Disable, "1(min filter) to 63(max filter)" , other=(max filter)
void FilterValueMNV(unsigned int);//"0" Disable, "1(min filter) to 63(max filter)" , other=(max filter)
void EnableCompensaP(boolean);//"0" Disable, "1" Enable, other Not valid
void EnableCompensaP_MNV(boolean);//"0" Disable, "1" Enable, other Not valid
unsigned int _FilterValueVar;//Max 0x=003F//Disable 0x0000
unsigned int _FilterValueVarMNV;//Max 0x=003F//Disable 0x0000
unsigned int _EnableCompensaP_Var;//Enable 0x000F;//Disable 0x0000
unsigned int _EnableCompensaP_VarMNV;//Enable 0x000F;//Disable 0x0000
private:
int _NSS_PIN;
//TYPE_ChipLambda_ST_L9780_arduino_SO _chiplambda_MensajeEnviado;//Puedo usarlo como variable temporal si quiero cambiar todo a la vez
//TYPE_ChipLambda_ST_L9780_arduino_SO _chiplambda_MensajeRecibido;//Puedo usarlo como variable temporal si quiero cambiar todo a la vez
int _flag_calibro=0;//No se para que sirve??
void buildMessage();
#if 1
typedef union{
struct{
unsigned _adjustAir:1;
unsigned _timeAutoOff:1;
unsigned _timeAutoOffMNV:1;
unsigned _reset_L9780:1;
unsigned _reset_uC:1;
unsigned _cleanErrors:1;
unsigned _FilterValue:1;
unsigned _FilterValueMNV:1;
unsigned _EnableCompensaP:1;
unsigned _EnableCompensaP_MNV:1;
unsigned _requestCode:1;
unsigned _requestValueAdjustAir:1;
unsigned _reset_uC_AjustAIR:1;
unsigned _NotUsed:3;
};
struct{
unsigned _byte0:8;
unsigned _byte1:8;
};
struct{
unsigned int _word0:16;
};
}TYPE_requestFlag;
TYPE_requestFlag _requestFlag;
//_requestFlag._word0=0;
unsigned int _timeOFFVar;//Max 0x=03FF;
unsigned int _timeOFFVarMNV;//Max 0x=03FF;
#endif
#endif
};
Bitte immer Links dazu posten, sonst nehmen wir evtl. ein falsches.
Sorry bin das erste mal in einem forum, hab mich bisher immer selbst durchgewurschtelt.
TXS0108E Logic Level Converter 8 Kanal
https://www.amazon.de/Parent-Logic-Level-Converter-TXS0108E/dp/B07V1FY9W5?th=1
hier der Zweite Levelshifter:
Die I2C bei SPI lege bei Seite die tun nicht.
Wie man mit dem TXS zu recht kommt steht hier
Ich benutze die Standard SPI Anschlüsse am ESP32 DEV Modul
MISO 19
MOSI 23
CSK 18
CS 5
Müsste also VSPI sein, ich weiß nur nicht was in cpp und h. datei ändern bzw. anpassen muss muss das die Verbindung läuft
ich habe beim tsx den OE Anschluss mit 3,3V verbunden, damit er aktiviert wird. hatte aber auch schon diverse andere sachen versucht, da es sehr unterschiedliche aussagen im netz gibt.
Als antwort im Seriellen Monitor bekomme ich den status OFF angezeigt, weiter komme ich nicht, zumindestens kommt keine Meldung "UNKNOWN0" oder "UNKNOWN" mehr. Ich glaube das es an der Library liegt, da die für UNO usw. geschrieben ist. Ich denke das ich bei den SPI sachen was geändert werden muss. Aber ich komm einfach nicht weiter. Kontakt zum Hersteller des Lambda shields blieb bisher unbeantwortet.
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.