G15 on Linux

Just wanting to check that the problem is definitely resolved now?

I was having problems installing g15composer after patching (I'm new to patch as well as Linux in general, so it could be me), but I patched g15daemon, and so far so good! No odd movement!

One last thing,
You're amazing.

I commented everything except for the necessities and the M-keys and the problem persisted. I went back and commented out the M-key stuff and the screen isn't going wacko anymore. I would assume this means that g15composer is sending the M-key data followed by the screen data until the 6880 buffer is reached, and then putting the leftover screen data in the next buffer?

The clock plugin and my modified version of it don't do this. This thing is just when I'm running the Python script, which is why I believe the problem is in g15composer or g15render. I haven't counted the shift amount, but it definitely appears to be by a constant amount which I'm going to guess is 7 or 8. I'm running the g15amarok-daemon.pl script as you suggested, and so far I do not see the issue I'm experiencing with my Python script. I noticed the Perl script updates every 5 seconds compared to my script which updates every second.

Your forums aren't allowing .pbm files to be uploaded. :) But here you are.

[attachment=0]g15daemon-sc-0.gif[/attachment]

I had 1.9.4 installed (for g15daemon), and updated to 1.9.5.2.
I'm running Kubuntu 7.10 with libusb-0.1-4_0.1.12-7_amd64.deb as the package file for libusb.

After updating g15daemon, I still had no luck.

Sadly, yes.

You'll have to pardon anything...wrong style-wise as well as anything unnecessarily defined, but here's the code. I plan on changing the style to something that reacts to Amarok's messages as opposed to constantly polling it for the information. Obviously I've also added in the buffer control. Thanks for the hint. After testing that, the moving appeared to be less common, but it was still there.

# LCD is 160x43 resolution</p>
<p>#The following is a list of the max widths of the screen in characters.<br />
maxWidths = ( 40,<br />
	32,<br />
	26,<br />
	)</p>
<p>import thread<br />
import os<br />
import time<br />
import sys</p>
<p>import tempfile<br />
import random</p>
<p>from dcopext import DCOPClient , DCOPApp<br />
import signal<br />
def cleanup( signum , frame ):<br />
	#Change this to something a little more useful.<br />
	output( 'Script was terminated.' , 0 )<br />
	d.close()<br />
	amarok.script.removeCustomMenuItem( scriptName , actionName )<br />
signal.signal( signal.SIGTERM , cleanup )</p>
<p>def r( number , precision ):<br />
	number_string = repr( number )<br />
	decimal_pos = number_string.index( "." )<br />
	number_string_cut = fstr[ : decimal_pos + 1 + precision ]<br />
	return number_string_cut</p>
<p>def sec_parse( seconds ):<br />
	seconds_left = seconds % 60<br />
	minutes = ( seconds - seconds_left ) / 60<br />
	time_string = ""<br />
	if minutes < 10: time_string += "0"<br />
	time_string += repr( minutes ) + ":"<br />
	if seconds_left < 10: time_string += "0"<br />
	time_string += repr( seconds_left )<br />
	return time_string</p>
<p>def output( string , style = 0 ):<br />
	#This function is for debugging purposes.  If you want to communicate with another program, use a pipe or a socket<br />
	if style == 1:<br />
		try: f = open( "/tmp/AmarokG15_error_log.log" , 'a' ) # Temporary debugging log--remove/change during debug purge<br />
		except: pass<br />
		f.write( string +  "\n" )<br />
		f.close()<br />
	else:<br />
		print string</p>
<p>def stdin_handle():<br />
	for line in sys.stdin:<br />
		if line == "configure":<br />
			thread.start_new_thread( do_config , () )</p>
<p>		else:<br />
			f = open("/tmp/AmarokG15_std_log.log",'a')<br />
			f.write( line + '\n' )<br />
			f.close()</p>
<p>def do_config():<br />
	# Configuration screen<br />
	pass</p>
<p>def text_scroll( text , sz , i ):<br />
	if sz not in ( 0 , 1 , 2 ): output( "sz not in (0,1,2) in text_scroll_list( text, sz )" , 1 ); return 0</p>
<p>	w = maxWidths[ sz ]<br />
	if i + w >= len( text ):<br />
		# past the end, start from the beginning</p>
<p>		ani = text[i - len( text ):] + text[:i - len( text ) + w]<br />
	else:<br />
		#No need for looping around<br />
		ani = text[ i : i + w ]</p>
<p>	return ani</p>
<p>class Disp( object ):<br />
	def __init__( self ):<br />
		self.__temp_dir = tempfile.mkdtemp()<br />
		self.__pipe_location = self.__temp_dir + "/g15comp0"</p>
<p> 		os.mkfifo( self.__pipe_location )</p>
<p>		os.system( "g15composer \"%s\" &" % ( self.__pipe_location ) )</p>
<p>		self.__f = open( self.__pipe_location , 'w' )<br />
		self.pos_text( "\"Loading...\"" , 80 , 19 , 2 , 1 )<br />
		self.__load()</p>
<p>	def __load( self ):<br />
		# Clear the screen, set the M keys etc.<br />
		self.clear()</p>
<p>		self.m_conf = [ 0 , 0 , 0 ]<br />
		self.set_m( 0 , 0 )</p>
<p>	def close( self ):<br />
		self.set_m( 0 , 0 )</p>
<p>		self.clear()<br />
		self.__f.write( "SC\n" )<br />
		self.__f.flush()</p>
<p>		self.__f.close()</p>
<p>		os.system( "rm -Rd " + self.__temp_dir )</p>
<p>	#Add all of the various functions here.<br />
	def write_bufs( self ):<br />
		self.__f.write( "MC 0\n" )<br />
		self.__f.write( "MC 1\n" )<br />
	def show_text( self , text , sz ):<br />
		self.__f.write( "T" + ( "S" , "M" , "L" )[ sz ] + " " + text + "\n" )<br />
		self.__f.flush()<br />
	def pos_text( self , text , x , y , sz , align ):<br />
		self.__f.write( "TO %s %s %s %s %s\n" % ( x , y , sz , align , text) )<br />
		self.__f.flush()<br />
	def set_m( self , num , state ):<br />
		if num in ( 0 , 1 , 2 , 3 ):<br />
			self.__f.write( "KM " + repr( num ) + " " + repr( state ) + "\n" )<br />
			self.__f.flush()<br />
			if num == 0:<br />
				self.m_conf[ 0 ] = state<br />
				self.m_conf[ 1 ] = state<br />
				self.m_conf[ 2 ] = state<br />
			else:<br />
				self.m_conf[ num - 1 ] = state<br />
			return 0<br />
		else:<br />
			output( "num (" + repr( num ) + ") not in legal range [0-3]" , 1 )<br />
			return 1<br />
	def draw_prog_bar( self , ( x1 , y1 ) ,( x2 , y2 ) , perc ):<br />
		self.__f.write( "DB %s %s %s %s 1 %s 100 1\n" % ( x1 , y1 , x2 , y2 , int( perc ) ) )<br />
		self.__f.flush()<br />
	def clear( self ):<br />
		self.__f.write( "PC 0\n" )</p>
<p>def main():<br />
	thread.start_new_thread( stdin_handle , () )</p>
<p>	global d<br />
	d = Disp()</p>
<p>	# aniIDict is the dictionary with a list of counters that update at the end of a loop.  Everything starts at 0.<br />
	#	You only need stuff here if your max (see aniMaxDict) is greater than 0, in which case you NEED to put things here for proper scrolling.<br />
	aniIDict = { "artist-title" : 0 ,<br />
	}<br />
	# aniMaxDict is the dictionary with a list of maxes for the counters in aniIDict.<br />
	#	the max is the len(str) - maxWidths[char_size] or 0, whichever is greater.  You don't need this if your max is 0 or less.<br />
	#	Also, don't be afraid to set these dynamically.<br />
	aniMaxDict = { "artist-title" : 1 ,<br />
	}</p>
<p>#<br />
#---Here starts where stuff can be removed for a template------------------------------------------------------------------------------------------------------<br />
#</p>
<p>	#Get the DCOP stuff started.<br />
	client = DCOPClient()<br />
	client.attach()</p>
<p>	amarok = DCOPApp( 'amarok' , client )</p>
<p>#<br />
#---Here ends where stuff can be removed for a template--------------------------------------------------------------------------------------------------------<br />
#</p>
<p>	while 1:<br />
		# This is the primary loop.<br />
		d.clear()</p>
<p>		#<br />
		#It would definitely be less CPU intensive to use a reactive style, as opposed to an always-reading style<br />
		#</p>
<p>		#This section gets a percentage of the song that has been played and displays it on the LCD.<br />
		ok1 , timeSoFar = amarok.player.trackCurrentTime()<br />
		ok2 , timeTotal = amarok.player.trackTotalTime()</p>
<p>		timeSoFar , timeTotal = float( timeSoFar ) , float( timeTotal )</p>
<p>		if not ( ok1 and ok2 ):<br />
			output( "Error getting track times" , 1 )<br />
			perc = 0<br />
			timeSoFar = 0<br />
			timeTotal = 0<br />
		else:<br />
			try: perc = timeSoFar / timeTotal * 100<br />
			except( ZeroDivisionError ): perc = 0<br />
			if perc > 100:<br />
				perc = 100.0<br />
		d.pos_text( "\"%s\"" % ( sec_parse( int( timeSoFar ) ) , ) , 0 , 37 , 0 , 0 )<br />
		d.draw_prog_bar( ( 20 , 39 ) , ( 134 , 39 ) , perc )<br />
		d.pos_text( "\"-%s\"" % ( sec_parse( int( timeTotal - timeSoFar ) ) , ) , 136 , 37 , 0 , 0 )</p>
<p>		#This section gets the artist and title of the current song and displays them on the LCD<br />
		ok1,title = amarok.player.title()<br />
		ok2,artist = amarok.player.artist()</p>
<p>		if not ok1:<br />
			output( "Error getting track title" , 1 )<br />
			title = ""<br />
		if not ok2:<br />
			output( "Error getting track artist" , 1 )<br />
			artist = ""<br />
		artist_title = "%s - %s" % ( artist.title() , title.title() )<br />
		if artist_title == " - ": artist_title = " - "<br />
		if len( artist_title ) > maxWidths[ 1 ]:<br />
			#animate<br />
			artist_title += " - " #So the looping looks good<br />
			aniMaxDict[ "artist-title" ] = len( artist_title )<br />
			artist_title_string = text_scroll( artist_title , 1 , aniIDict[ "artist-title" ] )<br />
		else:<br />
			artist_title_string = artist_title<br />
			aniMaxDict[ "artist-title" ] = 1<br />
		d.pos_text( "\"%s\"" % ( artist_title_string , ) , 80 , 26 , 1 , 1 )</p>
<p>        	# Update the dictionaries used for text scrolling (and other animations, eventually)<br />
        	for x in aniIDict.keys():<br />
				aniIDict[ x ]  = ( aniIDict[ x ] + 1 ) % ( aniMaxDict[ x ] )</p>
<p>		d.write_bufs()<br />
		time.sleep( 1 )</p>
<p>	#Closing up.<br />
	d.close()</p>
<p>if __name__ == "__main__":<br />
	try:<br />
		main()<br />
	except( KeyboardInterrupt ):<br />
		try: d.close() #Shut display down if it's up.<br />
		except: pass<br />
	except(), e:<br />
		try: d.close()<br />
		except: pass<br />
		output( "Something uncaught happened!\n" + e , 1 )<br />

Edit: I've decided to take advantage of the L-buttons for controlling Amarok, and because I can't do that with a Python script (I didn't explore the area too far, however), I've decided to modify the clock plugin to suit my needs. Since this (the text arbitrarily moving) is still an issue, I've kept my old Python script and will continue to check this thread for updates.

No reproducable methods other than just giving you my Python code and having you wait for it to happen, but I'm guessing you can do that yourself already. If you want my source code, I'll be glad to upload. I just checked after you mentioned the high system load, and I'm experiencing the change-age with a processor usage of about .8%. Top could just be reporting the processor usage as I have my script sleep (using time.sleep()), and there could be a large usage percentage in the short bursts that g15render goes in as it renders my stuff. I will try flushing the write buffers after I have all my output ready so that g15composer, etc. can all work at one time, as opposed to having g15composer start new g15renders after each flush. If it's a synchronization issue, that should help, right?