Bug fixes, LPC programming updates

Author: tyler-gilbert

include/hal/I2C.hpp

@@ -25,6 +25,13 @@ class I2C : public Periph {
 		SETUP_WRITE_PTR_TRANSFER /*! \brief I2C transfer that only writes the pointer (no data is transferred) */ = I2C_TRANSFER_WRITE_PTR
 	};
 
+	enum {
+		MASTER /*! \brief I2C acts as master */ = I2C_ATTR_FLAG_MASTER,
+		SLAVE /*! \brief I2C acts as slave */ = I2C_ATTR_FLAG_SLAVE,
+		SLAVE_ACK_GENERAL_CALL /*! \brief I2C slave will ack the general call */ = I2C_ATTR_FLAG_SLAVE_ACK_GENERAL_CALL,
+		PULLUP /*! \brief Enable internal resistor pullups where available */ = I2C_ATTR_FLAG_PULLUP
+	};
+
 	/*! \details Get the I2C attributes */
 	int get_attr(i2c_attr_t & attr);
 	/*! \details Set the I2C attributes */
@@ -53,10 +60,11 @@ class I2C : public Periph {
 	}
 
 	/*! \details Set attributes using specified bitrate and pin assignment. */
-	int set_attr(u32 bitrate = 100000, u8 pin_assign = 0){
+	int set_attr(u32 bitrate = 100000, u8 pin_assign = 0, u16 o_flags = MASTER){
 		i2c_attr_t attr;
 		attr.bitrate = bitrate;
 		attr.pin_assign = pin_assign;
+		attr.o_flags = o_flags;
 		return set_attr(attr);
 	}
 

include/hal/Uart.hpp

@@ -96,7 +96,7 @@ class Uart : public Periph {
 	int set_attr(int baudrate /*! Baudrate */ = 19200,
 			int pin_assign /*! Pin assignment */ = 0,
 			int parity /*! Parity */ = UART_PARITY_NONE,
-			int stop /*! Number of stop bits */ = UART_ATTR_STOP_BITS_2,
+			int stop /*! Number of stop bits */ = STOP1,
 			int width /*! bits per character */ = 8){
 		uart_attr_t attr;
 		attr.baudrate = baudrate;

include/isp/Isp.hpp

@@ -14,12 +14,18 @@ class Isp {
 public:
 	Isp(){}
 
-	virtual int program(const char * filename, int crystal, const char * dev, bool (*progress)(void*,int,int), void * context) = 0;
+	/*! \details Program the device with the specified filename */
+	virtual int program(const char * filename, int crystal, const char * dev, bool (*progress)(void*,int,int), void * context = 0) = 0;
+	/*! \details Read the image from the device */
 	virtual int read(const char * filename, int crystal, bool (*progress)(void*,int,int), void * context) = 0;
 	virtual char ** getlist() = 0;
 	virtual int copy_names(char * device, char * pio0, char * pio1) = 0;
+
+	/*! \details Initialize the physical layer interface */
 	virtual int init_phy(int uart_pinassign) = 0;
+	/*! \details De-initialize the physical layer interface */
 	virtual int exit_phy() = 0;
+	/*! \details Reset the target device */
 	virtual int reset() = 0;
 
 	static int name_maxsize(){ return 32; }

include/isp/LpcIsp.hpp

@@ -6,16 +6,19 @@
 #include <mcu/types.h>
 #include "../hal/Uart.hpp"
 #include "../hal/Pin.hpp"
+#include "../sys/Trace.hpp"
 #include "Isp.hpp"
 #include "LpcPhy.hpp"
 
 namespace isp {
 
 class LpcIsp : public Isp {
 public:
+
+	/*! \details Construct an LPC ISP object using the specified UART, reset pin and isp request pin */
 	LpcIsp(hal::Uart & uart, hal::Pin & rst, hal::Pin & ispreq) : m_phy(uart, rst, ispreq){}
 
-	int program(const char * filename, int crystal, const char * dev, bool (*progress)(void*,int, int), void * context);
+	int program(const char * filename, int crystal, const char * dev, bool (*progress)(void*,int, int), void * context = 0);
 	int read(const char * filename, int crystal, bool (*progress)(void*,int, int), void * context);
 	char ** getlist();
 
@@ -40,6 +43,8 @@ class LpcIsp : public Isp {
 
 	int write_vector_checksum(unsigned char * hex_buffer, const char * dev);
 	int prog_shutdown();
+
+	sys::Trace m_trace;
 };
 
 };

include/isp/LpcPhy.hpp

@@ -5,6 +5,7 @@
 
 #include "../hal/Uart.hpp"
 #include "../hal/Pin.hpp"
+#include "../sys/Trace.hpp"
 
 #define LPC_ISP_UNLOCK_CODE "23130"
 
@@ -17,28 +18,31 @@ class LpcPhy {
 	LpcPhy(hal::Uart & uart, hal::Pin & reset, hal::Pin & ispreq) : m_uart(uart), m_reset(reset), m_ispreq(ispreq){
 		m_echo = 0;
 		m_ram_buffer = 0x40000200;
-		m_is_lpc177x_8x = false;
+		m_is_return_code_newline = false;
+		m_is_uuencode = false;
+		m_pinassign = 0;
+		m_max_speed = MAX_SPEED_115200;
 	}
 
 
 	int init(int pinassign);
 	int exit();
 	int open(int crystal);
 	int close();
-	int writemem(u32 loc, const void * buf, int nbyte, u32 sector);
+	int write_memory(u32 loc, const void * buf, int nbyte, u32 sector);
 	void set_ram_buffer(u32 addr);
-	int readmem(u32 loc, void * buf, int nbyte);
+	int read_memory(u32 loc, void * buf, int nbyte);
 	int reset();
 	int start_bootloader();
 	int sync_bootloader(u32 crystal);
 	int sync_bootloader_lpc177x_8x(u32 crystal);
 	int unlock(const char * unlock_code);
-	int echo_off();
-	int echo_on();
-	int wr_ram(u32 ram_dest /*! The RAM destination address--must be a word boundary */,
+	int disable_echo();
+	int enable_echo();
+	int write_ram(u32 ram_dest /*! The RAM destination address--must be a word boundary */,
 			void * src /*! A pointer to the source data */,
 			u32 size /*! The number of bytes to write--must be a multiple of 4 */);
-	u32 rd_mem(void * dest /*! A pointer to the destination memory */,
+	u32 read_mem(void * dest /*! A pointer to the destination memory */,
 			u32 src_addr /*! The source address to read--must be a word boundary */,
 			u32 size /*! The number of bytes to read--must be a multiple of 4 */);
 	int prep_sector(u32 start /*! The first sector to prepare */,
@@ -52,31 +56,56 @@ class LpcPhy {
 			u32 end /*! The last sector to erase--must be >= start */);
 	int blank_check_sector(u32 start /*! The first sector to blank check */,
 			u32 end /*! The last sector to blank check--must be >= start */);
-	u32 rd_part_id();
-	u32 rd_boot_version();
-	int memcmp(u32 addr0 /*! The beginning of the first block */,
+	u32 read_part_id();
+	u32 read_boot_version();
+	int compare_memory(u32 addr0 /*! The beginning of the first block */,
 			u32 addr1 /*! The beginning of the second block */,
 			u32 size /*! The number of bytes to compare */);
 
+	void set_uuencode(bool v = true){ m_is_uuencode = v; }
+	bool is_uuencode() const  { return m_is_uuencode; }
+
+	void set_max_speed(u16 v){
+		m_max_speed = v;
+		if( m_max_speed > MAX_SPEED_9600 ){
+			m_max_speed = MAX_SPEED_9600;
+		}
+	}
+
+	enum {
+		MAX_SPEED_115200,
+		MAX_SPEED_78600,
+		MAX_SPEED_57600,
+		MAX_SPEED_38400,
+		MAX_SPEED_19200,
+		MAX_SPEED_9600
+	};
+
 private:
 	char m_echo;
 	hal::Uart & m_uart;
 	hal::Pin & m_reset;
 	hal::Pin & m_ispreq;
 	u32 m_ram_buffer;
-	int32_t lpc_write_data(void * src, u32 size);
-	int32_t lpc_read_data(void * dest, u32 size);
+	int m_pinassign;
+	bool m_is_return_code_newline;
+	bool m_is_uuencode;
+	u16 m_max_speed;
+
+	int send_command(const char * cmd, int timeout, int wait_ms = 0);
+	s32 write_data(void * src, u32 size);
+	s32 read_data(void * dest, u32 size);
 	int get_line(void * buf, int nbyte, int max_wait);
-	int lpc_rd_return_code(u16 timeout);
-	int lpc_wait_response(const char * response, u16 timeout);
-	int lpc_wait_ok(u16 timeout);
+	int read_return_code(u16 timeout);
+	int wait_response(const char * response, u16 timeout);
+	int wait_ok(u16 timeout);
+
 
-	bool m_is_lpc177x_8x;
-	bool is_lpc177x_8x(){ return m_is_lpc177x_8x; }
-	void set_lpc177x_8x(bool enabled = true){ m_is_lpc177x_8x = enabled; }
+	bool is_return_code_newline(){ return m_is_return_code_newline; }
+	void set_return_code_newline(bool enabled = true){ m_is_return_code_newline = enabled; }
 
-	int sendcommand(const char * cmd, int timeout, int wait_ms = 0);
 
+	sys::Trace m_trace;
 	int flush();
 
 };

include/sys.hpp

@@ -17,12 +17,12 @@ namespace sys {};
 #include "sys/Sched.hpp"
 #include "sys/Timer.hpp"
 #include "sys/Time.hpp"
-#include "sys/Trace.hpp"
 #include "sys/Dbug.hpp"
 #include "sys/DbugStdout.hpp"
 #include "sys/DbugUart.hpp"
 #endif
 
+#include "sys/Trace.hpp"
 #include "sys/Kernel.hpp"
 #include "sys/Appfs.hpp"
 #include "sys/Dir.hpp"

include/sys/Trace.hpp

@@ -26,11 +26,19 @@ class Trace : public var::String {
 	Trace& operator=(const char * a){ var::String::operator=(a); return *this; }
 	Trace& operator=(const var::String & a){ var::String::operator=(a); return *this; }
 
+#if !defined __link
 	inline void message() MCU_ALWAYS_INLINE { stratify_trace_event(POSIX_TRACE_MESSAGE, c_str(), size()); }
 	inline void warning() MCU_ALWAYS_INLINE { stratify_trace_event(POSIX_TRACE_WARNING, c_str(), size()); }
 	inline void error() MCU_ALWAYS_INLINE { stratify_trace_event(POSIX_TRACE_ERROR, c_str(), size()); }
 	inline void critical() MCU_ALWAYS_INLINE { stratify_trace_event(POSIX_TRACE_CRITICAL, c_str(), size()); }
 	inline void fatal() MCU_ALWAYS_INLINE { stratify_trace_event(POSIX_TRACE_FATAL, c_str(), size()); }
+#else
+	inline void message(){}
+	inline void warning(){}
+	inline void error(){}
+	inline void critical(){}
+	inline void fatal(){}
+#endif
 
 };
 

include/ui/Button.hpp

@@ -37,6 +37,16 @@ class Button {
 	 */
 	static void set_held_duration(u32 v){ m_held_duration = v; }
 
+	/*! \details This method returns the max held duration which will effectively disable the
+	 * reporting of button holds
+	 *
+	 *
+	 *  \code
+	 *  Button::set_held_duration( Button::max_held_duration() );
+	 *  \endcode
+	 */
+	static u32 max_held_duration(){ return (u32)-1; }
+
 	/*! \details This method checks the state of the actuation and then returns
 	 * an Event if needed.
 	 *
@@ -50,7 +60,9 @@ class Button {
 	 */
 	ui::Event event();
 
+	/*! \details Set the event ID of the button */
 	void set_event_id(enum ui::Event::button_id v){ m_event_id = v; }
+	/*! \details Access the event ID of the button */
 	enum ui::Event::button_id event_id() const { return m_event_id; }
 
 	/*! \details Returns the duration of the last button press.
@@ -99,7 +111,6 @@ class Button {
 protected:
 
 	virtual bool get_is_active() const = 0;
-
 	static u32 m_held_duration;
 	enum ui::Event::button_id m_event_id;
 
@@ -112,6 +123,7 @@ class Button {
 		unsigned release_reported:1;
 		unsigned held_reported:1;
 		unsigned actuation_reported:1;
+		unsigned duration_reported:1;
 	};
 
 	struct button_flags m_flags;

include/ui/Element.hpp

@@ -28,6 +28,8 @@ class Element : public draw::Drawing {
 
 	/*! \details Returns true if element is enabled */
 	inline bool is_enabled() const { return flag(FLAG_ENABLED); }
+	/*! \details Enable the element */
+	inline void set_enable(bool v = true){ set_flag(FLAG_ENABLED, v); }
 	inline void set_enabled(bool v = true){ set_flag(FLAG_ENABLED, v); }
 
 	/*! \details Returns true if element is visible */