Bill Smith
AE11 GUI for PICO
Dependencies: max32625pico USBDevice
Revision 0:a13d6826cf66, committed 2020-06-25
- Comitter:
- PowerIC
- Date:
- Thu Jun 25 17:25:24 2020 +0000
- Commit message:
- Initial_Upload
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/USBDevice.lib Thu Jun 25 17:25:24 2020 +0000 @@ -0,0 +1,1 @@ +https://developer.mbed.org/teams/MaximIntegrated/code/USBDevice/#dad310740b28
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/i2c.cpp Thu Jun 25 17:25:24 2020 +0000
@@ -0,0 +1,267 @@
+#include "mbed.h"
+#include "i2c.h"
+//#include "mcp4728.h"
+
+//-- PIN DEFINITIONS ----------------------------------------------------------------------------------
+I2C i2c1(P1_6, P1_7); // Enable I2C Master 1(SDA, SCL)
+//I2C i2c2(P5_7, P6_0); // Enable I2C Master 2(SDA, SCL)
+
+//-- VARIABLES ----------------------------------------------------------------------------------------
+extern char I2C1_TXDATA[];
+extern char I2C1_RXDATA[];
+//extern char I2C2_TXDATA[];
+//extern char I2C2_RXDATA[];
+
+void Init_I2C()
+{
+ i2c1.frequency(400000); // Set I2C Bus = 400KHz
+ //i2c2.frequency(400000); // Set I2C Bus = 400KHz
+}
+
+char I2C_Quick_Write(char port, char address)
+{
+ // Device present should respond with 0x01, otherwise 0x00
+ char RESPONSE = 0x00;
+ port = I2C_PORT1;
+
+ if(port == I2C_PORT2)
+ {
+ //i2c2.start();
+ //RESPONSE = i2c2.write(address); // Echo ACK/NACK Status
+ //i2c2.stop();
+ }
+ else
+ {
+ i2c1.start();
+ RESPONSE = i2c1.write(address); // Echo ACK/NACK Status
+ i2c1.stop();
+ }
+
+ return RESPONSE;
+}
+
+char I2C_Read_Byte(char port, char address, char reg)
+{
+ char RESPONSE = 0x00;
+ port = I2C_PORT1;
+
+ if(port == I2C_PORT2)
+ {
+ //I2C2_TXDATA[0] = reg; // Which register?
+ //(void)i2c2.write(address, I2C2_TXDATA, 1, true);
+ //(void)i2c2.read(address, I2C2_RXDATA, 1); // Ask for data
+ //wait_us(25); // Wait for it
+ //RESPONSE = I2C2_RXDATA[0]; // Return Data
+ }
+ else
+ {
+ I2C1_TXDATA[0] = reg; // Which register?
+ (void)i2c1.write(address, I2C1_TXDATA, 1, true);
+ (void)i2c1.read(address, I2C1_RXDATA, 1); // Ask for data
+ wait_us(25); // Wait for it
+ RESPONSE = I2C1_RXDATA[0]; // Return Data
+ }
+
+ return RESPONSE;
+}
+
+char I2C_Write_Register(char port, char address, char reg, char data)
+{
+ char RESPONSE = 0x00;
+ port = I2C_PORT1;
+
+ if(port == I2C_PORT2)
+ {
+ //I2C2_TXDATA[0] = reg; // Register
+ //I2C2_TXDATA[1] = data; // Data
+ //RESPONSE = i2c2.write(address,I2C2_TXDATA,2); // Echo ACK/NACK
+ }
+ else
+ {
+ I2C1_TXDATA[0] = reg; // Register
+ I2C1_TXDATA[1] = data; // Data
+ RESPONSE = i2c1.write(address,I2C1_TXDATA,2); // Echo ACK/NACK
+ }
+
+ return RESPONSE;
+}
+
+unsigned short I2C_Read_Word(char port, char address, char reg)
+{
+ unsigned short RESPONSE = 0x0000;
+ port = I2C_PORT1;
+
+ if(port == I2C_PORT2)
+ {
+ //I2C2_TXDATA[0] = reg; // Which register?
+ //(void)i2c2.write(address, I2C2_TXDATA, 1, true);
+ //(void)i2c2.read(address, I2C2_RXDATA, 2); // Ask for data
+ //wait_us(25); // Wait for it
+
+ //RESPONSE = (unsigned short)((I2C2_RXDATA[0] * 256) + I2C2_RXDATA[1]); // Return Data
+ }
+ else
+ {
+ I2C1_TXDATA[0] = reg; // Which register?
+ (void)i2c1.write(address, I2C1_TXDATA, 1, true);
+ (void)i2c1.read(address, I2C1_RXDATA, 2); // Ask for data
+ wait_us(25); // Wait for it
+
+ RESPONSE = (unsigned short)((I2C1_RXDATA[0] * 256) + I2C1_RXDATA[1]); // Return Data
+ }
+
+ return RESPONSE;
+}
+
+char I2C_Write_Word(char port, char address, char reg, char hbyte, char lbyte)
+{
+ char RESPONSE = 0x00;
+ port = I2C_PORT1;
+
+ if(port == I2C_PORT2)
+ {
+ //I2C2_TXDATA[0] = reg; // Register
+ //I2C2_TXDATA[1] = hbyte; // HB Data
+ //I2C2_TXDATA[2] = lbyte; // LB Data
+ //RESPONSE = i2c2.write(address,I2C2_TXDATA,3); // Echo ACK/NACK
+ }
+ else
+ {
+ I2C1_TXDATA[0] = reg; // Register
+ I2C1_TXDATA[1] = hbyte; // HB Data
+ I2C1_TXDATA[2] = lbyte; // LB Data
+ RESPONSE = i2c1.write(address,I2C1_TXDATA,3); // Echo ACK/NACK
+ }
+
+ return RESPONSE;
+}
+
+void I2C_Write_Byte(char address, char data)
+{
+ I2C1_TXDATA[0] = data; // Data
+ (void)i2c1.write(address,I2C1_TXDATA,1);
+ wait_us(10); // Wait for Mux to settle
+}
+
+
+char I2C_Write_Block(char port, char address, char nbytes)
+{
+ char RESPONSE = 0x00;
+ port = I2C_PORT1;
+
+ if(port == I2C_PORT2)
+ {
+ //RESPONSE = i2c2.write(address,I2C2_TXDATA,nbytes + 1); // Echo ACK/NACK
+ }
+ else
+ {
+ RESPONSE = i2c1.write(address,I2C1_TXDATA,nbytes + 1); // Echo ACK/NACK
+ }
+
+ return RESPONSE;
+}
+
+
+/*
+char I2C_Write_Fast(char port, char address, char daca_hb, char daca_lb, char dacb_hb, char dacb_lb, char dacc_hb, char dacc_lb, char dacd_hb, char dacd_lb)
+{
+ char RESPONSE = 0x00;
+ //port = I2C_PORT1;
+
+ if(port == I2C_PORT2)
+ {
+ I2C2_TXDATA[0] = daca_hb; // DAC_A High Byte
+ I2C2_TXDATA[1] = daca_lb; // DAC_A Low Byte
+ I2C2_TXDATA[2] = dacb_hb; // DAC_B High Byte
+ I2C2_TXDATA[3] = dacb_lb; // DAC_B Low Byte
+ I2C2_TXDATA[4] = dacc_hb; // DAC_C High Byte
+ I2C2_TXDATA[5] = dacc_lb; // DAC_C Low Byte
+ I2C2_TXDATA[6] = dacd_hb; // DAC_D High Byte
+ I2C2_TXDATA[7] = dacd_lb; // DAC_D Low Byte
+ RESPONSE = i2c2.write(address,I2C2_TXDATA,3); // Echo ACK/NACK
+ }
+ else
+ {
+ I2C1_TXDATA[0] = daca_hb; // DAC_A High Byte
+ I2C1_TXDATA[1] = daca_lb; // DAC_A Low Byte
+ I2C1_TXDATA[2] = dacb_hb; // DAC_B High Byte
+ I2C1_TXDATA[3] = dacb_lb; // DAC_B Low Byte
+ I2C1_TXDATA[4] = dacc_hb; // DAC_C High Byte
+ I2C1_TXDATA[5] = dacc_lb; // DAC_C Low Byte
+ I2C1_TXDATA[6] = dacd_hb; // DAC_D High Byte
+ I2C1_TXDATA[7] = dacd_lb; // DAC_D Low Byte
+ RESPONSE = i2c1.write(address,I2C1_TXDATA,8); // Echo ACK/NACK
+ }
+
+ return RESPONSE;
+}
+*/
+
+/*
+char I2C_Write_Block(char port, char address, char reg, char byte1, char byte2, char byte3, char byte4, char byte5, char byte6, char byte7, char byte8)
+{
+ char RESPONSE = 0x00;
+ //port = I2C_PORT1;
+
+ if(port == I2C_PORT2)
+ {
+ I2C2_TXDATA[0] = reg; // Register
+ I2C2_TXDATA[1] = byte1; // Byte 1
+ I2C2_TXDATA[2] = byte2; // Byte 2
+ I2C2_TXDATA[3] = byte3; // Byte 3
+ I2C2_TXDATA[4] = byte4; // Byte 4
+ I2C2_TXDATA[5] = byte5; // Byte 5
+ I2C2_TXDATA[6] = byte6; // Byte 6
+ I2C2_TXDATA[7] = byte7; // Byte 7
+ I2C2_TXDATA[8] = byte8; // Byte 8
+ RESPONSE = i2c2.write(address,I2C2_TXDATA,3); // Echo ACK/NACK
+ }
+ else
+ {
+ I2C1_TXDATA[0] = reg; // Register
+ I2C1_TXDATA[1] = byte1; // Byte 1
+ I2C1_TXDATA[2] = byte2; // Byte 2
+ I2C1_TXDATA[3] = byte3; // Byte 3
+ I2C1_TXDATA[4] = byte4; // Byte 4
+ I2C1_TXDATA[5] = byte5; // Byte 5
+ I2C1_TXDATA[6] = byte6; // Byte 6
+ I2C1_TXDATA[7] = byte7; // Byte 7
+ I2C1_TXDATA[8] = byte8; // Byte 8
+ RESPONSE = i2c1.write(address,I2C1_TXDATA,9); // Echo ACK/NACK
+ }
+
+ return RESPONSE;
+}
+*/
+
+
+/*
+unsigned short I2C_Read_Block(char address, char reg, int nbytes)
+{
+ unsigned short RESPONSE = 0x0000;
+
+ I2C1_TXDATA[0] = reg; // Which register?
+ (void)i2c.write(address, I2C1_TXDATA, 1, true);
+ (void)i2c.read(address,I2C1_RXDATA,nbytes);
+
+ switch(reg)
+ {
+ case DAC_A:
+ RESPONSE = (unsigned short)(((I2C1_RXDATA[1] & 0x0F) * 256) + I2C1_RXDATA[2]); // Return DAC A Data
+ break;
+ case DAC_B:
+ RESPONSE = (unsigned short)(((I2C1_RXDATA[7] & 0x0F) * 256) + I2C1_RXDATA[8]); // Return DAC B Data
+ break;
+ case DAC_C:
+ RESPONSE = (unsigned short)(((I2C1_RXDATA[13] & 0x0F) * 256) + I2C1_RXDATA[14]); // Return DAC C Data
+ break;
+ case DAC_D:
+ RESPONSE = (unsigned short)(((I2C1_RXDATA[19] & 0x0F) * 256) + I2C1_RXDATA[20]); // Return DAC D Data
+ break;
+ default:
+ break;
+ }
+
+ return RESPONSE;
+}
+*/
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/i2c.h Thu Jun 25 17:25:24 2020 +0000 @@ -0,0 +1,18 @@ +#define I2C_PORT1 0x00 +#define I2C_PORT2 0x01 + +extern char I2C1_TXDATA[]; +extern char I2C1_RXDATA[]; +//extern char I2C2_TXDATA[]; +//extern char I2C2_RXDATA[]; + +//-- PROTOTYPES ---------------------------------------------------------------------------------------- +void Init_I2C(); +char I2C_Quick_Write(char port, char address); +char I2C_Read_Byte(char port, char address, char reg); +char I2C_Write_Register(char port, char address, char reg, char data); +unsigned short I2C_Read_Word(char port, char address, char reg); +char I2C_Write_Word(char port, char address, char reg, char hbyte, char lbyte); +//char I2C_Write_Fast(char port, char address, char daca_hb, char daca_lb, char dacb_hb, char dacb_lb, char dacc_hb, char dacc_lb, char dacd_hb, char dacd_lb); +char I2C_Write_Block(char port, char address, char nbytes); +unsigned short I2C_Read_Block(char address, char reg, int nbytes);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp Thu Jun 25 17:25:24 2020 +0000
@@ -0,0 +1,557 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// MAX32625PICO FIRMWARE FOR MAXIM AE11 EVBs
+// Revision: 1.3
+// Date: 09/18/2019
+// Author: Bill Smith
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "mbed.h"
+#include "USBHID.h"
+#include "max32625pico.h"
+#include "i2c.h"
+
+// configure VDDIOH to local 3.3V supply, set dipVio and swdVio to 1.8V supply
+MAX32625PICO pico(MAX32625PICO::IOH_3V3, MAX32625PICO::VIO_1V8, MAX32625PICO::VIO_1V8);
+
+// We declare a USBHID device.
+// HID In/Out Reports are 64 Bytes long
+// Vendor ID (VID): 0x0B6A // Maxim Integrated
+// Product ID (PID): 0x0001 //
+// Serial Number: 0x0001 //
+USBHID hid(64, 64, 0x0B6A, 0x0003, 0x0001, true);
+
+InterruptIn alertb1(P3_2); // Interrupt PIN (INPUT)
+InterruptIn alertb2(P3_3); // Interrupt PIN (INPUT)
+
+DigitalOut red_led(LED1);
+DigitalOut green_led(LED2);
+DigitalOut blue_led(LED3);
+
+Timeout to_alertb1; // ALERTB1 timeout
+Timeout to_alertb2; // ALERTB2 timeout
+
+HID_REPORT send_report;
+HID_REPORT recv_report;
+
+//-----------------------------------------------------------------------------------------------------
+// USB COMMANDS
+//-----------------------------------------------------------------------------------------------------
+// LED Command
+#define WRITE_LED 0x20 // Send data to the RGB LED
+
+// I2C1 Commands
+#define QUICK_WRITE_I2C1 0x30 // Send Device Address on I2C Master 1, look for ACK
+#define READ_BYTE_I2C1 0x31 // Read Data Byte (8-bits) from Register of I2C Device
+#define WRITE_BYTE_I2C1 0x32 // Write Data Byte (8-bits) to Register of I2C Device
+#define READ_WORD_I2C1 0x33 // Read Data Word (16-bits) from Register of I2C Device
+#define WRITE_WORD_I2C1 0x34 // Write Data Word (16-bits) to Register of I2C Device
+#define WRITE_BLOCK_I2C1 0x3A // Write Data Block to Register of I2C Device
+#define SET_I2C_ADDR 0x3E // Set I2C Slave Address
+#define GET_I2C_ADDR 0x3F // Get I2C Slave Address
+
+// I2C2 Commands
+//#define QUICK_WRITE_I2C2 0x35 // Send Device Address on I2C Master 2, look for ACK
+//#define READ_BYTE_I2C2 0x36 // Read Data Byte (8-bits) from Register of I2C Device
+//#define WRITE_BYTE_I2C2 0x37 // Write Data Byte (8-bits) to Register of I2C Device
+//#define READ_WORD_I2C2 0x38 // Read Data Word (16-bits) from Register of I2C Device
+//#define WRITE_WORD_I2C2 0x39 // Write Data Word (16-bits) to Register of I2C Device
+//#define WRITE_BLOCK_I2C2 0x3B // Write Data Block to Register of I2C Device
+
+// AE11 Commands
+#define GET_FUNC_REGS 0x40 // Return
+#define GET_VENDOR_REGS 0x41 // Return
+#define GET_INT_REGS 0x42 // Return
+#define GET_MASK_REGS 0x43 // Return
+#define GET_CTRL_REGS 0x44 // Return
+#define GET_TAB1_REGS 0x45 // Return
+#define GET_OTP_DATA_REGS 0x46 // Return
+#define GET_OTP_TEST_CMD_REGS 0x47 // Return
+#define GET_OTP_TEST_MODE_REGS 0x48 // Return
+#define GET_OTP_TEST_OVRD_REGS 0x49 // Return
+#define OTP_REGS_UNLOCK 0x4A // Return
+#define OTP_REGS_LOCK 0x4B // Return
+
+// INTERRUPT Commands
+#define ALERTB1_ASSERTED 0xF0 // ALERTB1 Interrupt
+#define CLEAR_INTS 0xF2 // Clear All Interrupts
+
+// LED CONSTANTS
+#define LEDS_OFF 0x00
+#define RED 0x01
+#define GREEN 0x02
+#define BLUE 0x03
+#define YELLOW 0x04
+
+// LOGICAL CONSTANTS
+#define OFF 0x00
+#define ON 0x01
+
+char FUNC_REGS[63] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+ 0x0A, 0x0B, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21,
+ 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2E, 0x2F,
+ 0x30, 0x50, 0x51, 0x70, 0x71, 0x74, 0x75, 0x76, 0x77, 0x78,
+ 0x79, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
+ 0x89, 0x8A, 0x8B };
+
+char OTP_DATA_REGS[36] = { 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
+ 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3,
+ 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD,
+ 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3 };
+
+char OTP_TEST_CMD_REGS[16] = { 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
+ 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF };
+
+char OTP_TEST_MODE_REGS[23] = { 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
+ 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3,
+ 0xE4, 0xE5, 0xE6 };
+
+char OTP_TEST_OVRD_REGS[13] = { 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
+ 0xFA, 0xFB, 0xFC };
+
+char VENDOR_REGS[12] = { 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+ 0x8A, 0x8B };
+
+char INT_REGS[8] = { 0x10, 0x11, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x8B };
+
+char MASK_REGS[5] = { 0x12, 0x13, 0x14, 0x15, 0x16 };
+
+char CTRL_REGS[5] = { 0x18, 0x19, 0x1A, 0x1B, 0x1C };
+
+char TAB1_REGS[29] = { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+ 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x80, 0x81, 0x82,
+ 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B };
+
+//-----------------------------------------------------------------------------------------------------
+// VARIABLES
+//-----------------------------------------------------------------------------------------------------
+char I2C1_RXDATA[40];
+//char I2C2_RXDATA[40];
+char I2C1_TXDATA[40];
+//char I2C2_TXDATA[40];
+static char ALERTB1_STATE = 0x00; // ALERTB1 PIN STATE
+static bool ALERTB1_CHANGED = false;
+static char I2C_ADDR = 0x00;
+
+
+//-----------------------------------------------------------------------------------------------------
+// ALERTB1 INTERRUPT SERVICE ROUTINE
+//-----------------------------------------------------------------------------------------------------
+void test_alertb1_low()
+{
+ if(alertb1.read() == 0)
+ {
+ ALERTB1_STATE = 0x01; // Capture the state of the ALERTB1 pin
+ ALERTB1_CHANGED = true;
+ }
+}
+
+void test_alertb1_high()
+{
+ if(alertb1.read() == 1)
+ {
+ ALERTB1_STATE = 0x00; // Capture the state of the ALERTB1 pin
+ ALERTB1_CHANGED = true;
+ }
+}
+
+void ALERTB1_FALL_ISR()
+{
+ to_alertb1.attach(test_alertb1_low, 0.1);
+}
+
+void ALERTB1_RISE_ISR()
+{
+ to_alertb1.attach(test_alertb1_high, 0.1);
+}
+
+void StartUp_LEDs()
+{
+ red_led = 0; // Turn ON RED LED
+ wait(0.3);
+ red_led = 1; // Turn OFF RED LED
+ green_led = 0; // Turn ON GREEN LED
+ wait(0.3);
+ green_led = 1; // Turn OFF GREEN LED
+ blue_led = 0; // Turn ON BLUE LED
+ wait(0.3);
+ blue_led = 1; // Turn OFF BLUE LED
+}
+
+
+// main() runs in its own thread in the OS
+int main()
+{
+ send_report.length = 64;
+ recv_report.length = 64;
+
+ StartUp_LEDs(); // Cycle LEDs to show startup
+
+ Init_I2C(); // Make sure we can talk
+
+ alertb1.fall(&ALERTB1_FALL_ISR); // Attaches ALERTB1 to the ISR
+ alertb1.rise(&ALERTB1_RISE_ISR);
+
+ while (true)
+ {
+ if(ALERTB1_CHANGED)
+ {
+ send_report.data[0] = ALERTB1_ASSERTED; // Echo Command
+ send_report.data[1] = ALERTB1_STATE; // Echo INTB State
+
+ for(int i=0;i<8;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, I2C_ADDR, INT_REGS[i]); // Slave Address must be set!
+ }
+
+ ALERTB1_CHANGED = false; // Clear the INTB State Changed Flag
+ hid.sendNB(&send_report); // Send the report (Non-blocking)
+ }
+
+ if(hid.readNB(&recv_report))
+ {
+ switch(recv_report.data[0])
+ {
+ //-----------------------------------------------------------------------------------------------------------------
+ case WRITE_LED: // COMMAND [0x20] - WRITE TO RGB LED
+ //-----------------------------------------------------------------------------------------------------------------
+ switch(recv_report.data[1])
+ {
+ case LEDS_OFF:
+ red_led = 1; // Turn OFF RED LED
+ green_led = 1; // Turn OFF GREEN LED
+ blue_led = 1; // Turn OFF BLUE LED
+ break;
+ case RED:
+ if(recv_report.data[2] == 1){red_led = 0;} else {red_led = 1;}
+ break;
+ case GREEN:
+ if(recv_report.data[2] == 1){green_led = 0;} else {green_led = 1;}
+ break;
+ case BLUE:
+ if(recv_report.data[2] == 1){blue_led = 0;} else {blue_led = 1;}
+ break;
+ default:
+ break;
+ }// End Switch (RD1)
+
+ send_report.data[0] = recv_report.data[0]; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Subcommand 1
+ send_report.data[2] = recv_report.data[2]; // Echo Subcommand 2
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case QUICK_WRITE_I2C1: // COMMAND [0x30] - QUICK WRITE TO I2C1
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = QUICK_WRITE_I2C1; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Subcommand
+ send_report.data[2] = I2C_Quick_Write(0x00, recv_report.data[1]); // Echo ACK/NACK Status
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case READ_BYTE_I2C1: // COMMAND [0x31] - BYTE READ FROM I2C1
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = READ_BYTE_I2C1; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Device Address
+ send_report.data[2] = recv_report.data[2]; // Echo Register
+ send_report.data[3] = I2C_Read_Byte(0x00, recv_report.data[1], recv_report.data[2]); // Return Data
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case WRITE_BYTE_I2C1: // COMMAND [0x32] - BYTE WRITE TO I2C1
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = WRITE_BYTE_I2C1; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Device Address
+ send_report.data[2] = recv_report.data[2]; // Echo Register
+ send_report.data[3] = recv_report.data[3]; // Echo Data
+ send_report.data[4] = I2C_Write_Register(0x00, recv_report.data[1], recv_report.data[2], recv_report.data[3]);
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case READ_WORD_I2C1: // COMMAND [0x33] - READ WORD FROM I2C1
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = READ_WORD_I2C1; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Device Address
+ send_report.data[2] = recv_report.data[2]; // Echo Register
+
+ unsigned short RX1 = I2C_Read_Word(0x00, recv_report.data[1], recv_report.data[2]); // Read Device
+
+ send_report.data[3] = (char)((RX1 & 0xFF00) >> 8); // Return Data High Byte
+ send_report.data[4] = (char)(RX1 & 0x00FF); // Return Data Low Byte
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case WRITE_WORD_I2C1: // COMMAND [0x34] - WORD WRITE TO I2C1
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = WRITE_WORD_I2C1; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Device Address
+ send_report.data[2] = recv_report.data[2]; // Echo Register
+ send_report.data[3] = recv_report.data[3]; // Echo HBData
+ send_report.data[4] = recv_report.data[4]; // Echo LBData
+ send_report.data[5] = I2C_Write_Word(0x00, recv_report.data[1], recv_report.data[2], recv_report.data[3], recv_report.data[4]);
+ break;
+
+ //-----------------------------------------------------------------------------------------------------------------
+ case WRITE_BLOCK_I2C1: // COMMAND [0x3A] - WRITE A BLOCK of DATA (1 to 10 bytes) TO I2C1
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = WRITE_BLOCK_I2C1; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Device Address
+ send_report.data[2] = recv_report.data[2]; // Echo Register
+ send_report.data[3] = recv_report.data[3]; // Echo Number of Data Bytes
+
+ I2C1_TXDATA[0] = recv_report.data[2]; // Register Address
+
+ for(int n = 0; n < recv_report.data[3]; n++)
+ {
+ I2C1_TXDATA[1 + n] = recv_report.data[4 + n]; // Load TX Buffer with Data
+ }
+
+ I2C_Write_Block(0x00, recv_report.data[1], recv_report.data[3]);
+
+ break;
+
+ //-----------------------------------------------------------------------------------------------------------------
+ case SET_I2C_ADDR: // COMMAND [0x3E] - ASSIGN I2C DEVICE ADDRESS FOR SLAVE OPERATIONS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = SET_I2C_ADDR; // Echo Command
+ I2C_ADDR = recv_report.data[1]; // Assign Slave Address
+ send_report.data[1] = recv_report.data[1]; // Echo Subcommand
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_I2C_ADDR: // COMMAND [0x3F] - ASSIGN I2C DEVICE ADDRESS FOR SLAVE OPERATIONS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_I2C_ADDR; // Echo Command
+ send_report.data[1] = I2C_ADDR; // Return Slave Address
+ break;
+/*
+ //-----------------------------------------------------------------------------------------------------------------
+ case QUICK_WRITE_I2C2: // COMMAND [0x35] - QUICK WRITE TO I2C2
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = QUICK_WRITE_I2C2; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Subcommand
+ send_report.data[2] = I2C_Quick_Write(0x01, recv_report.data[1]); // Echo ACK/NACK Status
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case READ_BYTE_I2C2: // COMMAND [0x36] - BYTE READ FROM I2C1
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = READ_BYTE_I2C2; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Device Address
+ send_report.data[2] = recv_report.data[2]; // Echo Register
+ send_report.data[3] = I2C_Read_Byte(0x01, recv_report.data[1], recv_report.data[2]); // Return Data
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case WRITE_BYTE_I2C2: // COMMAND [0x37] - BYTE WRITE TO I2C2
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = WRITE_BYTE_I2C2; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Device Address
+ send_report.data[2] = recv_report.data[2]; // Echo Register
+ send_report.data[3] = recv_report.data[3]; // Echo Data
+ send_report.data[4] = I2C_Write_Register(0x01, recv_report.data[1], recv_report.data[2], recv_report.data[3]);
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case READ_WORD_I2C2: // COMMAND [0x38] - READ WORD FROM I2C2
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = READ_WORD_I2C2; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Device Address
+ send_report.data[2] = recv_report.data[2]; // Echo Register
+
+ unsigned short RX2 = I2C_Read_Word(0x01, recv_report.data[1], recv_report.data[2]); // Read Device
+
+ send_report.data[3] = (char)((RX2 & 0xFF00) >> 8); // Return Data High Byte
+ send_report.data[4] = (char)(RX2 & 0x00FF); // Return Data Low Byte
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case WRITE_WORD_I2C2: // COMMAND [0x39] - WORD WRITE TO I2C2
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = WRITE_WORD_I2C2; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Device Address
+ send_report.data[2] = recv_report.data[2]; // Echo Register
+ send_report.data[3] = recv_report.data[3]; // Echo HBData
+ send_report.data[4] = recv_report.data[4]; // Echo LBData
+ send_report.data[5] = I2C_Write_Word(0x01, recv_report.data[1], recv_report.data[2], recv_report.data[3], recv_report.data[4]);
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case WRITE_BLOCK_I2C2: // COMMAND [0x3B] - WRITE A BLOCK of DATA (1 to 10 bytes) TO I2C2
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = WRITE_BLOCK_I2C2; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo Device Address
+ send_report.data[2] = recv_report.data[2]; // Echo Register
+ send_report.data[3] = recv_report.data[3]; // Echo Number of Data Bytes
+
+ I2C2_TXDATA[0] = recv_report.data[2]; // Register Address
+
+ for(int n = 0; n < recv_report.data[3]; n++)
+ {
+ I2C2_TXDATA[1 + n] = recv_report.data[4 + n]; // Load TX Buffer with Data
+ }
+
+ I2C_Write_Block(0x01, recv_report.data[1], recv_report.data[3]);
+
+ break;
+*/
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_FUNC_REGS: // COMMAND [0x40] - BLOCK READ OF MAX25430 FUNCTIONAL REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_FUNC_REGS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ for(int i=0;i<63;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, recv_report.data[1], FUNC_REGS[i]);
+ }
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_VENDOR_REGS: // COMMAND [0x41] - BLOCK READ OF MAX25430 VENDOR REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_VENDOR_REGS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ for(int i=0;i<12;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, recv_report.data[1], VENDOR_REGS[i]);
+ }
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_INT_REGS: // COMMAND [0x42] - BLOCK READ OF MAX25430 INTERRUPT REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_INT_REGS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ for(int i=0;i<8;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, recv_report.data[1], INT_REGS[i]);
+ }
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_MASK_REGS: // COMMAND [0x43] - BLOCK READ OF MAX25430 MASK REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_MASK_REGS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ for(int i=0;i<5;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, recv_report.data[1], MASK_REGS[i]);
+ }
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_CTRL_REGS: // COMMAND [0x44] - BLOCK READ OF MAX25430 TCPC CONTROL REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_CTRL_REGS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ for(int i=0;i<5;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, recv_report.data[1], CTRL_REGS[i]);
+ }
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_TAB1_REGS: // COMMAND [0x45] - BLOCK READ OF MAX25430 TAB1 REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_TAB1_REGS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ for(int i=0;i<29;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, recv_report.data[1], TAB1_REGS[i]);
+ }
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_OTP_DATA_REGS: // COMMAND [0x46] - BLOCK READ OF MAX25430 OTP DATA REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_OTP_DATA_REGS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ for(int i=0;i<36;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, recv_report.data[1], OTP_DATA_REGS[i]);
+ }
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_OTP_TEST_CMD_REGS: // COMMAND [0x47] - BLOCK READ OF MAX25430 OTP TEST COMMAND REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_OTP_TEST_CMD_REGS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ for(int i=0;i<16;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, recv_report.data[1], OTP_TEST_CMD_REGS[i]);
+ }
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_OTP_TEST_MODE_REGS: // COMMAND [0x48] - BLOCK READ OF MAX25430 OTP TEST MODE REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_OTP_TEST_MODE_REGS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ for(int i=0;i<23;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, recv_report.data[1], OTP_TEST_MODE_REGS[i]);
+ }
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case GET_OTP_TEST_OVRD_REGS: // COMMAND [0x49] - BLOCK READ OF MAX25430 OTP TEST OVERRIDE REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = GET_OTP_TEST_OVRD_REGS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ for(int i=0;i<13;i++)
+ {
+ send_report.data[2 + i] = I2C_Read_Byte(0x00, recv_report.data[1], OTP_TEST_OVRD_REGS[i]);
+ }
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case OTP_REGS_UNLOCK: // COMMAND [0x4A] - UNLOCK MAX25430 OTP REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = OTP_REGS_UNLOCK; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ I2C_Write_Register(0x00, recv_report.data[1], 0xC0, 0x12);
+ I2C_Write_Register(0x00, recv_report.data[1], 0xC0, 0x34);
+ I2C_Write_Register(0x00, recv_report.data[1], 0xC0, 0xFA);
+ I2C_Write_Register(0x00, recv_report.data[1], 0xC0, 0xDB);
+
+ send_report.data[2] = 0x01; // Task Complete
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case OTP_REGS_LOCK: // COMMAND [0x4B] - LOCK MAX25430 OTP REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = OTP_REGS_LOCK; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ I2C_Write_Register(0x00, recv_report.data[1], 0xC0, 0x00);
+ I2C_Write_Register(0x00, recv_report.data[1], 0xC0, 0x00);
+ I2C_Write_Register(0x00, recv_report.data[1], 0xC0, 0x00);
+ I2C_Write_Register(0x00, recv_report.data[1], 0xC0, 0x00);
+
+ send_report.data[2] = 0x01; // Task Complete
+
+ break;
+ //-----------------------------------------------------------------------------------------------------------------
+ case CLEAR_INTS: // COMMAND [0xF2] - CLEAR ALL MAX25430 INTERRUPT REGISTERS
+ //-----------------------------------------------------------------------------------------------------------------
+ send_report.data[0] = CLEAR_INTS; // Echo Command
+ send_report.data[1] = recv_report.data[1]; // Echo I2C Device Address
+
+ I2C_Write_Register(0x00, recv_report.data[1], 0x10, 0xFF); // ALERT STATUS LB
+ I2C_Write_Register(0x00, recv_report.data[1], 0x11, 0xA7); // ALERT STATUS HB
+ I2C_Write_Register(0x00, recv_report.data[1], 0x1F, 0xFF); // FAULT STATUS
+
+ send_report.data[2] = 0x55; // Task Complete
+
+ break;
+
+ default:
+ break;
+ }// End Switch - Command Interpretor
+
+ //Send the report
+ hid.send(&send_report);
+ }// End If - HID Message
+ }// End Main While Loop
+}// End Main
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/max32625pico.lib Thu Jun 25 17:25:24 2020 +0000 @@ -0,0 +1,1 @@ +https://developer.mbed.org/users/switches/code/max32625pico/#65bda25808e4
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed-os.lib Thu Jun 25 17:25:24 2020 +0000 @@ -0,0 +1,1 @@ +https://github.com/ARMmbed/mbed-os/#ecb3c8c837162c73537bd0f3592c6e2a42994045