Changeset 1101

Timestamp:

03/23/11 04:41:29 (2 years ago)

Author:

reyalP

Message:

ptp script communication improvements, see ​http://chdk.setepontos.com/index.php?topic=4338.msg62725#msg62725
NOTE PTP protocol is updated, old clients will not be completely compatible

Location:

trunk

Files:

• . (modified) (1 prop)
• core/action_stack.c (modified) (3 diffs)
• core/action_stack.h (modified) (2 diffs)
• core/luascript.c (modified) (5 diffs)
• core/luascript.h (modified) (2 diffs)
• core/ptp.c (modified) (11 diffs)
• core/ptp.h (modified) (3 diffs)
• core/script.c (modified) (5 diffs)
• include/platform.h (modified) (1 diff)
• include/script.h (modified) (2 diffs)

trunk/core/action_stack.c

@@ -169 +169 @@
 }
 
+// handle initializing and checking a timeout value on the stack
+// p is the how far up the stack the timout value is
+// returns zero if the timeout has not expired, 1 if it has
+// does not pop the delay value off the stack or clear the delay value
+int action_process_delay(int p)
+{
+    int t = get_tick_count();
+    // FIXME take care if overflow occurs
+    if (action_stacks[active_stack]->delay_target_ticks == 0)
+    {
+        /* setup timer */
+        action_stacks[active_stack]->delay_target_ticks = t+action_get_prev(p);
+        return 0;
+    }
+    if (action_stacks[active_stack]->delay_target_ticks <= t)
+    {
+        return 1;
+    }
+    return 0;
+}
+
+void action_clear_delay(void)
+{
+    action_stacks[active_stack]->delay_target_ticks = 0;
+}
+
 // Defines some standard operations. Returns false if it could not process anything.
 // Can only be called from an action stack
@@ -188 +214 @@
         break;
     case AS_SLEEP:
-        t = get_tick_count();
-        // FIXME take care if overflow occurs
-        if (action_stacks[active_stack]->delay_target_ticks == 0)
-        {
-            /* setup timer */
-            action_stacks[active_stack]->delay_target_ticks = t+action_get_prev(2);
-        }
-        else
-        {
-            if (action_stacks[active_stack]->delay_target_ticks <= t)
-            {
-                action_stacks[active_stack]->delay_target_ticks = 0;
-
-                // pop sleep op.
-                action_pop();
-                action_pop();
-            }
+        if(action_process_delay(2))
+        {
+            action_clear_delay();
+            action_pop();
+            action_pop();
         }
         break;
@@ -239 +253 @@
         break;
     case AS_WAIT_CLICK:
-        t = get_tick_count();
-        if (action_stacks[active_stack]->delay_target_ticks == 0)
-        {
-            /* setup timer */
-            action_stacks[active_stack]->delay_target_ticks = t+((action_get_prev(2))?action_get_prev(2):86400000);
-        }
-        else
-        {
-            kbd_last_clicked = kbd_get_clicked_key();
-            if (kbd_last_clicked || (action_stacks[active_stack]->delay_target_ticks <= t))
-            {
-                if (!kbd_last_clicked) 
-                    kbd_last_clicked=0xFFFF;
-            
-                action_stacks[active_stack]->delay_target_ticks = 0;
-
-                // pop up
-                action_pop();
-                action_pop();
-            }
+        if(action_process_delay(2) || (kbd_last_clicked = kbd_get_clicked_key()))
+        {
+            if (!kbd_last_clicked) 
+                kbd_last_clicked=0xFFFF;
+            action_clear_delay();
+            action_pop();
+            action_pop();
         }
         break;

trunk/core/action_stack.h

@@ -19 +19 @@
     AS_WAIT_CLICK,
     AS_SCRIPT_RUN,
-    AS_MOTION_DETECTOR
+    AS_MOTION_DETECTOR,
+    AS_SCRIPT_READ_USB_MSG, // params: timeout
+    AS_SCRIPT_WRITE_USB_MSG, // params: timeout, msg
 };
 
@@ -32 +34 @@
 void action_wait_for_click(int timeout);
 void action_pop();
+int action_process_delay(int p);
+void action_clear_delay(void);
 long action_get_prev(int p);
 int action_stack_standard(long p);

trunk/core/luascript.c

@@ -15 +15 @@
 #include "action_stack.h"
 #include "motion_detector.h"
+#include "ptp.h"
 
 #include "../lib/lua/lstate.h"  // for L->nCcalls, baseCcalls
@@ -20 +21 @@
 lua_State* L;
 lua_State* Lt;
-int lua_keep_result;
-
-void *lua_consume_result()
-{
-  lua_State* r = L;
+
+static int lua_script_is_ptp;
+
+static int yield_hook_enabled;
+
+static void lua_script_disable_yield_hook(void) {
+    yield_hook_enabled = 0;
+}
+static void lua_script_enable_yield_hook(void) {
+    yield_hook_enabled = 1;
+}
+
+#ifdef CAM_CHDK_PTP
+// create a ptp message from the given stack index
+// incompatible types will return a TYPE_UNSUPPORTED message
+static ptp_script_msg *lua_create_usb_msg( lua_State* L, int index, unsigned msgtype) {
+    // TODO maybe we should just pass the lua type constants
+    unsigned datatype, datasize = 4;
+    int ivalue = 0;
+    void *data = &ivalue;
+    int ltype = lua_type(L,index);
+    switch(ltype) {
+        case LUA_TNONE:
+            return NULL; // nothing on the stack, no message generated
+        break;
+        case LUA_TNIL:
+            datatype = PTP_CHDK_TYPE_NIL;
+        break;
+        case LUA_TBOOLEAN:
+            datatype = PTP_CHDK_TYPE_BOOLEAN;
+            ivalue = lua_toboolean(L,index);
+        break;
+        case LUA_TNUMBER:
+            datatype = PTP_CHDK_TYPE_INTEGER;
+            ivalue = lua_tonumber(L,index);
+        break;
+        case LUA_TSTRING:
+            datatype = PTP_CHDK_TYPE_STRING;
+            data = (char *)lua_tolstring(L,index,&datasize);
+        break;
+        // TODO this converts to a string and returns as STRING, format as described at 
+        // http://chdk.setepontos.com/index.php?topic=4338.msg62606#msg62606
+        // for compatibility with current PTPCAM/PTPCAMGUI implementation
+        // later we should switch to a proper serialized table with it's own return type
+        case LUA_TTABLE: 
+            lua_script_disable_yield_hook(); // don't want to yeild while converting
+            lua_getglobal(L, "usb_msg_table_to_string"); // push function
+            lua_pushvalue(L, index); // copy specified index to top of stack
+            lua_pcall(L,1,1,0); // this will leave an error message as a string on the stack if call fails
+            lua_script_enable_yield_hook();
+            // an empty table will be returned as an empty string
+            // a non-string should never show up here
+            if ( !(lua_isstring(L,-1) /*&& ( lua_objlen(L,-1) > 0 )*/)) { 
+                return NULL;
+            }
+            datatype = PTP_CHDK_TYPE_STRING;
+            data = (char *)lua_tolstring(L,-1,&datasize);
+            lua_pop(L,1);
+        break;
+        default:
+            datatype = PTP_CHDK_TYPE_UNSUPPORTED;
+            data = (char *)lua_typename(L,ltype); // return type name as message data
+            datasize = strlen(data);
+    }
+    return ptp_script_create_msg(msgtype,datatype,datasize,data);
+}
+
+void lua_script_error_ptp(int runtime, const char *err) {
+    if(runtime) {
+        ptp_script_write_error_msg(PTP_CHDK_S_ERRTYPE_RUN, err);
+        script_end();
+    } else {
+        ptp_script_write_error_msg(PTP_CHDK_S_ERRTYPE_COMPILE, err);
+        lua_script_reset();
+    }
+}
+#endif
+
+void lua_script_reset()
+{
+  lua_close( L );
   L = 0;
-  return r;
-}
-
-void lua_script_reset()
-{
-  if ( !lua_keep_result )
-  {
-    lua_close( L );
-    L = 0;
-  }
-  Lt = 0;
 }
 
 static void lua_count_hook(lua_State *L, lua_Debug *ar)
 {
-  if( L->nCcalls <= L->baseCcalls )
+  if( L->nCcalls <= L->baseCcalls && yield_hook_enabled )
     lua_yield( L, 0 );
 }
 
-int lua_script_start( char const* script )
-{
-  lua_keep_result = 0;
+void lua_script_error(lua_State *Lt,int runtime)
+{
+    const char *err = lua_tostring( Lt, -1 );
+    script_console_add_line( err );
+    if(lua_script_is_ptp) {
+#ifdef CAM_CHDK_PTP
+        lua_script_error_ptp(runtime,err);
+#endif
+    } else {
+        if(runtime) {
+            if(conf.debug_lua_restart_on_error) {
+                lua_script_reset();
+                script_start_gui(0);
+            } else {
+                script_wait_and_end();
+            }
+        } else {
+            script_print_screen_end();
+            script_wait_and_end();
+        }
+    }
+}
+
+
+// TODO more stuff from script.c should be moved here
+void lua_script_finish(lua_State *L) 
+{
+#ifdef CAM_CHDK_PTP
+    if(lua_script_is_ptp) {
+        // send all return values as RET messages
+        int i,end = lua_gettop(L);
+        for(i=1;i<=end; i++) {
+            // if the queue is full return values will be silently discarded
+            // incompatible types will be returned as TYPE_UNSUPPORTED to preserve expected number and order of return values
+            ptp_script_write_msg(lua_create_usb_msg(L,i,PTP_CHDK_S_MSGTYPE_RET)); 
+        }
+    }
+#endif
+}
+
+int lua_script_start( char const* script, int ptp )
+{
+  lua_script_is_ptp = ptp;
   L = lua_open();
   luaL_openlibs( L );
@@ -55 +161 @@
   lua_setfield( L, LUA_REGISTRYINDEX, "Lt" );
   if( luaL_loadstring( Lt, script ) != 0 ) {
-    script_console_add_line( lua_tostring( Lt, -1 ) );
-    lua_script_reset();
+    lua_script_error(Lt,0);
     return 0;
   }
   lua_sethook(Lt, lua_count_hook, LUA_MASKCOUNT, 1000 );
+  lua_script_enable_yield_hook();
   return 1;
 }
@@ -1387 +1493 @@
         return 1;
 }
+
+#ifdef CAM_CHDK_PTP
+/*
+msg = read_usb_msg([timeout])
+read a message from the CHDK ptp interface.
+Returns the next available message as a string, or nil if no messages are available
+If timeout is given and not zero, wait until a message is available or timeout expires
+*/
+static int luaCB_read_usb_msg( lua_State* L )
+{
+  int timeout = luaL_optnumber( L, 1, 0 );
+  if(timeout) {
+    action_push(timeout);
+    action_push(AS_SCRIPT_READ_USB_MSG);
+    return lua_yield( L, 0 );
+  }
+  ptp_script_msg *msg = ptp_script_read_msg();
+  if(msg) {
+    lua_pushlstring(L,msg->data,msg->size);
+    return 1;
+  }
+  lua_pushnil(L);
+  return 1;
+}
+
+/*
+status = write_usb_msg(msg,[timeout])
+writes a message to the CHDK ptp interface
+msg may be nil, boolean, number, string or table (table has some restrictions, will be converted to string)
+returns true if the message was queued successfully, otherwise false
+if timeout is set and not zero, wait until message is written or timeout expires
+NOTE strings will not include a terminating NULL, must be handled by recipient
+*/
+static int luaCB_write_usb_msg( lua_State* L )
+{
+  ptp_script_msg *msg;
+  int timeout = luaL_optnumber( L, 2, 0 );
+  // TODO would it be better to either ignore this or return nil ?
+  // a write_usb_msg(function_which_returns_no_value()) is an error in this case
+  // replacing with nil might be more luaish
+  if(lua_gettop(L) < 1) {
+    return luaL_error(L,"missing argument");
+  }
+  msg=lua_create_usb_msg(L,1,PTP_CHDK_S_MSGTYPE_USER);
+  // for user messages, trying to create a message from an incompatible type throws an error
+  if(msg->subtype == PTP_CHDK_TYPE_UNSUPPORTED) {
+    free(msg);
+    return luaL_error(L,"unsupported type");
+  }
+  if(!msg) {
+    return luaL_error(L,"failed to create message");
+  }
+  if(timeout) {
+    action_push(timeout);
+    action_push((int)msg);
+    action_push(AS_SCRIPT_WRITE_USB_MSG);
+    return lua_yield( L, 0 );
+  }
+  lua_pushboolean(L,ptp_script_write_msg(msg)); 
+  return 1;
+}
+#endif
 
 void register_lua_funcs( lua_State* L )
@@ -1554 +1722 @@
 #endif
    FUNC(reboot);
-}
+#ifdef CAM_CHDK_PTP
+   FUNC(read_usb_msg);
+   FUNC(write_usb_msg);
+   luaL_dostring(L,"function usb_msg_table_to_string(t)"
+                    " local v2s=function(v)"
+                        " local t=type(v)"
+                        " if t=='string' then return v end"
+                        " if t=='number' or t=='boolean' or t=='nil' then return tostring(v) end"
+                        " return '' end"
+                    " local r=''"
+                    " for k,v in pairs(t) do"
+                        " local s,vs=''"
+                        " if type(v)=='table' then"
+                            " for i=1,table.maxn(v) do"
+                            " s=s..'\\t'..v2s(v[i]) end"
+                        " else"
+                            " vs=v2s(v)"
+                            " if #vs then s=s..'\\t'..vs end"
+                        " end"
+                        " vs=v2s(k)"
+                        " if #vs>0 and #s>0 then r=r..vs..s..'\\n' end"
+                    " end"
+                    " return r"
+                   " end");
+
+#endif
+}

trunk/core/luascript.h

@@ -4 +4 @@
 #include "lua.h"
 
-void *lua_consume_result();
 void lua_script_reset();
-int lua_script_start( char const* script );
+int lua_script_start( char const* script,int is_ptp );
+void lua_script_error( lua_State* L,int runtime );
+void lua_script_finish( lua_State* L );
 extern void register_lua_funcs( lua_State* L );
 // run the "restore" function at the end of a script
@@ -13 +14 @@
 extern lua_State* L;
 extern lua_State* Lt;
-extern int lua_keep_result;
 
 #endif

trunk/core/ptp.c

@@ -14 +14 @@
 #include "script.h"
 #include "action_stack.h"
-
-static lua_State *get_lua_thread(lua_State *L)
-{
-  lua_State *Lt;
-
-  lua_getfield(L,LUA_REGISTRYINDEX,"Lt");
-  Lt = lua_tothread(L,-1);
-  lua_pop(L,1);
-
-  return Lt;
-}
+// process id for scripts, increments before each attempt to run script
+// does not handle wraparound
+static unsigned script_run_id; 
 #endif
 
@@ -64 +56 @@
 
   return 1;
+}
+
+// camera will shut down if you ignore a recv data phase
+static void flush_recv_ptp_data(ptp_data *data,int size) {
+  char *buf;
+  buf = malloc((size > buf_size) ? buf_size:size);
+  if(!buf) // buf_size should always be less then available memory
+    return;
+  while ( size > 0 )
+  {
+    if ( size >= buf_size )
+    {
+      recv_ptp_data(data,buf,buf_size);
+      size -= buf_size;
+    } else {
+      recv_ptp_data(data,buf,size);
+      size = 0;
+    }
+  }
+  free(buf);
 }
 
@@ -94 +106 @@
 }
 
+#ifdef OPT_LUA
+// TODO this could be a generic ring buffer of words
+#define PTP_SCRIPT_MSG_Q_LEN 16
+typedef struct {
+  unsigned r; // index of current read value
+  unsigned w; // index of next write value, if w == r, empty TODO "full" currently wastes a slot
+  ptp_script_msg *q[PTP_SCRIPT_MSG_Q_LEN];
+} ptp_script_msg_q;
+
+// TODO it would be better to allocate these only when needed
+ptp_script_msg_q msg_q_in; // messages to pc from script
+ptp_script_msg_q msg_q_out; // messages to script from pc
+
+unsigned script_msg_q_next(unsigned i) {
+  if(i == PTP_SCRIPT_MSG_Q_LEN - 1) {
+    return 0;
+  }
+  return i+1;
+}
+
+unsigned script_msg_q_full(ptp_script_msg_q *q) {
+  return (script_msg_q_next(q->w) == q->r);
+}
+
+unsigned script_msg_q_empty(ptp_script_msg_q *q) {
+  return (q->w == q->r);
+}
+
+int enqueue_script_msg(ptp_script_msg_q *q,ptp_script_msg *msg) {
+  unsigned w = script_msg_q_next(q->w);
+  if(w == q->r) {
+    return 0;
+  }
+  // zero size messages don't make any sense
+  if(msg == NULL || msg->size == 0) {
+    return 0;
+  }
+  q->q[q->w] = msg;
+  q->w = w;
+  return 1;
+}
+
+ptp_script_msg* dequeue_script_msg(ptp_script_msg_q *q) {
+  ptp_script_msg *msg;
+  if(script_msg_q_empty(q)) {
+    return NULL;
+  }
+  msg = q->q[q->r];
+  q->r = script_msg_q_next(q->r);
+  return msg;
+}
+
+// public interface for script
+ptp_script_msg* ptp_script_create_msg(unsigned type, unsigned subtype, unsigned datasize, const void *data) {
+  ptp_script_msg *msg;
+  if(!datasize) {
+    return NULL;
+  }
+  msg = malloc(sizeof(ptp_script_msg) + datasize);
+  msg->size = datasize;
+  msg->type = type;
+  msg->subtype = subtype;
+  // caller may fill in data themselves
+  if(data) {
+      memcpy(msg->data,data,msg->size);
+  }
+  return msg;
+}
+
+int ptp_script_write_msg(ptp_script_msg *msg) {
+  msg->script_id = script_run_id;
+  return enqueue_script_msg(&msg_q_out,msg);
+}
+
+ptp_script_msg* ptp_script_read_msg(void) {
+  ptp_script_msg *msg;
+  while(1) {
+    msg = dequeue_script_msg(&msg_q_in); 
+    // no messages
+    if(!msg) {
+        return NULL;
+    }
+    // does message belong to our script
+    if(!msg->script_id || msg->script_id == script_run_id) {
+      return msg;
+    } else {
+    // no: discard and keep looking
+      free(msg);
+    }
+  }
+}
+int ptp_script_write_error_msg(unsigned errtype, const char *err) {
+  if(script_msg_q_full(&msg_q_out)) {
+    return 0;
+  }
+  ptp_script_msg *msg = ptp_script_create_msg(PTP_CHDK_S_MSGTYPE_ERR,errtype,strlen(err),err);
+  if(!msg) {
+    return 0;
+  }
+  return ptp_script_write_msg(msg);
+}
+
+#endif
+
 static int handle_ptp(
                int h, ptp_data *data, int opcode, int sess_id, int trans_id,
@@ -100 +216 @@
   static union {
     char *str;
-#ifdef OPT_LUA
-    lua_State *lua_state;
-#endif
   } temp_data;
   static int temp_data_kind = 0; // 0: nothing, 1: ascii string, 2: lua object
@@ -115 +228 @@
   ptp.num_param = 0;
   
+  // TODO calling this on every PTP command is not good,
+  // since it figures out free memory by repeatedly malloc'ing!
   buf_size=core_get_free_memory()>>1;
 
@@ -139 +254 @@
 #ifdef OPT_SCRIPTING
       ptp.param1 |= script_is_running()?PTP_CHDK_SCRIPT_STATUS_RUN:0;
+#ifdef OPT_LUA
+      ptp.param1 |= (!script_msg_q_empty(&msg_q_out))?PTP_CHDK_SCRIPT_STATUS_MSG:0;
+#endif
 #endif
       break;
@@ -210 +328 @@
           l = temp_data_extra;
         }
-#ifdef OPT_LUA
-        else { // temp_data_kind == 2
-          s = lua_tolstring(get_lua_thread(temp_data.lua_state),1,&l);
-        }
-#endif
 
         if ( !send_ptp_data(data,s,l) )
@@ -227 +340 @@
           free(temp_data.str);
         }
-#ifdef OPT_LUA
-        else if ( temp_data_kind == 2 )
-        {
-          lua_close(temp_data.lua_state);
-        }
-#endif
         temp_data_kind = 0;
 
@@ -257 +364 @@
           free(temp_data.str);
         }
-#ifdef OPT_LUA
-        else if ( temp_data_kind == 2 )
-        {
-          lua_close(temp_data.lua_state);
-        }
-#endif
         temp_data_kind = 0;
       }
@@ -392 +493 @@
 
 #ifdef OPT_LUA
+    // TODO this should flush data even if scripting isn't supported
     case PTP_CHDK_ExecuteScript:
       {
         int s;
         char *buf;
+
+        script_run_id++;
+        ptp.num_param = 2;
+        ptp.param1 = script_run_id;
 
         if ( param2 != PTP_CHDK_SL_LUA )
@@ -414 +520 @@
         recv_ptp_data(data,buf,s);
 
-        long script_action_stack = script_start_ptp(buf, param3&PTP_CHDK_ES_RESULT);
+        // error details will be passed in a message
+        if (script_start_ptp(buf) < 0) {
+          ptp.param2 = PTP_CHDK_S_ERRTYPE_COMPILE;
+        } else {
+          ptp.param2 = PTP_CHDK_S_ERRTYPE_NONE;
+        }
 
         free(buf);
         
-        if (script_action_stack < 0)
-        {
-          ptp.code = PTP_RC_InvalidParameter;
-          break;
-        }
-        else
-        {
-
-          if ( param3 & PTP_CHDK_ES_WAIT )
-          {
-
-            while ( script_is_running() )
-              msleep(100);
-
-            if ( param3 & PTP_CHDK_ES_RESULT )
-            {
-              lua_State *Lt;
-              temp_data.lua_state = lua_consume_result();
-              Lt = get_lua_thread(temp_data.lua_state);
-              temp_data_kind = 2;
-              if ( lua_gettop(Lt) == 0 )
-              {
-                temp_data_extra = PTP_CHDK_TYPE_NOTHING;
-              } else if ( lua_isnil(Lt,1) )
-              {
-                temp_data_extra = PTP_CHDK_TYPE_NIL;
-              } else if ( lua_isboolean(Lt,1) )
-              {
-                temp_data_extra = PTP_CHDK_TYPE_BOOLEAN;
-              } else if ( lua_isnumber(Lt,1) )
-              {
-                temp_data_extra = PTP_CHDK_TYPE_INTEGER;
-              } else if ( lua_isstring(Lt,1) )
-              {
-                temp_data_extra = PTP_CHDK_TYPE_STRING;
-              } else if ( lua_istable(Lt,1) )
-              {
-                temp_data_extra = PTP_CHDK_TYPE_NOTHING;
-                int i;
-                int count = 0;
-                lua_pushstring(Lt,"");
-                lua_pushnil(Lt);
-                while (lua_next(Lt,1) )
-                {
-                  lua_pushvalue(Lt,-2);
-                  lua_insert(Lt,-4);
-                  if ( lua_istable(Lt,-1) && (lua_objlen(Lt,-1) > 0) )
-                  {
-                    lua_pushstring(Lt,"");
-                    for ( i = 1; i <= lua_objlen(Lt,-2); i++ )
-                    {
-                      lua_rawgeti(Lt,-2,i);
-                      if ( lua_isnil(Lt,-1) )
-                      {
-                        lua_pushstring(Lt,"nil");
-                        lua_remove(Lt,-2);
-                      }
-                      if ( lua_isboolean(Lt,-1) )
-                      {
-                        lua_pushstring(Lt,lua_toboolean(Lt,-1)?"true":"false");
-                        lua_remove(Lt,-2);
-                      }
-                      if ( !lua_isstring(Lt,-1) )
-                      {
-                        lua_pop(Lt,1);
-                        lua_pushstring(Lt,"");
-                      }
-                      if ( lua_objlen(Lt,-2) > 0 )
-                      {
-                        lua_pushlstring(Lt,"\t",1);
-                        lua_insert(Lt,-2);
-                        lua_concat(Lt,3);
-                      }
-                      else lua_concat(Lt,2);
-                    }
-                    lua_remove(Lt,-2);
-                  }
-                  if ( lua_isboolean(Lt,-1) )
-                  {
-                    lua_pushstring(Lt,lua_toboolean(Lt,-1)?"true":"false");
-                    lua_remove(Lt,-2);
-                  }
-                  if ( lua_isstring(Lt,-1) )
-                  {
-                    lua_pushlstring(Lt,"\t",1);
-                    lua_insert(Lt,-2);
-                    if ( lua_objlen(Lt,-4) > 0 )
-                    {
-                      lua_pushlstring(Lt,"\n",1);
-                      lua_insert(Lt,-4);
-                      lua_concat(Lt, 5);
-                    }
-                    else lua_concat(Lt, 4);
-                  }
-                  else lua_pop(Lt,2);
-                  lua_insert(Lt,-2);
-                  lua_pushvalue(Lt,-1);  //set entry to nil for save memory
-                  lua_pushnil(Lt);
-                  lua_settable(Lt,1);
-                }
-                if ( lua_gettop(Lt) == 2 ) lua_remove(Lt,1);
-                if ( lua_isstring(Lt,1) && ( lua_objlen(Lt,1) > 0 )) temp_data_extra = PTP_CHDK_TYPE_STRING;
-              } else {
-                temp_data_extra = PTP_CHDK_TYPE_NOTHING;
-              }
-              ptp.num_param = 1;
-              ptp.param1 = temp_data_extra;
-              if ( temp_data_extra != PTP_CHDK_TYPE_STRING )
-              {
-                if ( temp_data_extra == PTP_CHDK_TYPE_BOOLEAN )
-                {
-                  ptp.num_param = 2;
-                  ptp.param2 = lua_toboolean(Lt,1);
-                } if ( temp_data_extra == PTP_CHDK_TYPE_INTEGER )
-                {
-                  ptp.num_param = 2;
-                  ptp.param2 = lua_tonumber(Lt,1);
-                }
-                lua_close(Lt);
-                temp_data_kind = 0;
-              } else {
-                ptp.num_param = 2;
-                ptp.param2 = lua_objlen(Lt,1);
-              }
-            }
-          }
-        }
-
-        break;
-      }
+        break;
+      }
+    case PTP_CHDK_ReadScriptMsg:
+    {
+      ptp_script_msg *msg = dequeue_script_msg(&msg_q_out);
+      ptp.num_param = 4;
+      if(!msg) {
+        // return a fully formed message for easier handling
+        ptp.param1 = PTP_CHDK_S_MSGTYPE_NONE;
+        ptp.param2 = 0;
+        ptp.param3 = 0;
+        ptp.param4 = 4;
+        // looks like we need to send some data no matter what
+        if ( !send_ptp_data(data,"\0\0\0",4) )
+        {
+          ptp.code = PTP_RC_GeneralError;
+        }
+        break;
+      }
+      ptp.param1 = msg->type;
+      ptp.param2 = msg->subtype;
+      ptp.param3 = msg->script_id;
+      ptp.param4 = msg->size;
+
+      // NOTE message is lost if sending failed
+      if ( !send_ptp_data(data,msg->data,msg->size) )
+      {
+        ptp.code = PTP_RC_GeneralError;
+      }
+      free(msg);
+      break;
+    }
+    case PTP_CHDK_WriteScriptMsg:
+    {
+      int msg_size;
+      ptp_script_msg *msg;
+      ptp.num_param = 1;
+      ptp.param1 = PTP_CHDK_S_MSGSTATUS_OK;
+      if (!script_is_running()) {
+        ptp.param1 = PTP_CHDK_S_MSGSTATUS_NOTRUN;
+      } else if(param2 && param2 != script_run_id) {// check if target script for message is running
+        ptp.param1 = PTP_CHDK_S_MSGSTATUS_BADID;
+      } else if(script_msg_q_full(&msg_q_in)) {
+        ptp.param1 = PTP_CHDK_S_MSGSTATUS_QFULL;
+      }
+
+      msg_size = data->get_data_size(data->handle);
+
+      // if something was wrong, don't bother creating message, just flush
+      if(ptp.param1 != PTP_CHDK_S_MSGSTATUS_OK) {
+        flush_recv_ptp_data(data,msg_size);
+        break;
+      }
+      msg = ptp_script_create_msg(PTP_CHDK_S_MSGTYPE_USER,PTP_CHDK_TYPE_STRING,msg_size,NULL);
+      if ( !msg ) // malloc error or zero size
+      {
+        // if size is zero, things will get hosed no matter what
+        flush_recv_ptp_data(data,msg_size);
+        ptp.code = PTP_RC_GeneralError;
+        break;
+      }
+      msg->script_id = param2;
+      if ( !recv_ptp_data(data,msg->data,msg->size) )
+      {
+        ptp.code = PTP_RC_GeneralError;
+        free(msg);
+        break;
+      }
+      if( !enqueue_script_msg(&msg_q_in,msg) ) {
+        ptp.code = PTP_RC_GeneralError;
+        free(msg);
+      }
+      break;
+    }
 #endif
 

trunk/core/ptp.h

@@ -1 +1 @@
 #ifndef __PTP_H
 #define __PTP_H
-
-// N.B.: not checking to see if CAM_CHDK_PTP is set as ptp.h is currently
-// only included by ptp.c (which already checks this before including ptp.h)
-
-#define PTP_CHDK_VERSION_MAJOR 0  // increase only with backwards incompatible changes (and reset minor)
-#define PTP_CHDK_VERSION_MINOR 2  // increase with extensions of functionality
+#define PTP_CHDK_VERSION_MAJOR 1  // increase only with backwards incompatible changes (and reset minor)
+#define PTP_CHDK_VERSION_MINOR 0  // increase with extensions of functionality
 /*
 protocol version history
 0.1 - initial proposal from mweerden, + luar
 0.2 - Added ScriptStatus and ScriptSupport, based on work by ultimA
+1.0 - removed old script result code (luar), replace with message system
 */
 
@@ -39 +36 @@
   PTP_CHDK_ExecuteScript,   // data is script to be executed
                             // param2 is language of script
-                            // param3 is for the ES flags below
-  PTP_CHDK_ScriptStatus,        // Script execution status
-                            // param1 CHDK_PTP_SCRIPT_STATUS_RUN is set if a script running, cleared if not
-                                                        // all other bits and params are reserved for future use
+                            // return param1 is script id, like a process id
+                            // return param2 is status, PTP_CHDK_S_ERRTYPE*
+  PTP_CHDK_ScriptStatus,    // Script execution status
+                            // return param1 bits
+                            // CHDK_PTP_SCRIPT_STATUS_RUN is set if a script running, cleared if not
+                            // CHDK_PTP_SCRIPT_STATUS_MSG is set if script messages from script waiting to be read
+                            // all other bits and params are reserved for future use
   PTP_CHDK_ScriptSupport,   // Which scripting interfaces are supported in this build
                             // param1 CHDK_PTP_SUPPORT_LUA is set if lua is supported, cleared if not
-                                                        // all other bits and params are reserved for future use
+                            // all other bits and params are reserved for future use
+  PTP_CHDK_ReadScriptMsg,   // read next message from camera script system
+                            // return param1 is chdk_ptp_s_msg_type
+                            // return param2 is message subtype:
+                            //   for script return and users this is ptp_chdk_script_data_type
+                            //   for error it may be an error ptp_chdk_script_error_type
+                            // return param3 is script id of script that generated the message
+                            // return param4 is length of the message data
+                            // return data is message.
+                            // A minimum of 4 bytes of zeros is returned if there would not be data otherwise
+  PTP_CHDK_WriteScriptMsg,  // write a message for scripts running on camera
+                            // input param2 is target script id, 0=don't care. Messages for a non-running script will be discarded
+                            // data length is handled by ptp data phase
+                            // input messages do not have type or subtype, they are always a string destined for the script (similar to USER/string)
+                            // output param1 is ptp_chdk_script_msg_status
 } ptp_chdk_command;
 
-// data types as used by TempData and ExecuteScript
+// data types as used by ReadScriptMessage
 enum {
-  PTP_CHDK_TYPE_NOTHING = 0,
+  PTP_CHDK_TYPE_UNSUPPORTED = 0, // type name will be returned in data
   PTP_CHDK_TYPE_NIL,
   PTP_CHDK_TYPE_BOOLEAN,
   PTP_CHDK_TYPE_INTEGER,
-  PTP_CHDK_TYPE_STRING
-} ptp_chdk_type;
+  PTP_CHDK_TYPE_STRING, // NOTE tables currently returned as string
+} ptp_chdk_script_data_type;
 
 // TempData flags
@@ -64 +78 @@
                                    // just clear
 
-// ExecuteScript flags
-#define PTP_CHDK_ES_WAIT      0x1  // do not return after script initialisation
-                                   // but wait until execution has finished
-                                   // (should only be used with short execution
-                                   // times)
-#define PTP_CHDK_ES_RESULT    0x2  // only in combination with WAIT; return
-                                   // param1 will be the ptp_chdk_type of the
-                                   // code result and param2 the value (booleans
-                                   // and integers) or length (strings)
-
-// Script Languages - for execution
+// Script Languages - for execution only lua is supported for now
 #define PTP_CHDK_SL_LUA    0
 #define PTP_CHDK_SL_UBASIC 1
 
 // bit flags for script status
-#define PTP_CHDK_SCRIPT_STATUS_RUN   0x1
+#define PTP_CHDK_SCRIPT_STATUS_RUN   0x1 // script running
+#define PTP_CHDK_SCRIPT_STATUS_MSG   0x2 // messages waiting
 // bit flags for scripting support
 #define PTP_CHDK_SCRIPT_SUPPORT_LUA  0x1
 
+// message types
+enum {
+    PTP_CHDK_S_MSGTYPE_NONE = 0, // no messages waiting
+    PTP_CHDK_S_MSGTYPE_ERR,         // error message
+    PTP_CHDK_S_MSGTYPE_RET,      // script return value
+    PTP_CHDK_S_MSGTYPE_USER,     // message queued by script
+// TODO chdk console data ?
+} ptp_chdk_script_msg_type;
+
+// error subtypes for PTP_CHDK_S_MSGTYPE_ERR and script startup status
+enum {
+    PTP_CHDK_S_ERRTYPE_NONE = 0,
+    PTP_CHDK_S_ERRTYPE_COMPILE,
+    PTP_CHDK_S_ERRTYPE_RUN,
+} ptp_chdk_script_error_type;
+
+// message status
+enum {
+    PTP_CHDK_S_MSGSTATUS_OK = 0, // queued ok
+    PTP_CHDK_S_MSGSTATUS_NOTRUN, // no script is running
+    PTP_CHDK_S_MSGSTATUS_QFULL,  // queue is full
+    PTP_CHDK_S_MSGSTATUS_BADID,  // specified ID is not running
+} ptp_chdk_script_msg_status;
 #endif // __PTP_H

trunk/core/script.c

@@ -467 +467 @@
 }
 
-static void wait_and_end(void)
+void script_wait_and_end(void)
 {
         script_console_add_line("PRESS SHUTTER TO CLOSE");
@@ -496 +496 @@
 
             if (Lres != LUA_YIELD && Lres != 0) {
-                script_console_add_line( lua_tostring( Lt, -1 ) );
-                if(conf.debug_lua_restart_on_error){
-                    lua_script_reset();
-                    script_start_gui(0);
-                } else {
-                    wait_and_end();
-                }
+                lua_script_error(Lt,1);
                 return;
             }
 
             if (Lres != LUA_YIELD) {
+                // add ptp result
+                lua_script_finish(Lt);
                 script_console_add_line(lang_str(LANG_CONSOLE_TEXT_FINISHED));
                 action_pop();
@@ -556 +552 @@
             }
             break;
+#if defined(OPT_LUA) && defined(CAM_CHDK_PTP)
+        case AS_SCRIPT_READ_USB_MSG:
+            if(L) { // only lua supported for now
+                ptp_script_msg *msg = ptp_script_read_msg();
+                if(action_process_delay(2) || msg) {
+                    if(msg) {
+                        lua_pushlstring( Lt,msg->data,msg->size);
+                    } else {
+                        lua_pushnil(Lt);
+                    }
+                    action_clear_delay();
+                    action_pop();
+                    action_pop();
+                }
+            }
+            break;
+        case AS_SCRIPT_WRITE_USB_MSG:
+            if(L) { // only lua supported for now
+                ptp_script_msg *msg = (ptp_script_msg *)action_get_prev(2);
+                int r = ptp_script_write_msg(msg);
+                if(action_process_delay(3) || r) {
+                    action_clear_delay();
+                    action_pop();
+                    action_pop();
+                    action_pop();
+                    lua_pushboolean(Lt,r);
+                }
+            }
+            break;
+#endif
         default:
             if (!action_stack_standard(p) && !state_kbd_script_run)
@@ -630 +656 @@
     if( is_lua() ) {
 #ifdef OPT_LUA
-        if( !lua_script_start(script_source_str) ) {
-            script_print_screen_end();
-            wait_and_end();
+        if( !lua_script_start(script_source_str,0) ) {
             return -1;
         }
@@ -673 +697 @@
 }
 
-#ifdef OPT_LUA
-long script_start_ptp( char *script , int keep_result )
-{
-  if (!lua_script_start(script)) return -1;
-  lua_keep_result = keep_result;
+#if defined(OPT_LUA) && defined(CAM_CHDK_PTP)
+long script_start_ptp( char *script )
+{
+  if (!lua_script_start(script,1)) return -1;
   state_lua_kbd_first_call_to_resume = 1;
   state_kbd_script_run = 1;

trunk/include/platform.h

@@ -541 +541 @@
 void init_chdk_ptp_task();
 
+typedef struct {
+    unsigned size;
+    unsigned script_id; // id of script message is to/from 
+    unsigned type;
+    unsigned subtype;
+    char data[];
+} ptp_script_msg;
+int ptp_script_write_msg(ptp_script_msg *msg);
+ptp_script_msg* ptp_script_read_msg(void);
+ptp_script_msg* ptp_script_create_msg(unsigned type, unsigned subtype, unsigned datasize, const void *data);
+int ptp_script_write_error_msg(unsigned errtype, const char *err);
+
 #endif // CAM_CHDK_PTP
 

trunk/include/script.h

@@ -32 +32 @@
 //-------------------------------------------------------------------
 
-extern long script_start_ptp(char *script, int keep_result);
 long script_stack_start();
 int script_is_running();
@@ -42 +41 @@
 int script_keyid_by_name( const char *name );
 #ifdef OPT_LUA
-long script_start_ptp( char *script , int keep_result );
+long script_start_ptp( char *script );
 #endif
+void script_wait_and_end();
 
 #endif