i2c

UserSpaceArduinoUno_via_Ulisp/code/1_initial_tests/echoulisp7b.dat

@@ -0,0 +1,19 @@
+(defun b ()
+  (pinmode 7 :output)
+  (digitalwrite 7 nil)
+  (delay 500)
+  (digitalwrite 7 t)
+  (delay 200)
+  (digitalwrite 7 nil)
+  (delay 500)
+  (digitalwrite 7 t)
+  (delay 200)
+  (digitalwrite 7 nil)
+  (delay 500)
+  (digitalwrite 7 t)
+  (delay 200)
+  (digitalwrite 7 nil)
+  (delay 500)
+  (digitalwrite 7 ti)
+  (delay 500))
+(b)

UserSpaceArduinoUno_via_Ulisp/code/1_initial_tests/echoulisp7c.dat

@@ -0,0 +1,15 @@
+(defun b ()
+  (pinmode 7 :output)
+  (digitalwrite 7 t)
+  (delay 200)
+  (digitalwrite 7 nil)
+  (delay 500)
+  (digitalwrite 7 t)
+  (delay 200)
+  (digitalwrite 7 nil)
+  (delay 500)
+  (digitalwrite 7 t)
+  (delay 200)
+  (digitalwrite 7 nil)
+  (delay 500))
+(b)

UserSpaceArduinoUno_via_Ulisp/notes/i2c_write_mcp4725

@@ -0,0 +1,222 @@
+14 bit registers
+
+extra bits at end are ignored
+
+data sheet for mxp4725 page 25 is good example
+
+you send something like
+4 bytes
+first is address byte 
+which is found via 
+(defun scn () 
+  (dotimes (p 127)
+    (with-i2c (str p)
+      (when str (print p)))))
+then
+run
+ (scn)
+in ulisp
+ 
+three bytes will be as in page 25
+
+8 bit bytes
+
+as in ulisp i2c page:
+
+//
+Writing to a slave
+For example, to write the three bytes 0, 1, and 2 to a slave device with address #x70 you would use:
+
+(with-i2c (str #x70) 
+  (write-byte 0 str) 
+  (write-byte 1 str) 
+  (write-byte 2 str))
+
+//
+
+so as a test
+i want to write
+0b01000000
+first byte
+second byte will be 
+0-4096 
+divided across 
+two bytes with last 4 bits being blank
+
+so just play around.
+0b11110000
+0b11110000
+two bytes of that
+
+and see what outputs.
+
+can we output binary direct into i2c in ulisp? or do we need
+decimal?
+
+so basic test:
+(with-i2c (str #x96) 
+  (write-byte #b01000000 str) 
+  (write-byte #b11110000 str) 
+  (write-byte #b11110000 str))
+that doesn't work
+(with-i2c (str #x96)
+  (write-byte 0b01000000 str)
+  (write-byte 0b11110000 str)
+  (write-byte 0b11110000 str))
+error: no room for long symbols
+
+in that case
+(with-i2c (str #x96)
+  (write-byte 64 str)
+  (write-byte 192 str)
+  (write-byte 192 str))
+
+note: 192 == 11000000
+
+sorry
+
+needs to be in function
+
+(defun go ()
+  (with-i2c (str #x96)
+    (write-byte #x40 str)
+    (write-byte #xc0 str)
+    (write-byte #xc0 str)))
+
+still getting
+256> (go)
+
+@⸮⸮
+
+nil
+
+doesnt' seem to send the bytes i want...
+
+EDIT: the address bit is 
+decimal 96, not hex 96. got this in 5-10 minutes.
+
+ok
+
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #xc0 str)
+    (write-byte #xc0 str)))
+
+ 256> (defun go2 ()   (with-i2c (str 96)     (write-byte #x40 str)     (write-byte #xc0 str)     (write-byte #xc0 str)))
+
+go2
+
+
+
+229> (go2)
+
+nil
+
+so, nil. no response from mcp, but
+now output is 4 volts. success.
+
+that's pretty much it for a test. now just to clarify the numbers I need to 
+get 0-1V and also to get 1v on output when it starts up (via eeprom)
+
+let's play first.
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #x00 str)
+    (write-byte #xA0 str)))
+
+redefining functions, saves on memory
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #x0F str)
+    (write-byte #xF0 str)))
+about 500mV
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #xFF str)
+    (write-byte #xF0 str)))
+max at 5v
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #xFF str)
+    (write-byte #x00 str)))
+still max
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #x4F str)
+    (write-byte #x00 str)))
+
+1.75V
+
+pretty much that last byte is useless. small amounts of resolution
+in this application
+
+so let's focus on byte 2
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte 200 str)
+    (write-byte #x00 str)))
+4volts
+
+I need a printout of hex to byte for 0-F on my wall...
+but instead, lets use decimal. easier here.
+
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte 100 str)
+    (write-byte #x00 str)))
+2.05volts
+
+1.05 volts for 50
+since 50 is roughly 1/5 of 255... 1/5 of VDD
+
+so i want my cpu load converted from whatever it is, to a number
+from 0-1, then take 0-1 of 48 or so.
+
+if you send this:
+
+(defun go2 ()   (with-i2c (str 96)     (write-byte #x40 str)     (write-byte 48 str)     (write-byte #x00 str))) (go2)
+as one line, you can see it change instantly. (not using variables yet)
+
+so 47 is 1 volt. that will be 100%
+
+0 will be 0.
+
+basically done.
+now to write 0 to eeprom
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x60 str)
+    (write-byte 0 str)
+    (write-byte 0 str)))
+
+let's restart and make sure its at 0.
+otherwise my dial will break
+
+looks good. EDIT: well it's at 200mV, but good enough for now.
+
+don't care really, as long as its lthan 1v.
+
+let's write again. wrote to ram. works. restarted, and value is at 200mv.
+
+OK. all set. Now to build and deploy.
+
+
+
+

UserSpaceArduinoUno_via_Ulisp/notes/i2c_write_mcp4725_BAK

@@ -0,0 +1,222 @@
+14 bit registers
+
+extra bits at end are ignored
+
+data sheet for mxp4725 page 25 is good example
+
+you send something like
+4 bytes
+first is address byte 
+which is found via 
+(defun scn () 
+  (dotimes (p 127)
+    (with-i2c (str p)
+      (when str (print p)))))
+then
+run
+ (scn)
+in ulisp
+ 
+three bytes will be as in page 25
+
+8 bit bytes
+
+as in ulisp i2c page:
+
+//
+Writing to a slave
+For example, to write the three bytes 0, 1, and 2 to a slave device with address #x70 you would use:
+
+(with-i2c (str #x70) 
+  (write-byte 0 str) 
+  (write-byte 1 str) 
+  (write-byte 2 str))
+
+//
+
+so as a test
+i want to write
+0b01000000
+first byte
+second byte will be 
+0-4096 
+divided across 
+two bytes with last 4 bits being blank
+
+so just play around.
+0b11110000
+0b11110000
+two bytes of that
+
+and see what outputs.
+
+can we output binary direct into i2c in ulisp? or do we need
+decimal?
+
+so basic test:
+(with-i2c (str #x96) 
+  (write-byte #b01000000 str) 
+  (write-byte #b11110000 str) 
+  (write-byte #b11110000 str))
+that doesn't work
+(with-i2c (str #x96)
+  (write-byte 0b01000000 str)
+  (write-byte 0b11110000 str)
+  (write-byte 0b11110000 str))
+error: no room for long symbols
+
+in that case
+(with-i2c (str #x96)
+  (write-byte 64 str)
+  (write-byte 192 str)
+  (write-byte 192 str))
+
+note: 192 == 11000000
+
+sorry
+
+needs to be in function
+
+(defun go ()
+  (with-i2c (str #x96)
+    (write-byte #x40 str)
+    (write-byte #xc0 str)
+    (write-byte #xc0 str)))
+
+still getting
+256> (go)
+
+@⸮⸮
+
+nil
+
+doesnt' seem to send the bytes i want...
+
+EDIT: the address bit is 
+decimal 96, not hex 96. got this in 5-10 minutes.
+
+ok
+
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #xc0 str)
+    (write-byte #xc0 str)))
+
+ 256> (defun go2 ()   (with-i2c (str 96)     (write-byte #x40 str)     (write-byte #xc0 str)     (write-byte #xc0 str)))
+
+go2
+
+
+
+229> (go2)
+
+nil
+
+so, nil. no response from mcp, but
+now output is 4 volts. success.
+
+that's pretty much it for a test. now just to clarify the numbers I need to 
+get 0-1V and also to get 1v on output when it starts up (via eeprom)
+
+let's play first.
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #x00 str)
+    (write-byte #xA0 str)))
+
+redefining functions, saves on memory
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #x0F str)
+    (write-byte #xF0 str)))
+about 500mV
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #xFF str)
+    (write-byte #xF0 str)))
+max at 5v
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #xFF str)
+    (write-byte #x00 str)))
+still max
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte #x4F str)
+    (write-byte #x00 str)))
+
+1.75V
+
+pretty much that last byte is useless. small amounts of resolution
+in this application
+
+so let's focus on byte 2
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte 200 str)
+    (write-byte #x00 str)))
+4volts
+
+I need a printout of hex to byte for 0-F on my wall...
+but instead, lets use decimal. easier here.
+
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x40 str)
+    (write-byte 100 str)
+    (write-byte #x00 str)))
+2.05volts
+
+1.05 volts for 50
+since 50 is roughly 1/5 of 255... 1/5 of VDD
+
+so i want my cpu load converted from whatever it is, to a number
+from 0-1, then take 0-1 of 48 or so.
+
+if you send this:
+
+(defun go2 ()   (with-i2c (str 96)     (write-byte #x40 str)     (write-byte 48 str)     (write-byte #x00 str))) (go2)
+as one line, you can see it change instantly. (not using variables yet)
+
+so 47 is 1 volt. that will be 100%
+
+0 will be 0.
+
+basically done.
+now to write 0 to eeprom
+
+(defun go2 ()
+  (with-i2c (str 96)
+    (write-byte #x60 str)
+    (write-byte 0 str)
+    (write-byte 0 str)))
+
+let's restart and make sure its at 0.
+otherwise my dial will break
+
+looks good. EDIT: well it's at 200mV, but good enough for now.
+
+don't care really, as long as its lthan 1v.
+
+let's write again. wrote to ram. works. restarted, and value is at 200mv.
+
+OK. all set. Now to build and deploy.
+
+
+
+