Adding solutions

Author: abaelen

MKR1010_USBIso_Core_v1/CDCIso.cpp

@@ -0,0 +1,140 @@
+/*
+ * CDCIso.cpp
+ *
+ * Created: 23/04/2020 10:34:21
+ * Author: Gebruiker
+ */ 
+
+#include <arduino.h>
+#include "CDCIso.h"
+#include <USB/USBCore.h>
+#include <USB/PluggableUSB.h>
+#include <USB/CDC.h>
+
+CDCIso_::CDCIso_(void) : PluggableUSBModule(2,2,epIsoType)
+{
+epIsoType[0] = USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_IN(0);
+epIsoType[1] = USB_ENDPOINT_TYPE_ISOCHRONOUS | USB_ENDPOINT_IN(0);
+ PluggableUSB().plug(this);
+}
+
+int CDCIso_::getInterface(uint8_t* interfaceNum)
+{
+
+interfaceNum[0] += 1;
+
+epEPNum[0]=pluggedEndpoint;
+epEPNum[1]=pluggedEndpoint+1;
+
+CDCIsoDescriptor _cdcIsoInterface = {
+
+// CDC Iso interface
+D_INTERFACE(uint8_t(pluggedInterface + 1), 2, 0xFF, 0, 0),
+D_ENDPOINT(USB_ENDPOINT_OUT(pluggedEndpoint), USB_ENDPOINT_TYPE_BULK, EPX_SIZE, 0),
+D_ENDPOINT(USB_ENDPOINT_IN (pluggedEndpoint+1), USB_ENDPOINT_TYPE_ISOCHRONOUS, 1023, 1)
+};
+return USBDevice.sendControl(&_cdcIsoInterface, sizeof(_cdcIsoInterface));
+
+}
+
+bool CDCIso_::setup(USBSetup& setup)
+{
+return false;
+}
+
+int CDCIso_::getDescriptor(USBSetup& setup)
+{
+return 0;
+}
+
+void CDCIso_::enableInterrupt() {
+USB->DEVICE.DeviceEndpoint[epEPNum[0]].EPINTENSET.bit.TRCPT0=1; //TO DO CHECK RIGHT BANK?
+USB->DEVICE.DeviceEndpoint[epEPNum[1]].EPINTENSET.bit.TRCPT1=1;
+}
+
+void CDCIso_::handleEndpoint(int ep) {
+if (ep==epEPNum[1]) {
+lenwritebuffer=sizeof(writebuffer);
+write(writebuffer,1023);
+}
+}
+
+size_t CDCIso_::write(const uint8_t *buffer, size_t size)
+{
+uint32_t r = send(epEPNum[1], buffer, size);
+
+if (r > 0) {
+return r;
+} else {
+//setWriteError();
+return 0;
+}
+}
+
+uint32_t CDCIso_::send(uint32_t ep, const void *data, uint32_t len)
+{
+uint32_t written = 0;
+uint32_t length = 0;
+
+if (!usbConfiguration)
+return -1;
+if (len > 16384)
+return -1;
+
+#ifdef PIN_LED_TXL
+if (txLEDPulse == 0)
+digitalWrite(PIN_LED_TXL, LOW);
+
+txLEDPulse = TX_RX_LED_PULSE_MS;
+#endif
+
+// Flash area
+while (len != 0)
+{
+if (USB->DEVICE.DeviceEndpoint[epEPNum[1]].EPSTATUS.bit.BK1RDY) { //USBCore equivalent: usbd.epBank1IsReady(ep) or usb.DeviceEndpoint[ep].EPSTATUS.bit.BK1RDY;
+// previous transfer is still not complete
+// convert the timeout from microseconds to a number of times through
+// the wait loop; it takes (roughly) 23 clock cycles per iteration.
+uint32_t timeout = microsecondsToClockCycles(70 * 1000) / 23; //70msec
+// Wait for (previous) transfer to complete
+// inspired by Paul Stoffregen's work on Teensy
+while (!USB->DEVICE.DeviceEndpoint[epEPNum[1]].EPINTFLAG.bit.TRCPT1) { //USBCore equivalent: usbd.epBank1IsTransferComplete(ep) or usb.DeviceEndpoint[ep].EPINTFLAG.bit.TRCPT1;
+if (LastTransmitTimedOut[1] || timeout-- == 0) {
+LastTransmitTimedOut[1] = 1;
+// set byte count to zero, so that ZLP is sent
+// instead of stale data
+*(EPn_BK1_Addr.b8+0x004) = *(EPn_BK1_Addr.b8+0x004) & (0xFFFFFFF0); //Byte count on position 0 to 7 set to 0 //USBCore equivalent: usbd.epBank1SetByteCount(ep, 0) or EP[ep].DeviceDescBank[1].PCKSIZE.bit.BYTE_COUNT = bc; 
+//return -1;
+}
+}
+}
+
+LastTransmitTimedOut[1] = 0;
+
+if (len >= iso_pcksize) {
+*(EPn_BK1_Addr.b8+0x004) = *(EPn_BK1_Addr.b8+0x004) | (0x1uL << 32); // Auto ZLP on position 31 //USBCore equivalent code: usbd.epBank1EnableAutoZLP(ep) or EP[ep].DeviceDescBank[1].PCKSIZE.bit.AUTO_ZLP = 1
+length = iso_pcksize;
+} else {
+length = len;
+}
+
+/* memcopy could be safer in multi threaded environment */
+memcpy(&databuffer, data, length);
+
+//set Byte count to length of data
+*(uint32_t *) (EPn_BK1_Addr.b8+0x004) = *(uint32_t *) (EPn_BK1_Addr.b8+0x004) | (length); //Byte count on position 0 to 13 set to length //USBCore equivalent: usbd.epBank1SetByteCount(ep, 0) or EP[ep].DeviceDescBank[1].PCKSIZE.bit.BYTE_COUNT = bc; 
+
+// Clear the transfer complete flag
+USB->DEVICE.DeviceEndpoint[epEPNum[1]].EPINTFLAG.reg = ((0x3ul << 0) & (2 << 0));//USBCore equivalent code: usbd.epBank1AckTransferComplete(ep) or usb.DeviceEndpoint[ep].EPINTFLAG.reg = USB_DEVICE_EPINTFLAG_TRCPT(2);
+
+// RAM buffer is full, we can send data (IN)
+USB->DEVICE.DeviceEndpoint[epEPNum[1]].EPSTATUSSET.bit.BK1RDY=1; //USBCore equivalent code: usbd.epBank1SetReady(ep) or usb.DeviceEndpoint[ep].EPSTATUSSET.bit.BK1RDY = 1
+
+written += length;
+len -= length;
+data = (char *)data + length;
+
+}
+
+return written;
+}

MKR1010_USBIso_Core_v1/CDCIso.h

@@ -0,0 +1,67 @@
+/*
+ * CDCIso.h
+ *
+ * Created: 23/04/2020 10:34:00
+ * Author: Gebruiker
+ */ 
+
+
+#ifndef CDCISO_H_
+#define CDCISO_H_
+
+#include <Arduino.h>
+#include <USB/PluggableUSB.h>
+#include <USB/USBCore.h>
+
+
+typedef struct
+{
+//Iso
+InterfaceDescriptor	dif;
+EndpointDescriptor	in;
+EndpointDescriptor	out;
+} CDCIsoDescriptor;
+
+union MemAddr {
+uint32_t* b32;
+uint8_t* b8;
+};
+
+class CDCIso_ : public PluggableUSBModule {
+public:
+CDCIso_(void);
+bool begin(void);
+void enableInterrupt();
+size_t write(const uint8_t *buffer, size_t size);
+
+
+uint8_t writebuffer[1023];
+uint8_t lenwritebuffer;
+uint8_t databuffer[1023];
+
+uint32_t iso_pcksize;
+uint8_t iso_pckcode;
+
+uint32_t usbConfiguration = 0;
+
+uint8_t epEPNum[2];
+USBSetup EP0_BK0;
+uint32_t* ptrEP0_BK0;
+MemAddr EP0_BK0_Addr;
+MemAddr EPn_BK1_Addr;
+
+protected:
+int getInterface(uint8_t* interfaceNum);
+ bool setup(USBSetup& setup);
+int getDescriptor(USBSetup& setup);
+void handleEndpoint(int ep);
+
+private:
+uint32_t epIsoType[2];
+uint32_t send(uint32_t ep, const void *data, uint32_t len);
+
+char LastTransmitTimedOut[2] = {0,0};
+};
+
+
+#endif /* CDCISO_H_ */

MKR1010_USBIso_Core_v1/CDCIso_event.h

@@ -0,0 +1,69 @@
+/*
+ * CDCIso_event.h
+ *
+ * Created: 25/04/2020 2:50:22
+ * Author: Gebruiker
+ */ 
+
+
+
+#include <Arduino.h>
+#include "CDCIso.h"
+#include <USB/SAMD21_USBDevice.h>
+#include <USB/USBAPI.h>
+
+#ifndef CDCISO_EVENT_H_
+#define CDCISO_EVENT_H_
+
+
+
+
+CDCIso_ USBISO;
+
+
+void UDD_Handler_Iso(void) {
+
+if (USB->DEVICE.DeviceEndpoint[0].EPINTFLAG.bit.RXSTP) { //USBCore equivalent code:usbd.epBank0IsSetupReceived(0) or usb.DeviceEndpoint[ep].EPINTFLAG.bit.RXSTP; 
+USBISO.EP0_BK0_Addr.b32=(uint32_t *) (USB->DEVICE.DESCADD.reg);
+//DESCADD contains the address (=> cast to 32 bit adddress) to the pointer that contains (=>request content) the address (cast to 32bit address) to the EP0 BK0 content
+memcpy(&(USBISO.EP0_BK0), (uint32_t *) *((uint32_t *) (USB->DEVICE.DESCADD.reg)), sizeof(USBSetup)); 
+if (REQUEST_STANDARD == (USBISO.EP0_BK0.bmRequestType & REQUEST_TYPE)) {
+switch (USBISO.EP0_BK0.bRequest) {
+case SET_CONFIGURATION:
+if (REQUEST_DEVICE == (USBISO.EP0_BK0.bmRequestType & REQUEST_RECIPIENT)) {
+switch (USBISO.iso_pcksize) { //EP[ep].DeviceDescBank[1].PCKSIZE.bit.SIZE
+case 8:
+USBISO.iso_pckcode = 0x0;
+case 16:
+USBISO.iso_pckcode = 0x01;
+case 32:
+USBISO.iso_pckcode = 0x02;
+case 64:
+USBISO.iso_pckcode = 0x03;
+case 128:
+USBISO.iso_pckcode = 0x04;
+case 256:
+USBISO.iso_pckcode = 0x05;
+case 512:
+USBISO.iso_pckcode = 0x06;
+case 1024:
+USBISO.iso_pckcode = 0x07; //1024 is necessary is the check below is >= and otherwise always AutoZLP!! //TO DO define HS
+}
+USBISO.EPn_BK1_Addr.b8 = USBISO.EP0_BK0_Addr.b8 + 2*0x10*USBISO.epEPNum[1]+0x10; //EPn has offset 2x (0xn0) //BK1 has offset 0x10
+*(USBISO.EPn_BK1_Addr.b32) = (uint32_t) &(USBISO.databuffer); //Set EPn_BK1 32bit content (=> cast to 32bit value) to address of data_iso_buffer; Equivalent to USBCore statement: usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[ep]);
+*(uint32_t *)(USBISO.EPn_BK1_Addr.b8+0x004) = *(uint32_t *) (USBISO.EPn_BK1_Addr.b8+0x004) | ((uint32_t) USBISO.iso_pckcode << 28); //PckSize has offset 0x004; 0x7 on position 28 means 1023bit; Equivalent to USBCore statement: usbd.epBank1SetSize(ep, 1023);
+USB->DEVICE.DeviceEndpoint[USBISO.epEPNum[1]].EPCFG.bit.EPTYPE1 = 2; //0x02 stands for IN Isochronous
+USBISO.usbConfiguration = USBISO.EP0_BK0.wValueL;
+USBISO.enableInterrupt();
+//leave it to the USBCore to handle the other EP's
+}
+}
+}
+}
+USBDevice.ISRHandler();
+
+}
+
+
+
+#endif /* CDCISO_EVENT_H_ */

MKR1010_USBIso_Core_v1/MKR1010_USBIso_Core_v1.ino

@@ -0,0 +1,22 @@
+#include "CDCIso.h"
+#include "CDCIso_event.h"
+
+void setup() {
+ // put your setup code here, to run once:
+ USBISO.iso_pcksize=1024;
+ USB_SetHandler(UDD_Handler_Iso);
+ SerialUSB.print("test");
+ delay(1000);
+ SerialUSB.print("test");
+ delay(1000);
+ for (int i=0; i<1023;i++) {
+ USBISO.writebuffer[i]=0xAA;
+ }
+ USBISO.write(USBISO.writebuffer,1023);
+
+}
+
+void loop() {
+ // put your main code here, to run repeatedly:
+
+}