Bitmasking hilfe benötigt

International Deutsch
1

Hi, brauche hilfe bei bitmasking da ich das ganze nicht wirklich verstehe.
Ich arbeite an Tachos die über can laufen was aber nicht wirklich wichtig sein sollte.
Also zum thema. Habe von jemandem files erhalten wo dann alles drinsteht. Aber Mercedes dachte sich: komm bitmasking gute idee deswegen bin ich hier. Mir gehts eigentlich nur wie ich die bitmask selbst mache, rest schaff ich.

Vorgegeben:

void setIgn_On_StartProc_Inact(uint64_t value){d.raw = (d.raw & 0xfffeffffffffffff) | (value & 0x1) << 48;};

0xfffeffffffffffff wär mask?
0x1 filter?
<<48 48 bits shiften nach links?

2

Bei dir stehen die Bits noch Hexdezimal und nicht Binär. Dadurch lässt es sich vom Menschen schwerer überblicken.

Aber im Grunde ist es einfache Bitmanupilation, als Suchtipp.

3

Danke. D.raw wären dann die zu senden daten?
Wenn ich die Daten als uint64_t definiere sollte es ja klappen oder nicht?
Die mask in binär ist 1111111111111110111111111111111111111111
D.raw& mask hab ich durch value& mask ersetzt.

4

Es ist nicht zu erkennen, ob D.raw die zu sendenden Daten sind. Raw steht für Roh.

Bei & käme als Beispiel folgendes raus.

Mask  1111 1111 1111 1110 1111 1111 1111 1111 1111 1111
D.raw 0101 0101 0101 0101 0101 0101 0101 0101 0101 0101 
Ergb. 0101 0101 0101 0100 0101 0101 0101 0101 0101 0101
5

Ich weiß dass es die zu sendenen 8 bytes sind, wenn ich Zuhause bin werde ich mal schauen, habe in etwa Zündung

6

Da wird lediglich das eine bit mit dem letzten Bit aus value gesetzt oder nicht.

3210987654321098765432109876543210987654321098765432109876543210
1111111111111110111111111111111111111111111111111111111111111111
0000000000000001000000000000000000000000000000000000000000000000

auf welchem Prozessor bist du unterwegs - evtl sind casts notwendig.
Was gibts mehr an Infos?

7

Prozessor keine Ahnung, würd gern die header Files die ich hab hochladen aber kann nix hochladen

8

// Status Z\u00FCndung/Fahrzeug
// sending ecus: EIS
typedef struct _Ign_Veh_Stat_AR2: public CANDescriptiveFrame {
_Ign_Veh_Stat_AR2() {
id = 0x20;
len = 8;
signal_count = 22;
}

// Bus fehlerhaft
// receiver ecus: DLM,TGW
// values: 1: BUS_FLT_KPT_AWAKE,0: NO_FLT
uint8_t getBusFlt_PrmntActv(){ return d.raw >> 28 & 0x1; };
void setBusFlt_PrmntActv(uint64_t value){ d.raw = (d.raw & 0xffffffffefffffff) | (value & 0x1) << 28; };

// Status Motorweiterlaufschaltung
// receiver ecus: TGW
// values: 3: SNA,2: NDEF,1: CONT_ENG_RUN_ON,0: CONT_ENG_RUN_OFF
uint8_t getContEngRun_Stat(){ return d.raw >> 26 & 0x3; };
void setContEngRun_Stat(uint64_t value){ d.raw = (d.raw & 0xfffffffff3ffffff) | (value & 0x3) << 26; };

// CRC-Checksumme der Signal Gruppe gem\u00E4\u00DF AUTOSAR Profil 2
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
uint8_t getCRC_Ign_Stat_Pr2(){ return d.raw >> 56 & 0xff; };
void setCRC_Ign_Stat_Pr2(uint64_t value){ d.raw = (d.raw & 0xffffffffffffff) | (value & 0xff) << 56; };

// DidA Externer Tester erkannt
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getDidA_ExtTest_Pres(){ return d.raw >> 31 & 0x1; }
void setDidA_ExtTest_Pres(uint64_t value){d.raw = (d.raw & 0xffffffff7fffffff) | (value & 0x1) << 31;};

// Keyless Go Anlassbedingungen erf\u00FCllt
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getEngSt_Enbl_Rq_KG(){ return d.raw >> 35 & 0x1; }
void setEngSt_Enbl_Rq_KG(uint64_t value){d.raw = (d.raw & 0xfffffff7ffffffff) | (value & 0x1) << 35;};

// ELV Verriegelungsanforderung
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
// values: 3: ORC_SAM_F_RQ,2: SAM_F_RQ,1: ORC_RQ,0: DEFAULT
uint8_t getESL_Lk_Rq(){ return d.raw >> 44 & 0x3; };
void setESL_Lk_Rq(uint64_t value){ d.raw = (d.raw & 0xffffcfffffffffff) | (value & 0x3) << 44; };

// Z\u00FCndung an/Motorstart aus
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getIgn_On_StartProc_Inact(){ return d.raw >> 48 & 0x1; }
void setIgn_On_StartProc_Inact(uint64_t value){d.raw = (d.raw & 0xfffeffffffffffff) | (value & 0x1) << 48;};

// Klemmenstatus
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
// values: 7: SNA,5: IGN_START,4: IGN_ON,2: IGN_ACC,1: IGN_OFF,0: IGN_LOCK
uint8_t getISw_Stat(){ return d.raw >> 49 & 0x7; };
void setISw_Stat(uint64_t value){ d.raw = (d.raw & 0xfff1ffffffffffff) | (value & 0x7) << 49; };

// Keyless Go Klemmenansteuerung aktiv
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getKG_IgnCtrl_Actv(){ return d.raw >> 47 & 0x1; }
void setKG_IgnCtrl_Actv(uint64_t value){d.raw = (d.raw & 0xffff7fffffffffff) | (value & 0x1) << 47;};

// Keyless Go Starttaster  bet\u00E4tigt
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getKG_StartSw_Psd(){ return d.raw >> 46 & 0x1; }
void setKG_StartSw_Psd(uint64_t value){d.raw = (d.raw & 0xffffbfffffffffff) | (value & 0x1) << 46;};

// Mobilger\u00E4t Status Ladeanforderung
// receiver ecus: TGW
// values: 3: SNA,2: NDEF2,1: CHARGE,0: DO_NOT_CHARGE
uint8_t getMobile_Chrg_Rq_EIS(){ return d.raw >> 24 & 0x3; };
void setMobile_Chrg_Rq_EIS(uint64_t value){ d.raw = (d.raw & 0xfffffffffcffffff) | (value & 0x3) << 24; };

// Klemmensteuerung Motorfernstart aktiv
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getRemSt_IgnCtrl_Actv(){ return d.raw >> 34 & 0x1; }
void setRemSt_IgnCtrl_Actv(uint64_t value){d.raw = (d.raw & 0xfffffffbffffffff) | (value & 0x1) << 34;};

// Klemmensteuerung Motorfernstart Information
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
// values: 3: SNA,2: BAT_CHRG,1: PRECON,0: NO_RQ
uint8_t getRemSt_IgnCtrl_Info(){ return d.raw >> 32 & 0x3; };
void setRemSt_IgnCtrl_Info(uint64_t value){ d.raw = (d.raw & 0xfffffffcffffffff) | (value & 0x3) << 32; };

// R\u00FCckw\u00E4rtsgang eingelegt
// receiver ecus: DLM,NV,RBTM_FL,RBTM_FR,RVC,TGW,TPM
// values: 3: SNA,2: NDEF2,1: ENGG,0: DISENGG
uint8_t getRevGr_Engg(){ return d.raw >> 29 & 0x3; };
void setRevGr_Engg(uint64_t value){ d.raw = (d.raw & 0xffffffff9fffffff) | (value & 0x3) << 29; };

// Akustische Warnung SPCR
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getSPCR_AcustWarn_Rq_EIS(){ return d.raw >> 40 & 0x1; }
void setSPCR_AcustWarn_Rq_EIS(uint64_t value){d.raw = (d.raw & 0xfffffeffffffffff) | (value & 0x1) << 40;};

// Konfiguration Stillstandskoordinator
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
// values: 3: SNA,2: HOLD_AND_SBW,1: HOLD_NO_SBW,0: NOT_CONF
uint8_t getSPCR_Conf_EIS(){ return d.raw >> 41 & 0x3; };
void setSPCR_Conf_EIS(uint64_t value){ d.raw = (d.raw & 0xfffff9ffffffffff) | (value & 0x3) << 41; };

// StopCoordinator Failure EIS
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getSPCR_Flt_EIS(){ return d.raw >> 43 & 0x1; }
void setSPCR_Flt_EIS(uint64_t value){d.raw = (d.raw & 0xfffff7ffffffffff) | (value & 0x1) << 43;};

// Sequenzz\u00E4hler
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
uint8_t getSQC_Ign_Stat_Pr2(){ return d.raw >> 52 & 0xf; };
void setSQC_Ign_Stat_Pr2(uint64_t value){ d.raw = (d.raw & 0xff0fffffffffffff) | (value & 0xf) << 52; };

// Anforderung Not-'P'
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getTxPkPosn_Emg_Rq(){ return d.raw >> 38 & 0x1; }
void setTxPkPosn_Emg_Rq(uint64_t value){d.raw = (d.raw & 0xffffffbfffffffff) | (value & 0x1) << 38;};

// EIS-Wunsch: 'P' einlegen
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getTxPkPosn_Rq(){ return d.raw >> 39 & 0x1; }
void setTxPkPosn_Rq(uint64_t value){d.raw = (d.raw & 0xffffff7fffffffff) | (value & 0x1) << 39;};

// SPCR-Wunsch: 'P' einlegen erlaubt
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getTxPkPosn_Rq_SPCR_Enbl(){ return d.raw >> 36 & 0x1; }
void setTxPkPosn_Rq_SPCR_Enbl(uint64_t value){d.raw = (d.raw & 0xffffffefffffffff) | (value & 0x1) << 36;};

// Auto-'P' enabled
// receiver ecus: DLM,DRVU,HUD,IC,NV,ORC,RBTM_FL,RBTM_FR,RVC,TGW,TPM
bool getTxPkPosnAuto_Enbl(){ return d.raw >> 37 & 0x1; }
void setTxPkPosnAuto_Enbl(uint64_t value){d.raw = (d.raw & 0xffffffdfffffffff) | (value & 0x1) << 37;};

} Ign_Veh_Stat_AR2;

9 
void setIgn_On_StartProc_Inact (uint64_t value) {
   d.raw = (d.raw & 0xfffeffffffffffff) | (value & 0x01) << 48;
}

Das ist eine Maske
0xfffeffffffffffff
und

0x01

ist eine Maske. Also die Masken hast du schon, wenn du diese meinst.

Die Zeile wird von links nach rechts gelesen inkl. Klammerbeachtung..
d.raw = (d.raw & 0xfffeffffffffffff) | (value & 0x01) << 48;

d.raw wird maskiert sodass nur noch alle '1' der Maske von d.raw übrig bleiben, wenn vorhanden gewesen.
value wird mit 0x01 maskiert sodass nur noch das erste Bit auf '1' bleibt wenn es denn auf 1 stehen sollte. Mit 0x01 ist das erste Bit 0 gemeint. Reihenfolge der Wertigkeiten beachten.
Danach werden beide Werte aus den Klammern verodert.
Danach wird alles um 48 Stellen nach links verschoben und der Wert d.raw neu zugewiesen.

Ich gebe mir mal noch meine Formatierungsmethoden.
myToolbox.zip (3,8 KB)

#include <myToolbox.h>

void setup (void)
{
  Serial.begin(9600);
  Serial.println(F("\nuC Reset ####"));
  uint32_t data1 {0xFFFF};
  uint64_t data2 {0xFFFF};
  formatBINln(Serial, data1);
  formatBINln(Serial, data1, true);
  formatBINln(Serial, data2);  
  formatBINln(Serial, data2, true);
}

void loop (void)
{
}

uC Reset ####
0b00000000000000001111111111111111
0b0000'0000.0000'0000.1111'1111.1111'1111
0b0000000000000000000000000000000000000000000000001111111111111111
0b0000'0000.0000'0000.0000'0000.0000'0000.0000'0000.0000'0000.1111'1111.1111'1111

Damit werden alle Werte je nach Datentyp gleich formatiert ausgegeben. Zum debuggen besser lesbar wenn alle Bits sauber untereinander stehen inkl. führender Nullen.
Die Option 'true' sorgt nur für eine optische Trennung mit Punkt in Bytegruppen und Hochkomma in halbe Bytes.

10

Wär es möglich dass du mir ein Abschnitt machst damit? Ich lerne ehr wenn ich code sehe.
Der Wert der durch die mask gehen soll ist egal, kann 0-7 sein max. Zündung wäre 4, Accessoires wäre 1. Außerdem wie kann ich mehrere masks in eine void packen? Idee wär meine:
Void licht(bool blinkerL, bool blinkerR, unsigned long Licht) {

Licht maskieren:
Senden;
Blinker l maskieren;
Senden;
Blinker r maskieren;
Senden;}
Oder doch lieber mit for machen?
Um d.raw zu nutzen d als struct?

11

Du suchst die Teilung in Functionen. nicht voids. void is nix. niente. Also hier:

void blinken()

bedeutet es, das die funktion blinken nix zurück gibt.
Im Gegensatz dazu

byte blinken()
{
if (rechts == true)
return rechts;
else if (links==true)
return links;
return 0;
}

gibt die Funktion immer einen Wert zurück. entweder rechts, oder links, oder 0.

Du kannst auch eine Funktion bauen und damit weitere Funktionen aufrufen:

void licht()
{
blinken();
Abblendlicht();
Bremslicht();
}

Jede einzelne Funktion kann dann Deinen Wert auffüllen/verändern.
Ich würde sogar meinen, das alles zusammen gesehen es sowas wie eine einfache Addition wird.
Nur eben mit Bitmanipulation.

12

Hallo,

ein Bsp. wie man meine Formatierungsfunktionen verwendet habe ich gezeigt. Weitere sind enthalten. Musste nur anwenden. Einfacher gehts nun wirklich nicht. Das dient nur zur Anzeige, zum Debuggen. Falls das verwechselt wurde.
Auf deinen Fall bezogen kann ich nichts schreiben, weil kein Bsp. vorhanden ist.
Du zeigst nur Stückweise paar Zeilen und ohne jede Formatierung fürs Forum zum lesen.
Damit kann ich nichts anfangen. Das struct d kennen wir auch nicht.
Mein Rat. Beschäftige dich mit Bitmanipulation im Einzelnen. Wenn du das verstanden hast kannste das auf alles anwenden was du möchtest. Momentan verstrickst du dich im Programm. Teste es einzeln, danach anwenden.

13

hättest du sonst eine idee wegen crc? autosar-crc/main.cpp at main · LuisFalk/autosar-crc · GitHub algo wurd geleaked. würde gerne das was ich hab hochladen aber
Forum lässt mich nicht.

14

Hallo,

hast denn schon das Bisherige fertig? Habe das Gefühl du machst viel zu viele Baustellen auf einmal auf. Der Code scheint nicht für AVR geschrieben zu sein. Wir haben keine Standard LibC++ zur Verfügung. Es ist aber einiges davon inkludiert. Was hast du überhaupt für einen Arduino?
Wegen CRC, da ist in deinem Link alles dabei. Es wird laut meiner Meinung keine fremde Lib benötigt.

15

Du kannst Code ganz normal in Deinem Post einfügen.
Dafür gibt es entweder die Funktion - BEARBEITEN - FÜR FORUM KOPIEREN - in der IDE oder hier den Button <CODE/>

Das hochladen ist für was anderes gedacht...

16

Soll ich 4k Zeilen code Pasten?

17

Hab einen uno, sonst noch leonardo. Der code den ich gesendet habe müsste aus einem gateway oder ähnliches stammen, entwickelungs Dateien.

18

Das weiss ich nicht.

19

das wär mein aktueller code

#include <SPI.h>
#include <Wire.h>
int CAN_INT = 2;
int counter;
long unsigned int rxid;
unsigned char len;
unsigned char rxbuf;
MCP_CAN CAN(10);
void setup() {
  // put your setup code here, to run once:

      if(CAN.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK) 
      CAN.setMode(MCP_NORMAL);
Serial.begin(115200);
      pinMode(CAN_INT, INPUT);
}
uint16_t draw;
void loop() {
  counter++;
if (counter == 255)
{
  counter = 0;
}

  ignition(2);
  wup();
 // gpk(1);
 // Serial.println(rxid);

delay(100);

}
 /*void gpk(uint64_t value){
   draw = (value &  0xff7fffffffffffff) | (value & 0x1) << 55;
  CAN.sendMsgBuf(0x263,0,8,draw);
}*/

void wup(){
 draw = (0 & 0xffffffbfffffffff) | (0 & 0x1) << 38;
  CAN.sendMsgBuf(0x507,0,8,draw);
}

void ignition(uint64_t value){

 draw = (value & 0xfff1ffffffffffff) | (value & 0x7) << 49;
  CAN.sendMsgBuf(0x20,0,8,draw);
}```
20

Das passt doch nicht.

void wup()
{
  draw = (0 & 0xffffffbfffffffff) | (0 & 0x1) << 38;
  CAN.sendMsgBuf(0x507, 0, 8, draw);
}