Eigenes tool programmieren

Beitrag von **mgck** » Samstag 24. November 2007, 15:53

Hallöchen.

Ich versuche ein kleines Tool in C für die dbox2 (Neutrino) zu schreiben.
Das Tool soll über die RS232 einige Daten versenden.
Uhrzeit,ChannelName, und Programmfortschritt.

Kann mir mal jemand dabei helfen und mir sagen wie ich an den ChannelName innerhalb meines C Tools komme?

Ich habe jetzt schon stunden lang die C files im cdk durchsucht aber eigentlich nicht wirklich was gefunden.
Die Uhrzeit über rs232 auszugeben klappt jedenfalls schon.

Ich habe zwar einige Grundkenntnisse in C, aber die reichen man gerade um einige kleine Änderungen an den Neutrino sources durchzuführen.
Bin halt auch schon mal froh das mein tool nach einem make compelliert wird.

gruß mgck

Beitrag von **Houdini** » Samstag 24. November 2007, 16:12

guck dir mal die libzapitclient an

Beitrag von **seife** » Samstag 24. November 2007, 16:12

Schau mal in den pzapit sourcecode, das kann das auch:

Code: Alles auswählen

/ $ pzapit -gi
44d00016dca (Das Erste)

Beitrag von **mgck** » Samstag 24. November 2007, 17:10

Ok Danke schon mal für die Tips.

Gefunden in pzapit.cpp habe ich folgendes.

Code: Alles auswählen

if (getchannel)
	{
		t_channel_id channel = zapit.getCurrentServiceID();
		printf("%llx (%s)\n", channel, (zapit.getChannelName(channel)).c_str());
		return 0;
	}

Jetzt kommt aber das größte Problem aller Probleme.

Was für Headerfiles brauche ich um auf die Zapit geschichte zuzugreifen?
Wie binde ich diese richtig ein.

Ich hatte natürlich auch schon so manche Idee Funktionen aus anderen bereichen zu nutzen leider scheiterte das dann immer beim einbinden der Headerfiles. Die fehler das sie nicht gefunden werden rauschen dann nur so durch. Muß evtl. noch was an meinem Makefile geändert werden?

gruß

Beitrag von **Tommy** » Samstag 24. November 2007, 19:13

....hört sich nach einem externen Display an

Beitrag von **mgck** » Samstag 24. November 2007, 19:27

Gut erkannt.

Das Display wir im Moment von einem Atmega16 angesteuert. Die Daten
werden über die Serielle empfangen. Das funktioniert auch schon ganz gut, jedenfalls im Simulator. Hatte leider keinen Pegelwandler (MAX232) rumliegen deswegen ist die Ansteuerung noch nicht ganz fertig.

Den Atmega programmiere ich über Bascom komm mit Basic einfach besser klar.

Ich könnte nun natürlich in Neutrino rumfuschen um die daten wegzusenden, da ich aber irgendwann mal meinem ufs910 ein GrafikDisplay verpassen möchte (Soll. Ein Gruß an meine Frau) sollte es schon ein eigenes Tools sein.

gruß

Beitrag von **Tommy** » Samstag 24. November 2007, 20:16

Die Atmegas kommen doch supi mit iÂ²c klar und alle infos fürs Dbox Display gehen imo über den Bus. Kannste den nicht anzapfen? Über die serielle kommt ja alles mögliche. Da mußt Du ganz schön filtern.

BTW - bau in Dein Plugin noch ein paar "Schaltmöglichkeiten" ein den Atmega nur für ein Display zu nutzen wär Verschwendung - der hat soooo viele Ausgänge

(je nach Typ)

Beitrag von **mgck** » Samstag 24. November 2007, 21:07

Ja mal sehen was man da noch so machen kann. Erstmal klein anfangen.
Klar über die Serielle kommt ne ganze mal testen ob meine Startsequenz erkannt wird und kein qaudawelsch rauskommt

gruß

Zwei der Probleme sind einfach zu lösen:
Benutze einfach die freie serielle Schnittstelle vom Modem. Dort kommt kein Datenmüll raus, der erstmal gefiltert werden muss. Ausserdem wird kein RS232 benötigt, weil das Signal schon im TTL Pegel anliegt.

Beitrag von **mgck** » Sonntag 25. November 2007, 13:00

Auch eine gute Idee.
Estmal muß ich aber sehen wie ich an die Daten (ChannelName und Fortschritt] komme.

gruß

Beitrag von **Houdini** » Sonntag 25. November 2007, 13:22

Code: Alles auswählen

if (getchannel)
   {
      t_channel_id channel = zapit.getCurrentServiceID();
      printf("%llx (%s)\n", channel, (zapit.getChannelName(channel)).c_str());
      return 0;
   }

Code: Alles auswählen

void CInfoViewer::showLcdPercentOver()
{
	if (g_settings.lcd_setting[SNeutrinoSettings::LCD_SHOW_VOLUME] != 1)
	{
		int runningPercent=-1;
		time_t jetzt=time(NULL);
		if ( ! (info_CurrentNext.flags & CSectionsdClient::epgflags::has_current) ||
		     jetzt > (int)(info_CurrentNext.current_zeit.startzeit + info_CurrentNext.current_zeit.dauer))
		{
			info_CurrentNext = getEPG(channel_id);
		}
		if ( info_CurrentNext.flags & CSectionsdClient::epgflags::has_current)
		{
			if (jetzt < info_CurrentNext.current_zeit.startzeit)
				runningPercent = 0;
			else
				runningPercent=MIN((jetzt-info_CurrentNext.current_zeit.startzeit) * 100 /
					            info_CurrentNext.current_zeit.dauer ,100);
		}
		CLCD::getInstance()->showPercentOver(runningPercent);
	}
}

Da gibt es doch ein PlugIn mit dem man Befehle an der RS232 absetzen kann...

Gruß
____Paule

Beitrag von **mgck** » Sonntag 25. November 2007, 13:33

Die stellen hatte ich auch schon gefunden, aber dennoch ein dank an dir.

Nur wie kann ich aus meinem Tool auf die Funktionen der pzapit oder InfoViewer zugreifen ?

Ein kleines Beispiel währe der Hammer.

Gruß mgck

Schau mal hier... http://www.jackthegrabber.de/viewtopic.php?t=7048

Code: Alles auswählen

Dieser Wrapper dient dazu, aus Scripten heraus über die serielle Schnittstelle der DBox 
mit Geräten zu kommunizieren. Da mit einem Script weder Binärdaten ausgegeben oder aus- 
gewertet werden können noch z.B. Checksummen über XOR berechnet werden können, bietet 
der Wrapper eine Kommandozeilenschnittstelle, über welche solche Aufgaben und Auswertun- 
gen möglich sind. 
Geöffnet und konfiguriert wird die Schnittstelle mit dem ebenfalls im Archiv befindlichen "stty". 

Installation: 
comwrap und stty kommen mit den Rechten 755 nach /var/bin/. Mehr ist für die Installation 
nicht zu tun. 

Nutzung: 
Bevor die serielle Schnittstelle verwendet werden kann, muß sie zunächst erst einmal geöff- 
net und konfiguriert werden. Voraussetzung ist allerdings, daß die Bootkonsole von Neutrino 
nicht auf "seriell" eingestellt ist, da es sonst zu gegenseitigen Beeinflussungen kommt. 
Geöffnet und konfiguriert wird die Schnittstelle mit "stty". Die Aufrufsyntax von "stty" 
kann man sich in den Linux-Beschreibungen anschauen. Eine Beschreibung findet man zum Bei- 
spiel auf http://www.computerhope.com/unix/ustty.htm. 
Um zum Beispiel den externen Com-Port mit den Parametern 19200 Baud und 8 Datenbit zu öffnen, 
ist zu Beginn des Scriptes folgendes Kommando auszuführen: "stty 19200 cs8 </dev/tts/0" 

Nun kann man über den Aufruf von comwrap Daten zur Schnittstelle senden oder von ihr empfan- 
gen. Da empfangene Daten über die Kommandozeile zurückgegeben werden, können diese mit der 
Aufrufsyntax "Variablenname=`comwrap ...`" einer Variablen zugewiesen und anschließend aus- 
gewertet werden. Der Erfolg von Lese- und Schreibkommandos kann unmittelbar nach dem Aufruf 
über die Systemvariable "$?" abgefragt werden. "0" bedeutet erfolgreiche Ausführung des Vor- 
gangs, "1" bedeutet, daß ein Fehler aufgetreten ist. 

Aufrufsyntax von comwrap: 

comwrap Device Mode [Konsolenformat] [Comformat] [Endezeichen] [Checksumme] [zu lesende Bytes] [Senddaten [Sendedaten [...]]] 

Device 
welcher Port soll verwendet werden? 
-d0: externer Port 
-d1: interner Port 

Mode 
was wollen wir machen? 
-r: Empfangen 
-w: Senden 

Konsolenformat 
wie sollen die vom Script übergebenen Daten interpretiert werden? 
-ks: als String 
-kd: als Dezimalzahl 
-kh[s]: als Hex-Zahl, mit -khs sowohl bei Ein- als auch bei Augabe mit Leerzeichen getrennt 
-kb: als Byte 

Portformat 
wie sollen die interpretierten Daten auf den Port ausgegeben werden? 
-ps: als String 
-pb: als Byte 
-ph[s]: als Hex-Zahl, mit -phs sowohl bei Ein- als auch bei Augabe mit Leerzeichen getrennt 

Endezeichen: 
sollen Endezeichen angehängt werden? 
-ec: beim Schreiben Carriage Return anhängen, beim Lesen nach Carriage Return abbrechen (0x0D) 
-el: beim Schreiben Line Feed anhängen, beim Lesen nach Line Feed abbrechen (0x10) 

Checksumme 
erfolgt eine Kommunikation mit Checksumme und wie sieht die aus? 
-co[n]: alle Zeichen werden mit XOR verknüpft und von dem Ergebnis werden n Bytes berücksichtigt 
-ca[n]: alle Zeichen werden vorzeichenlos addiert und vom Ergebnis werden n Bytes berücksichtigt 

zu lesende Bytes 
beim Lesen von Binärdaten vom Port sollen wieviele Bytes gelesen werden? 
-nz: es sollen z Bytes empfangen werden 


Beispiel: http://www.produktinfo.conrad.com/datenbla...ach_seriell.pdf 
Um nun zum Beispiel auf dem in dieser Anleitung beschriebenen Conrad-Relaisboard das Relais Nummer 
3 (Bitwert 4) zu setzen, ruft man den Wrapper so auf: 

comwrap -d0 -w -kd -pb -co1 3 1 4 
comwrap -d0 -r -kd -pb -n4 

An das Board würde dann folgende Bytefolge gesendet werden: "0x03 0x01 0x04 0x06" 
Die übersetzte Antwort des Boards, welche über die Kommandozeile ausgegeben wird 
und im Script auch ausgewertet werden könnte sieht dann so aus: "252 1 0 253". 

Am Besten kann man sich mit der Funktion vertraut machen, indem man zunächst erst einmal mit 
dem Com-Terminal eines PC kommuniziert und den Comwrapper über Telnet mit den entsprechenden 
Parametern aufruft. 

Dieses ist eine erste Arbeitsversion des Wrappers. Wir würden uns freuen, Erfahrungsberichte und 
vor allem Vorschläge für zuätzliche Funktionalitäten von Euch zu bekommen. Die möglichen Kommu- 
nikationsprotokolle mit externen Geräten sind ja dermaßen vielgestaltig, daß man nich alle von 
vornherein berücksichtigen kann.

Gruß
____Paule

Leider ist davon der Sourcecode vom Comwrap nicht verfügbar. Ich denke mal, mgck möchte das schon selber schreiben. (zumindest würde ich das so machen)

Liontamer hat geschrieben:Leider ist davon der Sourcecode vom Comwrap nicht verfügbar. Ich denke mal, mgck möchte das schon selber schreiben. (zumindest würde ich das so machen)

Jo, aber für erste Tests sollte das reichen.

Beitrag von **mgck** » Sonntag 25. November 2007, 14:51

Im Moment macht mir der Comport weniger sorgen, das klappt über den vorhanden schon ganz gut.

gruß mgck

Beitrag von **mgck** » Sonntag 25. November 2007, 18:05

So ich habe schon mal ein kleinen Fortschritt gemacht der aber nur als Notlösung gilt, damit ich erstmal mit dem Display weiterkomme.

Den ChannelName hole ich mir mit: execlp("pzapit", "pzapit", "-gi", NULL);

Hier mal das ergebniss:

Code: Alles auswählen

/var/bin # ./display
#start#ChannelName=45300014460 (9Live)#end#
#start#Fortschritt=50#end#
#start#Uhrzeit=17:56#end#

Ich hoffe aber immer noch das mir jemand ein Codeschnipsel anbieten kann der mir zeigt wie ich an die Benötigten Daten komme. Denn der Fortschritt ist nur ein pseudo wert.

gruß mgck

Beitrag von **mgck** » Mittwoch 28. November 2007, 17:06

So die Grundfunktionen sind schon drinn.

gruß mgck

mgck hat geschrieben:So die Grundfunktionen sind schon drinn.

gruß mgck

Sieht genial aus! Hoffe es gibt da dann eine "Bauanleitung" von Dir...

Gruß
____Paule

Beitrag von **mgck** » Freitag 7. Dezember 2007, 18:24

Na das wird ja schon langsam.
Muß jetzt erstmal eine Platine zaubern und ein Gehäuse bauen.
Hier noch mal aktuelle Pictures.

gruß mgck

Beitrag von **mb405** » Freitag 7. Dezember 2007, 22:45

geil geil geil

ich haben will

hab zwar keine ahnung wie du das ansteuerst, aber die infoviewer.cpp ganz unten zeigt dir, wie du paar infos bekommst.

channelList->getActiveChannelNumber
channelList->getActiveChannelName
channelList->getActiveSatellitePosition
channelList->getActiveChannel_ChannelID

den epg bekommste so
channel->currentEvent.description
channel->nextEvent.description
channel->currentEvent.text
channel->nextEvent.text

da sollte aber nich mehr möglich sein

Beitrag von **mgck** » Samstag 8. Dezember 2007, 08:19

Ich habe mir in neutrino/src/driver eine C datei erstellt, über die ich die infos zum Comport jagen kann.
Diese habe ich dann in der lcdd.cpp eingebunden da hier ja auch die Funktionen zur Ansteuerung des Dbox2 Display drinn sind.

Wie oben geschrieben bin ich (noch) kein guter C Programmierer aber es Funktioniert. Ich poste hier mal den Code vielleicht hat ja einer der Profis einige verbesserungs Vorschläge.

Das Display habe ich von Pollin für 19,95â‚¬, hab noch keine günstigeren gefunden. Zuerst hatte ich das Blaue für 29,95â‚¬ habe es aber beim rumbastel geschrottet.

Wie man sieht hatte ich zuerst versucht den Speicher für die zu übergebenden daten mit malloc zu reservieren. Das funktionierte zwar in meiner ersten Version einer eigenständigen binary aber unter Neutrino kam dann immer '*** glibc detected *** malloc(): memory corruption: 0x101b1c28'

display.h

Code: Alles auswählen

#ifndef _display_h
#define _display_h


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

#include <unistd.h>
#include <fcntl.h>
#include <termios.h>

#define TERM_DEVICE "/dev/console"   /* = COM1 */
#define TERM_SPEED B9600      /* Bit/Sek */ 

extern void LCD_SendData (int mode, char *pt_data);
int SendData (char *buffer);

#endif

display.c

Code: Alles auswählen

#include "display.h"

void LCD_SendData (int mode, char *pt_data)
{
  //char *data = NULL;
  //data = (char *) malloc(sizeof(pt_data)+5);
    char data[128]="";

  switch(mode)
  {
     case 1:                        // ChannelName
      strcat(data,"#N=");
      strcat(data,pt_data);
      strcat(data,"*\n");
      SendData(data);
      //printf("debug: %s",data);
      break;

     case 2:
      strcat(data,"#F=");           // Fortschritt
      strcat(data,pt_data);
      strcat(data,"*\n");
      SendData(data);
      //printf("debug: %s",data);
      break;

     case 3:
      strcat(data,"#T=");           //Uhrzeit
      strcat(data,pt_data);
      strcat(data,"*\n");
      SendData(data);
      //printf("debug: %s",data);
      break;

     case 4:
      strcat(data,"#V=");           // Lautstaerke
      strcat(data,pt_data);
      strcat(data,"*\n");
      SendData(data);
      //printf("debug: %s",data);
      break;
  }
  //free(data);
}

int SendData (char *buffer)
 {
  int fd, old_flags;

  //char *data = NULL;
  //data = (char *) malloc(sizeof(buffer)+1);
  char data[128]="";
  strcpy(data,buffer);

  struct termios term_attr;

  if ((fd = open(TERM_DEVICE, O_RDWR)) == -1)
   {
    perror("terminal: Can't open device " TERM_DEVICE);
    //free(data);
    return(1);
   }
            /* RS232 konfigurieren */
  if (tcgetattr(fd, &term_attr) != 0)
   {
    perror("terminal: tcgetattr() failed");
    //free(data);
    return(1);
   }
  term_attr.c_cflag = TERM_SPEED | CS8 | CRTSCTS | CLOCAL;
  term_attr.c_iflag = 0;
  term_attr.c_oflag = OPOST | ONLCR;
  term_attr.c_lflag = 0;
  if (tcsetattr(fd, TCSAFLUSH, &term_attr) != 0)
    perror("terminal: tcsetattr() failed");

            /* Std.-Eingabe anpassen */
  if (tcgetattr(STDIN_FILENO, &term_attr) != 0)
   {
    perror("terminal: tcgetattr() failed");
    //free(data);
    return(1);
   }
            /* alte Einst. sichern */
  old_flags = term_attr.c_lflag;
  term_attr.c_lflag &= ~(ICANON | ECHO);
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &term_attr) != 0)
    perror("terminal: tcsetattr() failed");

  /*daten auf ttyS0 ausgeben*/
  write(fd,data,strlen(data)+1);

  /* Std.-Eingabe wie vorher */
  term_attr.c_lflag = old_flags;
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &term_attr) != 0)
    perror("terminal: tcsetattr() failed");

  //printf("Aborted.\n");
  close(fd);
  //free(data);
  return(0);
 }

Und hier die relevanten Teile der lcdd.cpp

Code: Alles auswählen

...
#include <dbox/fp.h>
#include <fcntl.h>
#include <sys/timeb.h>
#include <time.h>
#include <unistd.h>


extern "C" {
#include <driver/display.h>
}

#include <daemonc/remotecontrol.h>
extern CRemoteControl * g_RemoteControl; /* neutrino.cpp */

...
void CLCD::showServicename(const std::string & name) // UTF-8
{
        char* data = NULL;
        data = new char[name.size()+1];
        strcpy(data,name.c_str());
        LCD_SendData(1,data );
        //printf(" Debug:showServiceName: %s",data);
        delete [] data;
	
servicename = name;

	if (mode != MODE_TVRADIO)
		return;
	display.draw_fill_rect (0,14,120,48, CLCDDisplay::PIXEL_OFF);

	if (fonts.channelname->getRenderWidth(name.c_str(), true) > 120)
	{
		int pos;
		std::string text1 = name;
		do
		{
			pos = text1.find_last_of("[ .]+"); // <- characters are UTF-encoded!
			if (pos != -1)
                        {
			  text1 = text1.substr( 0, pos );
                        }
		} while ( ( pos != -1 ) && ( fonts.channelname->getRenderWidth(text1.c_str(), true) > 120 ) ); // UTF-8
		
		if ( fonts.channelname->getRenderWidth(text1.c_str(), true) <= 120 ) // UTF-8
                {
			fonts.channelname->RenderString(1,29+16, 130, name.substr(text1.length()+ 1).c_str(), CLCDDisplay::PIXEL_ON, 0, true); // UTF-8
                }
		else
		{
			std::string text1 = name;
                        while (fonts.channelname->getRenderWidth(text1.c_str(), true) > 120) // UTF-8
				text1= text1.substr(0, text1.length()- 1);
			
			fonts.channelname->RenderString(1,29+16, 130, name.substr(text1.length()).c_str(), CLCDDisplay::PIXEL_ON, 0, true); // UTF-8
		}
		
		fonts.channelname->RenderString(1,29, 130, text1.c_str(), CLCDDisplay::PIXEL_ON, 0, true); // UTF-8
	}
	else
	{
		fonts.channelname->RenderString(1,37, 130, name.c_str(), CLCDDisplay::PIXEL_ON, 0, true); // UTF-8 
	}
	
	wake_up();
	displayUpdate();
}

void CLCD::showTime()
{
	if (showclock)
	{
		char timestr[21];
		struct timeb tm;
		struct tm * t;

		ftime(&tm);
		t = localtime(&tm.time);
		
                if (mode == MODE_STANDBY)
		{
			display.draw_fill_rect(-1, -1, 120, 64, CLCDDisplay::PIXEL_OFF); // clear lcd

			ShowNewClock(&display, t->tm_hour, t->tm_min, t->tm_wday, t->tm_mday, t->tm_mon);
 			strftime((char*) &timestr, 20, "%H:%M", t);
                        LCD_SendData(1,timestr);
		}
		else
		{
			if (CNeutrinoApp::getInstance ()->recordingstatus && clearClock == 1)
			{
				strcpy(timestr,"  :  ");
				clearClock = 0;
			}
			else
			{
				strftime((char*) &timestr, 20, "%H:%M", t);
                                LCD_SendData(3,timestr);
				clearClock = 1;
			}

			display.draw_fill_rect (77, 50, 120, 64, CLCDDisplay::PIXEL_OFF);

			fonts.time->RenderString(122 - fonts.time->getRenderWidth(timestr), 62, 50, timestr, CLCDDisplay::PIXEL_ON);
		}
		displayUpdate();
	}
}

...

void CLCD::showVolume(const char vol, const bool perform_update)
{
        char lcd_vol[3]="";
	volume = vol;
	if (
	    ((mode == MODE_TVRADIO) && (g_settings.lcd_setting[SNeutrinoSettings::LCD_SHOW_VOLUME])) ||
	    (mode == MODE_SCART) ||
	    (mode == MODE_AUDIO)
	    )
	{
		display.draw_fill_rect (11,53,73,61, CLCDDisplay::PIXEL_OFF);
		//strichlin
		if (muted)
		{
			display.draw_line (12,55,72,59, CLCDDisplay::PIXEL_ON);
                        LCD_SendData(4,"255");
		}
		else
		{
			int dp = int( vol/100.0*61.0+12.0);

                        int i_vol = int(vol);
                        sprintf(lcd_vol, "%i", i_vol);
                        LCD_SendData(4,lcd_vol);

			display.draw_fill_rect (11,54,dp,60, CLCDDisplay::PIXEL_ON);
		}
		if(mode == MODE_AUDIO)
		{
			display.draw_fill_rect (-1, 51, 10, 62, CLCDDisplay::PIXEL_OFF);
			display.draw_rectangle ( 1, 55,  3, 58, CLCDDisplay::PIXEL_ON, CLCDDisplay::PIXEL_OFF);
			display.draw_line      ( 3, 55,  6, 52, CLCDDisplay::PIXEL_ON);
			display.draw_line      ( 3, 58,  6, 61, CLCDDisplay::PIXEL_ON);
			display.draw_line      ( 6, 54,  6, 59, CLCDDisplay::PIXEL_ON);
		}

		if (perform_update)
		  displayUpdate();
	}
	wake_up();
}

void CLCD::showPercentOver(const unsigned char perc, const bool perform_update)
{
        char lcd_perc[3]="";
	percentOver = perc;
	if (mode == MODE_TVRADIO)
	{
          //int i_perc = int(perc);
          //sprintf(lcd_perc, "%i", i_perc);
          //LCD_SendData(2,lcd_perc);
        if (g_settings.lcd_setting[SNeutrinoSettings::LCD_SHOW_VOLUME] == 0)
		{
			display.draw_fill_rect (11,53,73,61, CLCDDisplay::PIXEL_OFF);
			//strichlin
			if (perc==255)
			{
				display.draw_line (12,55,72,59, CLCDDisplay::PIXEL_ON);
                                LCD_SendData(2,"255");
			}
			else
			{
				int dp = int( perc/100.0*61.0+12.0);
				display.draw_fill_rect (11,54,dp,60, CLCDDisplay::PIXEL_ON);
                                int i_perc = int(perc);
                                sprintf(lcd_perc, "%i", i_perc);
                                LCD_SendData(2,lcd_perc);
			}
		}
		else if (g_settings.lcd_setting[SNeutrinoSettings::LCD_SHOW_VOLUME] == 2)
		{
			display.draw_fill_rect (11,2,117,8, CLCDDisplay::PIXEL_OFF);
			//strichlin
			if (perc==255)
			{
				display.draw_line (12,3,116,7, CLCDDisplay::PIXEL_ON);
                                LCD_SendData(2,"255");
			}
			else
			{
				int dp = int( perc/100.0*105.0+12.0);
				display.draw_fill_rect (11,2,dp,8, CLCDDisplay::PIXEL_ON);
                                int i_perc = int(perc);
                                sprintf(lcd_perc, "%i", i_perc);
                                LCD_SendData(2,lcd_perc);
			}
		}
		else if (g_settings.lcd_setting[SNeutrinoSettings::LCD_SHOW_VOLUME] == 3)
		{
			display.draw_fill_rect (11,2,97,8, CLCDDisplay::PIXEL_OFF);
			//strichlin
			if (perc==255)
			{
				display.draw_line (12,3,96,7, CLCDDisplay::PIXEL_ON);
                                LCD_SendData(2,"255");
			}
			else
			{
				int dp = int( perc/100.0*86.0+12.0);
				display.draw_fill_rect (11,2,dp,8, CLCDDisplay::PIXEL_ON);
                                int i_perc = int(perc);
                                sprintf(lcd_perc, "%i", i_perc);
                                LCD_SendData(2,lcd_perc);
			}

            const char * icon;
            
            if( g_RemoteControl != NULL )
            {
                uint count = g_RemoteControl->current_PIDs.APIDs.size();
                if ( ( g_RemoteControl->current_PIDs.PIDs.selected_apid < count ) &&
                     ( g_RemoteControl->current_PIDs.APIDs[g_RemoteControl->current_PIDs.PIDs.selected_apid].is_ac3 ) )
                    icon = DATADIR "/lcdd/icons/dd.raw";
                else
                    icon = DATADIR "/lcdd/icons/stereo.raw";

                display.paintIcon( icon, 101, 1, false );
            }
		}

		if (perform_update)
            displayUpdate();
	}
}

gruß mgck

Beitrag von **Houdini** » Samstag 8. Dezember 2007, 09:37

data = (char *) malloc(sizeof(pt_data)+5);

Damit allokierst du 9 Bytes!
ein size of pointer hat immer 4 bytes (32Bit System)
deswegen geht das in die Hose.

Beitrag von **mgck** » Samstag 8. Dezember 2007, 09:52

Sch... Pointer. Bis man das mal rafft, aber ich glaube ich habe es verstanden.

In meinem binary hatte ich nur einen pointer übergeben deshalb haute das auch hin.

So wie das aussieht habe ich jetzt versucht einem pointer noch zeichen zuzufügen. Das das nicht geht ist klar.

Danke