iPod-Interface am Anschluss des CD-Wechsler für Audi Werksradio (1. Generation)

Hi!
Mehr Infos habe ich leider auch nicht. Pinbelegung steht ja auf dem 
Radio.
Mitloggen sollte gehen mit einem Controller der SPI hat.
Du musst nur zunächst mal die richtigen Taktraten einstellen, die Du mit 
einem Oscar messen kannst. So würde ich jedenfalls vorgehen.
Leider hat mein Wagen kein FIS sonst hätte ich das auch schon längst 
gemacht. Schließlich habe ich die Titelnamen, Interpret und Albumnamen 
bereits als String in meinem Controller der iPod-Steuerung.
Somit läge es nahe diese im FIS anzuzeigen.
Ach ja, da ich glaube dass ein Tausch des Kombiinstrumentes nur schwer 
möglich ist (oder gar nicht), suche ich dazu ein LCD in dem Rot der 
Audi-Armaturen. Hatte schon an das des Radios gedacht, aber dazu habe 
ich leider keine Infos. Außerdem ist es zu breit und ich wollte es in 
eines der "Leerfelder" setzen (wo sonst die Regler der Sitzheizung 
sind).
Also falls jemand eine Idee dazu hat...
Danke und schöne Grüße,
Klaus.

Also mein Code ist leider sehr kompliziert geworden, da ich mehrere 
Zustandsmaschinen ineinander verschachtelt habe. Nur so konnte ich 
allerdings sicherstellen, dass die gesamte iPod-Kommunikation über einen 
Timer-Interrupt läuft und vom "main" vollständig zeitlich entkoppelt 
ist.
Grundsätzlich habe ich mich aber an die o. g. Quellen gehalten. 
Aufgeblähr wurde das ganze erst, als ich mehr und mehr Befehle 
implementiert habe, die jederzeit über eine Message-Queue aufgerufen 
werden können. So kann ich in den Routinen, die die Kommandos vom Radio 
auswerten ganz einfach den iPod-Routinen posten, was sie als nächstet 
(d. h. wenn alle vorigen Befehle der Queue abgearbeitet sind) tun soll.

Ich poste aber wenigstens mal meine Low-Levels, um Euch ein bisschen 
Arbeit zu ersparen:

1

/* MODULE prot */

2

void ProtInit(void)

3

{

4

  AS1_ClearRxBuf();

5

  AS1_ClearTxBuf();

6

7

  ProtZustand_u16 = PROT_ZUSTAND_IDLE;

8

  ProtTimerCounter_u16 = 0;

9

10

  AblZustand_u16 = ABL_ZUSTAND_IDLE;

11

  AblTimerCounter_u16 = 0;

12

  AblWdhCounter_u16 = 0;

13

  AblAmountCounter_u16 = 1;

14

  AblGetTitleArtistAlbumCounter_u16 = 0;

15

16

  SendMessage_st.SendeAnforderung_bool = FALSE;

17

  SendMessage_st.Fertig_bool = FALSE;

18

  SendMessage_st.Error_u8 = 0;

19

  SendMessage_st.EmpfangErwartet_bool = FALSE;

20

  SendMessage_st.PauseVorEmpfang_u16 = 0;

21

22

  HAblTimerCounter_u16 = 0;

23

24

}

25

26

27

void ProtZustandsmaschine(void)

28

{

29

  unsigned int i;

30

  unsigned char crc;

31

32

  if(ProtTimerCounter_u16)

33

  {

34

    --ProtTimerCounter_u16;

35

  }

36

37

  switch(ProtZustand_u16)

38

  {

39

    case PROT_ZUSTAND_IDLE:

40

    {

41

      if(SendMessage_st.SendeAnforderung_bool)

42

      {

43

        SendMessage_st.SendeAnforderung_bool = FALSE;

44

        SendMessage_st.Fertig_bool = FALSE;

45

        SendMessage_st.Error_u8 = 0;

46

        ProtZustand_u16 = PROT_ZUSTAND_CALC_SND_CHECKSUM;

47

      }

48

      break;

49

    }

50

    case PROT_ZUSTAND_CALC_SND_CHECKSUM:

51

    {

52

      SendMessage_st.Checksum_u8 = Calculate_CRC(&SendMessage_st);

53

      SendMessage_st.SendeCommand_u16 = SendMessage_st.Command_u16;

54

      ProtZustand_u16 = PROT_ZUSTAND_SEND;

55

      break;

56

    }

57

    case PROT_ZUSTAND_SEND:

58

    {

59

      SendMessage(&SendMessage_st);

60

      ProtZustand_u16 = PROT_ZUSTAND_WAIT1;

61

      break;

62

    }

63

    case PROT_ZUSTAND_WAIT1:

64

    {

65

      //Immer Zwangspause

66

      ProtTimerCounter_u16 = SendMessage_st.PauseVorEmpfang_u16;

67

      ProtZustand_u16 = PROT_ZUSTAND_WAIT2;

68

      break;

69

    }

70

    case PROT_ZUSTAND_WAIT2:

71

    {

72

      if(!ProtTimerCounter_u16)

73

      {

74

        ProtZustand_u16 = PROT_ZUSTAND_RECEIVE;

75

      }

76

      break;

77

    }

78

    case PROT_ZUSTAND_RECEIVE:

79

    {

80

      SendMessage_st.EmpfangAnzahlZeichen_u16=AS1_GetCharsInRxBuf();

81

      if(!SendMessage_st.EmpfangAnzahlZeichen_u16)

82

      {

83

        if(SendMessage_st.EmpfangErwartet_bool)

84

        {

85

          SendMessage_st.Error_u8 = PROT_ERR_KEINE_DATEN_EMPFANGEN;

86

          SendMessage_st.Fertig_bool = TRUE;

87

          ProtZustand_u16 = PROT_ZUSTAND_DATEN_FERTIG;

88

        }

89

        else

90

        {

91

          SendMessage_st.Fertig_bool = TRUE;

92

          ProtZustand_u16 = PROT_ZUSTAND_DATEN_FERTIG;

93

        }

94

      }

95

      else

96

      {

97

        SendMessage_st.Error_u8 = AS1_RecvBlock(SendMessage_st.EmpfangString_au8, SendMessage_st.EmpfangAnzahlZeichen_u16, &SendMessage_st.EmpfangAnzahlZeichen_u16);

98

        if(SendMessage_st.Error_u8 != ERR_OK)

99

        {

100

          AS1_GetError(&SendMessage_st.LetzterSeriellerFehler_st);

101

          SendMessage_st.Fertig_bool = TRUE;

102

          ProtZustand_u16 = PROT_ZUSTAND_DATEN_FERTIG;

103

        }

104

        else

105

        {

106

          //Empfangsdaten einsortieren

107

          SendMessage_st.Header_u16 = (word)((SendMessage_st.EmpfangString_au8[0]<<8) + SendMessage_st.EmpfangString_au8[1]);

108

          SendMessage_st.Lenght_u8 = SendMessage_st.EmpfangString_au8[2];

109

          SendMessage_st.Mode_u8 = SendMessage_st.EmpfangString_au8[3];

110

          SendMessage_st.Command_u16 = (word)((SendMessage_st.EmpfangString_au8[4]<<8) + SendMessage_st.EmpfangString_au8[5]);

111

          if(SendMessage_st.Lenght_u8>=3)

112

          {

113

            for(i=0; i<SendMessage_st.Lenght_u8-3; ++i)

114

            {

115

              SendMessage_st.Parameter_au8[i] = SendMessage_st.EmpfangString_au8[6+i];

116

            }

117

          }

118

          SendMessage_st.Checksum_u8 = SendMessage_st.EmpfangString_au8[6+i];

119

120

          ProtZustand_u16 = PROT_ZUSTAND_CHECK_RCV_DATA;

121

        }

122

      }

123

124

      break;

125

    }

126

    case PROT_ZUSTAND_CHECK_RCV_DATA:

127

    {

128

      //Anzahl der empfangenen Daten überprüfen

129

      if(SendMessage_st.EmpfangAnzahlZeichen_u16 < SendMessage_st.Lenght_u8 + 4)

130

      {

131

        SendMessage_st.Error_u8 = PROT_ERR_ZU_WENIG_DATEN_EMPFANGEN;

132

      }

133

      //Empfangenen Command überprüfen, ob der Wert = SendeCommand+1 entspricht

134

      else if(SendMessage_st.Command_u16 != 1+SendMessage_st.SendeCommand_u16)

135

      {

136

        SendMessage_st.Error_u8 = PROT_ERR_FALSCHER_ANTWORT_COMMAND;

137

      }

138

      else

139

      {

140

        //CRC überprüfen

141

        crc = Calculate_CRC(&SendMessage_st);

142

        if(crc != SendMessage_st.Checksum_u8)

143

        {

144

          SendMessage_st.Error_u8 = PROT_ERR_CRC_FEHLER_IN_DATEN;

145

        }

146

      }

147

148

      SendMessage_st.Fertig_bool = TRUE;

149

      ProtZustand_u16 = PROT_ZUSTAND_DATEN_FERTIG;

150

      break;

151

    }

152

    case PROT_ZUSTAND_DATEN_FERTIG:

153

    {

154

      if(!SendMessage_st.Fertig_bool)

155

      {

156

        ProtZustand_u16 = PROT_ZUSTAND_IDLE;

157

      }

158

      break;

159

    }

160

    default:

161

    {

162

      ProtZustand_u16 = PROT_ZUSTAND_IDLE;

163

      break;

164

    }

165

  }

166

}

167

168

169

170

byte Calculate_CRC(SendMessage_sts *msg)

171

{

172

  unsigned int i;

173

  unsigned char crc = 0x00;

174

175

  crc -= msg->Lenght_u8;

176

  crc -= msg->Mode_u8;

177

  crc -= ((msg->Command_u16)>>8)&0xff;

178

  crc -= (msg->Command_u16)&0xff;

179

180

  if(msg->Lenght_u8 > 3)

181

  {

182

    for(i=0; i<msg->Lenght_u8-3; ++i)

183

    {

184

      crc -= msg->Parameter_au8[i];

185

    }

186

  }

187

188

  return crc;  

189

}

190

191

192

byte SendMessage(SendMessage_sts *msg)

193

{

194

  byte snd[20];

195

  byte err;

196

  word Sent;

197

  unsigned int i, j;

198

199

  j=0;

200

  snd[j++] = (byte)(((msg->Header_u16)>>8)&0xff);

201

  snd[j++] = (byte)((msg->Header_u16)&0xff);

202

  snd[j++] = msg->Lenght_u8;

203

  snd[j++] = msg->Mode_u8;

204

  snd[j++] = (byte)(((msg->Command_u16)>>8)&0xff);

205

  snd[j++] = (byte)((msg->Command_u16)&0xff);

206

207

  for(i=0; i<msg->Lenght_u8-3; ++i)

208

  {

209

    snd[j++] = msg->Parameter_au8[i];

210

  }

211

212

  snd[j] = msg->Checksum_u8;

213

214

  err = AS1_SendBlock((byte*)snd, (word)(msg->Lenght_u8+4), &Sent);

215

216

  return err;

217

}

218

219

220

221

222

void Ablaufsteuerung(void)

223

{

224

  if(AblTimerCounter_u16)

225

  {

226

    --AblTimerCounter_u16;

227

  }

228

229

  switch(AblZustand_u16)

230

  {

231

    case ABL_ZUSTAND_NACH_DEM_EINSCHALTEN:

232

    {

233

      AblTimerCounter_u16 = ABL_PAUSE_NACH_DEM_EINSCHALTEN;

234

      AblZustand_u16 = ABL_ZUSTAND_WAIT10;

235

      AblWdhCounter_u16 = 0;

236

      break;

237

    }

238

    case ABL_ZUSTAND_WAIT10:

239

    {

240

      if(!AblTimerCounter_u16)

241

      {

242

        AblZustand_u16 = ABL_ZUSTAND_SWITCH_MODE_4;

243

      }

244

      break;

245

    }

246

    case ABL_ZUSTAND_SWITCH_MODE_4:

247

    {

248

      SendMessage_st.Header_u16  = HEADER_STANDARD;

249

      SendMessage_st.Lenght_u8   = 0x03;

250

      SendMessage_st.Mode_u8     = MODE_MODE_SWITCHING;

251

      SendMessage_st.Command_u16   = SWITCH_AIR_MODE;

252

      //SendMessage_st.Parameter_au8[...] = ???;

253

      SendMessage_st.EmpfangErwartet_bool = FALSE;

254

      SendMessage_st.SendeAnforderung_bool = TRUE;

255

      SendMessage_st.PauseVorEmpfang_u16 = PROT_PAUSE_VOR_EMPFANGEN_LANG;    //Pausezeit vor erwarteten Empfangsdaten setzen

256

257

      AblTimerCounter_u16 = ABL_PAUSE_NACH_JEDEM_PROTOKOLL;

258

      AblZustand_u16 = ABL_ZUSTAND_SWITCH_MODE_4_WAIT;

259

      break;

260

    }

261

    case ABL_ZUSTAND_SWITCH_MODE_4_WAIT:

262

    {

263

      if(!AblTimerCounter_u16)

264

      {

265

        if(SendMessage_st.Fertig_bool)  //Protokoll abgearbeitet?

266

        {

267

          SendMessage_st.Fertig_bool = FALSE;

268

//          AblZustand_u16 = ABL_ZUSTAND_STOP;

269

          AblZustand_u16 = ABL_ZUSTAND_GET_IPOD_NAME;

270

        }

271

      }

272

      break;

273

    }

274

/*    case ABL_ZUSTAND_STOP:

275

    {

Diese "Ablaufsteuerung" ist eine der ZM's. Sie geht natürlich noch 
weiter, aber hier kann man schön das Schema ablesen. Ich beginne mit dem 
Zustand nach dem Einschalten, Schalte dann in Mode 4, mach eine Pause 
und weiter geht's dann mit dem Namen des iPod, mit der Anzahl der 
einzelnen Items (Anz Playlisten, anz Alben, anz...), u.s.w.



Hier noch die zugehörige Struktur:

1

typedef struct {

2

  word Header_u16;

3

  byte Lenght_u8;

4

  byte Mode_u8;

5

  word Command_u16;

6

  byte Parameter_au8[64];

7

  byte Checksum_u8;

8

9

  bool SendeAnforderung_bool;

10

  bool EmpfangErwartet_bool;

11

  bool Fertig_bool;

12

13

  word EmpfangAnzahlZeichen_u16;

14

  unsigned char EmpfangString_au8[64];

15

16

  AS1_TError LetzterSeriellerFehler_st;

17

  byte Error_u8;

18

19

  word SendeCommand_u16;

20

21

  unsigned int PauseVorEmpfang_u16;

22

23

} SendMessage_sts;

Hoffe ich konnte ein wenig weiterhelfen.
Aber ein bißchen Arbeit müsst Ihr Euch auch noch machen :-)
Außerdem lern man viel dabei.

Gruß Klaus.

Hallo

Also dann werde ich euch auch mal in diesem Thread auf die Nerven gehen. 
;)
Kennt hier jemand zufällig das CDC Protokoll des Audi Radios Concert 2+ 
(DoppelDIN)? Manchmal auch fälschlich als Concert 3 bezeichnet. Ist das 
evtl. auch das Panasonic Protokoll oder, da dieses Gerät imho von 
Blaupunkt ist, evtl. ein Blapunkt Protokoll? Und da dieses Gerät am CDC 
Stecker zwei Audio eingänge besitzt (AUX und CDC IN) suche ich eine 
Möglichkeit beide verwenden zu können. Könnte ja sein das man wie bei 
einem CD Simulator noch zusätzlich ein AUX In simulieren muss. Kenn sich 
da jemand aus und kann mir weiterhelfen?

Gruß
Hansi

Hallo!
Mal in absoluter Kurzform, da ich im Moment wenig Zeit habe:
- Grundsätzlich habe ich mein Programm so gestaltet, dass ich in einer 
Variablen immer die momentan gewählten Abspiel-Art (also Playlist, 
Album, ...), in einer weiteren die Item-Nummer (also Playlist-Nr, 
Album-Nr, ... ) und in einer dritten die Titel-Nr. mitführe.
- Ändere ich eine dieser Vars (von Außen z.B. über Monitor-Programm, 
oder über Radio-Tastendruck) dann wird diese Ereignis erkannt und in der 
richtige Befehl (s. u.) ausgewählt.
- Meine SW fragt (bis auf die Titel-Nr und eine Ausnahme (wenn das Item 
zu ende läuft)) nicht ab, wo gerade gespielt wird, da ich das ja aus 
meinen Vars lesen kann (-> Datenfluss nur in eine Richtung, von µC -> 
iPod).
- Den Wechsel zwischen den Abspiel-Arten (also Wechsel von Playlist auf 
Album, oder Album auf Interpret, ...) habe ich folgendermaßen 
realisiert:
  1.) Wechsel innerhalb des selben Abspiel-Typs: Befehl 1
  2.) Wechsel von Playlist -> anderes Item (Album, ...): Zunächt auf 
Playlist 0 wechseln (mit Befehl 1 / um Zugriff auf ALLE Titel zu haben), 
dann Befehl 2 um von Abspielart Playlist auf andere Abspielart zu 
wechseln
  3.) Wechsel von Anderer Art -> Playlist: Wieder über Befehl 1
Die Befehle schaue ich später noch nach!

Gruß Klaus

Hallo!
Wenn ich bei meiner Steuerung ein neues Album anwähle, also global 
gesagt: Item+ oder Item- anwähle, dann fange ich auch immer bei Track 1 
an.
Ist es das was Du meintest?
Aber man kann sich ja sicherlich auch die Pos im jeweiligen Item merken 
und dort wieder hinsprigen. Ich fand das nur doof, wenn ich den iPod 
rausgenommen habe und evtl ein neues Album zugefügt habe, dann springt 
er immer irgendwo hin, weil die SW ja nicht weiß wo genau das neue Album 
in der Album-List dazugekommen ist. Aber auch da kann man sicherlich 
viel, viel Programmieren. Ich habe allerdigs nur 16kWord ROM zur 
Verfügung, daher bin ich so zufrieden.
Befehle kommen noch... Sorry für die Verzögerung.

Gruß Klaus

Hallo Schorsch!
Glaube wir haben ein bißchen aneinander vorbei geredet!
Fasse noch einmal meine Funktionen zusammen:
- Wenn ich mein Autoradio ausschalter, dann geht der iPod lediglich auf 
Pause
- Schalte ich wieder an, dann wird einfach weitergespielt, d. h. sogar 
exakt an der selben Stelle (natürlich im selben Titel des selben Albums 
(besser Items))
- Nehme ich den iPod raus (egal ob bei ein- oder ausgeschaltetem Radio) 
initialisiere ich neu. D. h. auf Mode 4 schalten, Abspielen pauschal 
stoppen, Ipod-Namen lesen, Anzahl ALLER Items einlesen (Anz Playlisten, 
Anz Artits, Anz Alben, ...), Auf Playlist 0 schalten, Auf zuletzt 
gespieltes Item schalten

Dabei wird also auf jeden Fall der zuletzt gespielte Item-Typ und die 
letzte Item-Nummer angewählt. Ledglich die Track Nummer wird immer auf 1 
gesetzt, da ich mir diese nicht merke. Sonst muss ich ja einen Vektor 
erstellen, der für jedes Item sich die zuletzt gespielte Track-Nummer 
merkt. Wäre zwar möglich, aber ich denke das mich das verwirrt, denn man 
ist ja gewohnt immer den ersten Titel zu hören, wenn man z. B. am 
CD-Wechsler einen neue CD wählt!

Also, wie gesagt, ich fange auch nicht immer wieder bei Album 1 an!


Zu dem Wechsel der Abspiel-Art (Item-Typ) von Oben:


Fall 1) Playlist wird gespielt. Neue Playlist wird angewählt.
Das Kommando HABL_COMMAND_SWITCH_TO_PLAYLIST wird ausgeführt.

1

      SendMessage_st.Header_u16  = HEADER_STANDARD;

2

      SendMessage_st.Lenght_u8   = 0x08;

3

      SendMessage_st.Mode_u8     = MODE_AIR;

4

      SendMessage_st.Command_u16   = AIR_IPOD_SWITCH_TO;

5

      SendMessage_st.Parameter_au8[0] = iPodData_st.Parameter1ToExecute_u8;  //Item-Type

6

      SendMessage_st.Parameter_au8[1] = 0;

7

      SendMessage_st.Parameter_au8[2] = 0;

8

      SendMessage_st.Parameter_au8[3] = (byte)((iPodData_st.Parameter2ToExecute_u16>>8)&0xff);  //Item-Nr.

9

      SendMessage_st.Parameter_au8[4] = (byte)(iPodData_st.Parameter2ToExecute_u16&0xff);

10

      SendMessage_st.EmpfangErwartet_bool = FALSE;

11

      SendMessage_st.SendeAnforderung_bool = TRUE;

12

      SendMessage_st.PauseVorEmpfang_u16 = PROT_PAUSE_VOR_EMPFANGEN_STD;    //Pausezeit vor erwarteten Empfangsdaten setzen

Danach Execute:

1

      SendMessage_st.Header_u16  = HEADER_STANDARD;

2

      SendMessage_st.Lenght_u8   = 0x07;

3

      SendMessage_st.Mode_u8     = MODE_AIR;

4

      SendMessage_st.Command_u16   = AIR_EXECUTE_PLAYLIST_AND_JUMP_TO_SONGNUMBER;

5

//      SendMessage_st.Command_u16   = AIR_EXECUTE_PLAYLIST_AND_SWITCH_TO_SONG_IN_CURRENT_PLAYLIST;

6

      SendMessage_st.Parameter_au8[0] = 0x00;

7

      SendMessage_st.Parameter_au8[1] = 0x00;

8

      SendMessage_st.Parameter_au8[2] = (byte)((iPodData_st.Parameter3ToExecute_u16>>8)&0xff);

9

      SendMessage_st.Parameter_au8[3] = (byte)(iPodData_st.Parameter3ToExecute_u16&0xff);

10

//      SendMessage_st.Parameter_au8[2] = 0x00;

11

//      SendMessage_st.Parameter_au8[3] = 0x00;

12

13

      SendMessage_st.EmpfangErwartet_bool = FALSE;

14

      SendMessage_st.SendeAnforderung_bool = TRUE;

15

      SendMessage_st.PauseVorEmpfang_u16 = PROT_PAUSE_VOR_EMPFANGEN_STD;    //Pausezeit vor erwarteten Empfangsdaten setzen

Fall 2) Playlist wird abgespielt. Item <> Playlist wird gewählt (also 
Artist, Album, ...)
Das Kommando HABL_COMMAND_SWITCH_TO_PLAYLIST_0_TO_ITEM wird ausgeführt.

1

      SendMessage_st.Header_u16  = HEADER_STANDARD;

2

      SendMessage_st.Lenght_u8   = 0x08;

3

      SendMessage_st.Mode_u8     = MODE_AIR;

4

      SendMessage_st.Command_u16   = AIR_IPOD_SWITCH_TO;

5

      SendMessage_st.Parameter_au8[0] = ABSPIELTYPE_PLAYLIST;

6

      SendMessage_st.Parameter_au8[1] = 0;

7

      SendMessage_st.Parameter_au8[2] = 0;

8

      SendMessage_st.Parameter_au8[3] = 0;  //Playlist 0

9

      SendMessage_st.Parameter_au8[4] = 0;  //Playlist 0

10

      SendMessage_st.EmpfangErwartet_bool = FALSE;

11

      SendMessage_st.SendeAnforderung_bool = TRUE;

12

      SendMessage_st.PauseVorEmpfang_u16 = PROT_PAUSE_VOR_EMPFANGEN_STD;    //Pausezeit vor erwarteten Empfangsdaten setzen

Danach den o. g. HABL_COMMAND_SWITCH_TO_PLAYLIST ausführen, um auf das 
Item zu springen.
Nur so sind in den anderen Abspiel-Modi (<> Playlist) überhaupt alle 
Titel und Items verfügbar.
Zumindest habe ich das so erfahren.
Wenn man NICHT zuvor auf Pl 0 springt, dann sind lediglich die Titel und 
Items verfügbar, die in der momentan gespielten Playlist vorhanden sind.
Also eine Art "verundeter Filter".


Der Vollständigkeit halber hier noch meine Defines:

1

//iPod-Protokoll

2

//HEADER

3

#define HEADER_STANDARD      0xff55

4

5

//MODES

6

#define MODE_MODE_SWITCHING    0x00

7

#define MODE_VOICE_RECORDER    0x01

8

#define MODE_SIMPLE_REMOTE    0x02

9

#define MODE_AIR        0x04

10

11

//COMMANDS

12

//Switching-Commands

13

#define SWITCH_COMMAND_MODE    0x0102

14

#define SWITCH_AIR_MODE      0x0104

15

16

//Original-Remote-Commands

17

#define ORC_PLAY_PAUSE      0x0001

18

#define ORC_VOL_PLUS      0x0002

19

#define ORC_VOL_MINUS      0x0004

20

#define ORC_SKIP_FORWARD    0x0008

21

#define ORC_SKIP_BACK      0x0010

22

#define ORC_BUTTON_RELEASE    0x0000

23

24

//Advanced iPod Remote (AiR)

25

#define AIR_IPOD_NAME                  0x0014

26

#define AIR_IPOD_SWITCH_TO                0x0017

27

#define AIR_IPOD_AMOUNT_OF                0x0018

28

#define AIR_GET_TIME_AND_STATUS_INFO          0x001c

29

#define AIR_GET_POSITION_IN_CURRENT_PLAYLIST      0x001e

30

#define AIR_GET_TITLE_OF_SONGNUMBER            0x0020

31

#define AIR_GET_ARTIST_OF_SONGNUMBER          0x0022

32

#define AIR_GET_ALBUM_OF_SONGNUMBER            0x0024

33

#define AIR_EXECUTE_PLAYLIST_AND_JUMP_TO_SONGNUMBER    0x0028

34

#define AIR_PLAYBACK_CONTROL              0x0029

35

#define AIR_GET_SHUFFLE_MODE              0x002c

36

#define AIR_SET_SHUFFLE_MODE              0x002e

37

#define AIR_GET_REPEAT_MODE                0x002f

38

#define AIR_SET_REPEAT_MODE                0x0031

39

#define AIR_GET_NUMBER_OF_SONGS_IN_CURRENT_PLAYLIST    0x0035

40

#define AIR_EXECUTE_PLAYLIST_AND_SWITCH_TO_SONG_IN_CURRENT_PLAYLIST      0x0037

41

42

//Sonstiges

43

#define ABSPIELTYPE_NICHT_DEFINIERT    0

44

#define ABSPIELTYPE_PLAYLIST      1

45

#define ABSPIELTYPE_ARTIST        2

46

#define ABSPIELTYPE_ALBUM        3

47

#define ABSPIELTYPE_GENRE        4

48

#define ABSPIELTYPE_SONG        5

49

#define ABSPIELTYPE_COMPOSER      6

Hoffe das hilft weiter.
Gruß Klaus.

Das weiß ich auch nicht. Daher initialisiere ich ihn ja auch immer nach 
jedem "Anschließen".
Dann springe ich einfach zu DER Playlist (oder DEM Album, oder dem ...) 
und dem Titel, welchen ich zuletzt gespielt habe.

Hallo Georg,
bis zum EEprom bin ich gar nicht mehr gekommen.
Begründung: Zunächst wollte ich auch immer die Versorgung der CPU 
abschalten, weil ich "Angst" um meine Autobatterie hatte.
Das hat nur leider einen entscheidenden Nachteil: Wenn man den iPod im 
ausgeschalteten Zustand herausnimmt, dann "merkt" der Controller ja nix 
davon. Steckt man ihn nun wieder herein (nachdem man z. B. mit iTunes 
neue Titel aufespielt hat), so bekommt die CPU das ebenfalls nicht mit. 
Beim Wiedereinschalten versucht er also einfach vom Pause- in den 
Play-Zustand zu wechseln, bzw. erkennt gar nicht die Anzahl der Items 
korrekt, was beim o.g. Bedienkonzept zu Problemen führen kann.
Also habe ich mich mit dem Thema Energiespar-Modi befaßt. Da meine 
Schaltung nur ein paar Zehn Milliamps zieht war mir auch das den Aufwand 
nicht wert, denn dann muss man mit HW-Interupts bei "iPod-Bewegung" aus 
dem Sleep-Mode aufwachen und entsprechend reagieren.
Jetzt bleibt's eben an und das dürfte (bei normalem KFZ-Betrieb) der 
Batterie nix ausmachen.
Gruß Klaus.

Nach all den Antworten habe ich jetzt aber auch mal eine Frage an Euch 
:-)
Wie kann ich denn die Videos, die auf dem iPod abgelegt sind, 
ansprechen? Habe z.B. einige Muskivideos geladen, die ich im Auto hören 
möchte.
Zudem passiert manchmal etwas Seltsames: Habe ich z. B. mit dem iPod im 
Zug ein Video geschaut und stecke ihn dann zurück ins Auto, so findet er 
plötzlich nur noch ein oder zwei Videos; alle Audio-Items sind nicht 
mehr ansprechbar. Da hilft auch nicht meine oben beschriebene 
Initialisierung.
Muss den iPod dann entnehmen, "per Hand" irgendeine Playlist wählen, und 
wieder reinstecken. Er macht dann einen neuen Init und es läuft ganz 
normal.
Was kann das sein? Was mache ich falsch bei der Initialisierung? Gibt es 
Zugriff auf die Videos?
Danke für Eure Antworten.
Gruß Klaus.

Hallo zusammen,

tut mir Leid, dass ich noch eine Frage dazwischenschiebe :)
Ich will meinen iPod ebenfalls an das Autoradio über den Wechslereingang 
anschließen. Ich habe dazu den Anschluss mit 13-poligem DIN Stecker im 
Kofferraum.

Jetzt frage ich mich, ob ich das Signal verstärken soll, um möglichst 
eine gute SNR am Autoradio hinzubekommen.
Der iPod spuckt am Interfacestecker bei Vollaussteuerung ein Signal mit 
genau 1V Amplitude (2V Spitze-Spitze) aus.

Jetzt meine Frage: Weiß jemand von euch, mit welcher Amplitude der 
originale VW/Audi CD-Wechsler das Audiosignal (bei Vollaussteuerung) auf 
die Reise schickt? Bzw. mit welcher maximalen Amplitude kann ich an das 
Radio rangehen ohne zu übersteuern?

Danke im voraus.

Grüßle
Marcus

Hallo,

um meine Zwischenfrage mal selbst zu beantworten:

Ich habe einen Audi CD-Wechsler in die Hände bekommen und konnte mal ein 
bisschen messen. Dazu habe ich mir eine kleine Zwischenplatine aus 
Reichelt-Teilen hergestellt.
Das Ergebnis: Das Signal aus dem CD-Wechsler hat eine Amplitude von 
genau 2V (4V Spitze-Spitze), d.h. um eine gute SNR hinzubekommen, sollte 
man das Audiosignal, welches aus dem iPod-Dock-Connector kommt, um ca. 
6dB anheben.

Grüßle
Marcus

Hallo Klaus,

vielen Dank für deine Anregung! Auf die Idee mit den EQ-Einstellungen 
bin ich noch garnicht gekommen.
Ich spiele zum Vergleich eine Audiodatei mit einem Sinus-sweep von 
0-22kHz ab, welche sich auf dem iPod Nano 3. Generation (das breite 
Ding) und einer gebrannten CD für den Wechsler befindet.
Ich habe gerade noch einmal das Oszi angefeuert und mal die 
EQ-Einstellungen durchprobiert.
Die Messungen bestätigen Dein Gehör: Bei eingeschaltetem EQ tritt bei 
gewissen Signalfrequenzen (abh. von gewählter EQ-Einstellung) Clipping 
auf, d.h. schon am Dock-Ausgang des iPods ist das Signal übersteuert 
(was ja irgendwie dämlich ist).

Grüßle
Marcus

P.S. Ist ja echt ein feines Projekt, was Du da durchgezogen hast, Klaus. 
Ich habe mir die Pläne dazu mal angeschaut. Etwas Ähnliches, nur in 
weniger ausgeklügelter Art, möchte ich auch machen. Im Moment knabber 
ich gerade an der Kommunikation von Radio zu Wechsler :)

Hallo Marcus,
das ging aber fix! :-)
Wenn Du Lust hast, dann denk' Dir doch mal eine schicke OP-Schaltung 
aus, dias das mit den +6dB erledigt.
Zwischenfrage: Warum eigentlich 6dB und nicht 3dB zur Verdopplung? Hat 
das mit linear- und quadratisch-gewichteten Einheiten zu tun? Also hier 
Spannung, d.h. 20*log(...)?
Die OP-Schaltung würde ich dann gern in meine Schaltung mit aufnehmen. 
Evtl. bestelle ich mir dann (nach noch ein paar kleinen Updates) eine 
neue Platine.
Schöne Grüße,
Klaus

Hallo,

ich habe mir schon eine kleine OP-Schaltung überlegt, Teile sind auch 
schon da. In der Simulation funktioniert's natürlich schon. Ich muss nur 
mal dazu kommen, eine Testschaltung aufzubauen, denn das größte Problem 
wird wahrscheinlich das Drehzahlbrummen werden. Wenn ich das habe, 
schreibe ich das hier rein.

Ich habe mit einer kleinen Experimentierplatine jetzt erfolgreich die 
Kommunikation zwischen dem CD-Wechsler und dem Radio abhorchen können. 
Die Nachrichten Wechsler->Radio sind sehr vielfältiger als unter lafrog 
angegeben. In den höchsten 4 Bits des ersten und letzten Bytes scheinen 
auch irgendwelche Statusbits untergebracht zu sein, ich verstehe nur 
noch nicht, was diese bedeuten. Das vorletzte Byte kennt anscheinend 
auch noch ein paar andere Zustände. Dazu kommt noch, dass der 
CD-Wechsler anscheinend defekt ist. Manchmal spielt er, manchmal nicht. 
Wenn er nicht geht (so wie bei meiner Aufzeichnungssession gestern) dann 
wechselt er die CDs durch und zeigt vorne nur an "CD Error".
Ich habe das Log mal angehängt. Der Wechsler fängt genau alle 50ms an, 
eine Nachricht auf die Reise zu schicken. Die CDC Messages kommen vom 
Wechsler, die Radio Messages vom Radio (Msgs mit Kommando 0x14 sind 
bereits ausgeblendet).

Gibt es irgendwo noch eine näher detaillierte Protokollbeschreibung als 
bei lafrog?

Grüßle und Vielen Dank
Marcus

P.S.: Sorry, wenn da etwas mit den 6dB verbuchselt habe. Ich komme aus 
der Regelungstechnik. Bei uns entsprechen 20dB einer Dekade, weil wir 
das Verhältnis der Quadrate als Größe heranziehen. Also bei mir ist eine 
Verdopplung +6dB, weiß nicht wie die Elektrotechniker das machen :)

Den hatte ich vergessen...

Hallo Klaus,

vielen Dank für Deine Antwort!

ich habe noch einmal Deinen Beitrag in dem anderen Thread gelesen. Die 
"Keep-Alive"-messages, wenn der Wechsler nicht aktiv ist (z.B. Radio im 
Radioempfang-Modus), decken sich mit den Deinen, wenn man die Bits 
invertiert (das sind die messages ganz am Schluss der Datei). Ich habe 
die Messages hier so interpretiert wie auf der Website lafrog. Der 
Vorteil ist dann, dass man Track/CD direkt aus der Message ohne 
großartiges Kopfrechnen herauslesen kann :)
Wenn ich im nächsten Schritt dann selber Nachrichten sende, muss ich die 
Nachrichten natürlich wieder bitweise invertiert an die SPI-Hardware 
übergeben.

Im Betrieb scheint er an den ersten und vorletzten vier Bits etwas zu 
verändern. Das deckt sich mit Deiner Beobachtung, dass Du im letzten 
Byte etwas drehen musst, damit das Radio wieder reagiert, wenn es 
zyklisch sendet. Da stecken wohl noch ein paar Status- und 
Acknowledgebits drin.

Wenn der Wechsler letzte Woche getan hätte, hätte ich die von Dir 
geschilderte Kommunikation mit dem "Taste gedrückt halten" auch gleich 
ausprobiert. Ich probiere das am Wochenende oder am Feiertag nocheinmal 
aus und hoffe, dass das Ding dann mal wieder richtig läuft, denn dann 
werde ich die Messungen nochmal wiederholen und bestimmte use-cases 
durchprobieren.

Als Radio habe ich ein altes Audi Navigation Plus aus einem alten A8 und 
den CD-Wechsler zur Kofferraummontage. Da war glaube ich noch ein 
Aufkleber mit einer Teilenummer drauf, die habe ich aber nicht 
aufgeschrieben. Das muss ich dann auch nochmal nachschauen.

Grüßle
Marcus

Ich habe heute nochmal meinen Controller rangehängt. Tatsächlich hat der 
Wechsler erstmal wieder funktioniert.
Ich habe mal das Protokoll angehängt und bis Zeile 1493 kommentiert.

Irgendwie ist bei dem Programmcode für das Einlesen der Kommandos vom 
Radio etwas schiefgelaufen. Manchmal "verschluckt" er Kommandos, was 
aber glaube ich daran liegt, dass die vielen Aufrufe der 
Interruptroutinen sich oft gegenseitig blockieren und so mal ein paar 
Bits verschluckt werden. Den Code habe ich nicht komplett selber 
geschrieben, ich habe mich da auch stark am Code von Matthias Kölling 
Beitrag "Re: CD Wechsler Protokoll" 
orientiert.

Dann gibt es da aber noch ein größeres Problem. Irgendwie scheint er die 
"Taste ist gedrückt" Nachricht nicht korrekt zu empfangen. Ich hätte 
eigentlich erwartet, dass das Radio periodisch ein leeres Paket mit 
kürzerer erster low-Phase schickt (wie auf lafrog). Ich habe da gesagt, 
er soll die Nachricht

1

0xDEADBEEF

 auf das Terminal schicken. Da kommt aber nichts an.
Oder kommt da gerade immer die Nachricht

1

0x532C14EB

die ich ausgeblendet habe? Habe es leider nicht mehr testen können.
Ich habe immer nur

1

0x532CE41B

 nach loslassen der Spulentaste vom Radio empfangen...

Um zu schauen, ob da überhaupt etwas auf der Leitung kommt, wenn man 
eine Spul-Taste gedrückt hält, wollte ich nochmal mit dem Oszi ran, aber 
gerade da wollte der CD-Wechsler nicht mehr... wieder nur CD Error.

Immerhin sieht man in dem Log gut, was der Wechsler bei "Spulen-Anfang" 
und "Spulen-Ende" sendet, was für Dich interessant sein könnte, Klaus.

Grüßle
Marcus