Merge pull request #51 from per1234/output-recipes

Add output recipes

README.md

@@ -1,19 +1,23 @@
 DigistumpArduino
 ================
 
-Files to add Digistump support (Digispark, Pro, DigiX) to Arduino 1.5.X (1.5.7+)
+Files to add Digistump support (Digispark, Pro, DigiX) to Arduino 1.6.X (1.6.4+)
 
+**These files are designed for install via the Arduino Boards Manager:** 
 
-**Binary downloads of the bundled IDE can be found here:** https://github.com/digistump/DigistumpArduino/releases/tag/v1.5.8A
+Board manager URL: http://digistump.com/package_digistump_index.json
 
-To manually install:
+**Full Install Instructions:** 
 
-Place digistump folder inside the Arduino /hardware folder.
+Digispark: http://digistump.com/wiki/digispark/tutorials/connecting
 
-To compile tools for other platforms or from scratch use:
+Digispark Pro: http://digistump.com/wiki/digispark/tutorials/connectingpro
+
+DigiX: http://digistump.com/wiki/digix/tutorials/software
+
+**To compile:**
+
+Micronucleus is the only executable in these packages that is pre-compiled:
 
 Micronucleus: https://github.com/micronucleus/micronucleus/tree/80419704f68bf0783c5de63a6a4b9d89b45235c7
-
+Dependencies: libusb and possibly lib32stdc on linux - (on ubuntu get it by issuing: apt-get install lib32stdc++6)
-AVR-Dummy: https://github.com/digistump/avr-dummy
-
-ld from a more recent install of avr-gcc then Arduino uses

digistump-avr/boards.txt

@@ -62,4 +62,46 @@ digispark-pro64.build.core=pro
 digispark-pro64.build.variant=pro64buffer
 digispark-pro64.upload.wait_for_upload_port = false
 digispark-pro64.upload.use_1200bps_touch = false
-digispark-pro64.upload.disable_flushing = false
+digispark-pro64.upload.disable_flushing = false
+
+digispark-tiny16.name=Digispark (16mhz - No USB)
+digispark-tiny16.upload.using=micronucleusprog
+digispark-tiny16.upload.protocol=usb
+digispark-tiny16.upload.tool=micronucleus
+digispark-tiny16.upload.maximum_size=6012
+digispark-tiny16.build.mcu=attiny85
+digispark-tiny16.build.f_cpu=16000000L
+digispark-tiny16.build.board=AVR_DIGISPARK
+digispark-tiny16.build.core=tiny
+digispark-tiny16.build.variant=digispark
+digispark-tiny16.upload.wait_for_upload_port = false
+digispark-tiny16.upload.use_1200bps_touch = false
+digispark-tiny16.upload.disable_flushing = false
+
+digispark-tiny8.name=Digispark (8mhz - No USB)
+digispark-tiny8.upload.using=micronucleusprog
+digispark-tiny8.upload.protocol=usb
+digispark-tiny8.upload.tool=micronucleus
+digispark-tiny8.upload.maximum_size=6012
+digispark-tiny8.build.mcu=attiny85
+digispark-tiny8.build.f_cpu=8000000L
+digispark-tiny8.build.board=AVR_DIGISPARK
+digispark-tiny8.build.core=tiny
+digispark-tiny8.build.variant=digispark
+digispark-tiny8.upload.wait_for_upload_port = false
+digispark-tiny8.upload.use_1200bps_touch = false
+digispark-tiny8.upload.disable_flushing = false
+
+digispark-tiny1.name=Digispark (1mhz - No USB)
+digispark-tiny1.upload.using=micronucleusprog
+digispark-tiny1.upload.protocol=usb
+digispark-tiny1.upload.tool=micronucleus
+digispark-tiny1.upload.maximum_size=6012
+digispark-tiny1.build.mcu=attiny85
+digispark-tiny1.build.f_cpu=1000000L
+digispark-tiny1.build.board=AVR_DIGISPARK
+digispark-tiny1.build.core=tiny
+digispark-tiny1.build.variant=digispark
+digispark-tiny1.upload.wait_for_upload_port = false
+digispark-tiny1.upload.use_1200bps_touch = false
+digispark-tiny1.upload.disable_flushing = false

digistump-avr/cores/pro/Arduino.h

@@ -103,6 +103,11 @@ int digitalRead(uint8_t);
 int analogRead(uint8_t);
 void analogReference(uint8_t mode);
 void analogWrite(uint8_t, int);
+void pwmWrite(uint8_t, int);
+void pwmConnect(uint8_t);
+void pwmDisconnect(uint8_t);
+void pwmReset(void);
+
 
 unsigned long millis(void);
 unsigned long micros(void);
@@ -160,6 +165,9 @@ extern const uint8_t PROGMEM digital_pin_to_timer_PGM[];
 #define TIMER1B 4
 #define TIMER1D 5
 
+#define CHANNELA 3 //TIMER1A
+#define CHANNELB 4 //TIMER1B
+
 #include "pins_arduino.h"
 
 #ifndef USE_SOFTWARE_SERIAL

digistump-avr/cores/pro/wiring_analog.c

@@ -45,6 +45,8 @@ void analogReference(uint8_t mode)
   analog_reference = mode;
 }
 
+
+
 int analogRead(uint8_t pin)
 {
   #if defined( NUM_DIGITAL_PINS )
@@ -83,6 +85,80 @@ int analogRead(uint8_t pin)
   return LOW;
   #endif
 }
+
+void pwmReset()
+{
+  cbi(TCCR1D, OC1AV);
+  cbi(TCCR1D, OC1AU);
+  cbi(TCCR1D, OC1AW);
+  cbi(TCCR1D, OC1AX);
+  cbi(TCCR1D, OC1BV);
+  cbi(TCCR1D, OC1BU);
+  cbi(TCCR1D, OC1BW);
+  cbi(TCCR1D, OC1BX);
+}
+void pwmWrite(uint8_t channel, int val)
+{
+  if( channel == TIMER1A){
+    // connect pwm to pin on timer 1, channel A
+    sbi(TCCR1A, COM1A1);
+    sbi(TCCR1A, WGM10);
+    cbi(TCCR1A, COM1A0);
+    sbi(TCCR1B, WGM10);
+    sbi(TCCR1B, CS11);
+    //sbi(TCCR1B, CS10);
+    OCR1A = val; // set pwm duty
+  } else if( channel == TIMER1B){
+    // connect pwm to pin on timer 1, channel B
+    sbi(TCCR1A, COM1B1);
+    sbi(TCCR1A, WGM10);
+    cbi(TCCR1A, COM1B0);
+    sbi(TCCR1B, WGM10);
+    sbi(TCCR1B, CS11);
+    //sbi(TCCR1B, CS10);
+    OCR1B = val; // set pwm duty
+  } 
+}
+
+void pwmConnect(uint8_t pin)
+{
+  pinMode(pin,OUTPUT);
+  if(pin == 2)
+    sbi(TCCR1D, OC1AV);
+  else if(pin == 0)
+    sbi(TCCR1D, OC1AU);
+  //  cbi(TCCR1D, OC1AW);//used by crystal
+  else if(pin == 3)
+    sbi(TCCR1D, OC1AX);
+  else if(pin == 4)
+    sbi(TCCR1D, OC1BV);
+  else if(pin == 1)
+    sbi(TCCR1D, OC1BU);
+  //  cbi(TCCR1D, OC1BW);//used by crystal
+  //  sbi(TCCR1D, OC1BX);//reset pin
+
+}
+void pwmDisconnect(uint8_t pin)
+{
+  pinMode(pin,OUTPUT);
+  if(pin == 2)
+    cbi(TCCR1D, OC1AV);
+  else if(pin == 0)
+    cbi(TCCR1D, OC1AU);
+  //  cbi(TCCR1D, OC1AW);//used by crystal
+  else if(pin == 3)
+    cbi(TCCR1D, OC1AX);
+  else if(pin == 4)
+    cbi(TCCR1D, OC1BV);
+  else if(pin == 1)
+    cbi(TCCR1D, OC1BU);
+  //  cbi(TCCR1D, OC1BW);//used by crystal
+  //  cbi(TCCR1D, OC1BX);//reset pin
+
+}
+
+
+
 // Right now, PWM output only works on the pins with
 // hardware support.  These are defined in the appropriate
 // pins_*.c file.  For the rest of the pins, we default
@@ -109,15 +185,15 @@ void analogWrite(uint8_t pin, int val)
     uint8_t timer = digitalPinToTimer(pin);
 
 
-/*
-	if( timer == TIMER0B){
-		// connect pwm to pin on timer 0, channel B
-		sbi(TCCR0A, COM0B1);
-		cbi(TCCR0A, COM0B0);
-		OCR0B = val; // set pwm duty
-	} else
-*/
 
+	if( timer == TIMER0A){
+		// connect pwm to pin 8 on timer 0, channel A
+		sbi(TCCR0A, COM0A1);
+		cbi(TCCR0A, COM0A0);
+    sbi(TCCR0A, WGM01);
+    sbi(TCCR0A, WGM00);
+		OCR0A = val; // set pwm duty
+	} else
 
 	if( timer == TIMER1A){
 		// connect pwm to pin on timer 1, channel A
@@ -129,10 +205,19 @@ void analogWrite(uint8_t pin, int val)
 		//sbi(TCCR1B, CS10);
 
 		cbi(TCCR1D, OC1AV);
-		sbi(TCCR1D, OC1AU);
+		cbi(TCCR1D, OC1AU);
 		cbi(TCCR1D, OC1AW);
 		cbi(TCCR1D, OC1AX);
 
+    if(pin == 2)
+      sbi(TCCR1D, OC1AV);
+    else if(pin == 0)
+      sbi(TCCR1D, OC1AU);
+    else if(pin == 3)
+      sbi(TCCR1D, OC1AX);
+
+
+
 		OCR1A = val; // set pwm duty
 	} else
 
@@ -150,16 +235,17 @@ void analogWrite(uint8_t pin, int val)
     //sbi(TCCR1B, CS10);
 
 		cbi(TCCR1D, OC1BV);
-		sbi(TCCR1D, OC1BU);
+		cbi(TCCR1D, OC1BU);
 		cbi(TCCR1D, OC1BW);
 		cbi(TCCR1D, OC1BX);
+    
+    if(pin == 4)
+      sbi(TCCR1D, OC1BV);
+    else if(pin == 1)
+      sbi(TCCR1D, OC1BU);
 
 		OCR1B = val; // set pwm duty
 	} else
-
-
-
-	
     {
       if (val < 128)
       {

digistump-avr/cores/tiny/new.cpp

@@ -0,0 +1,18 @@
+#include <new.h>
+
+void * operator new(size_t size)
+{
+  return malloc(size);
+}
+
+void operator delete(void * ptr)
+{
+  free(ptr);
+} 
+
+int __cxa_guard_acquire(__guard *g) {return !*(char *)(g);};
+void __cxa_guard_release (__guard *g) {*(char *)g = 1;};
+void __cxa_guard_abort (__guard *) {}; 
+
+void __cxa_pure_virtual(void) {};
+

digistump-avr/cores/tiny/new.h

@@ -0,0 +1,22 @@
+/* Header to define new/delete operators as they aren't provided by avr-gcc by default
+   Taken from http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=59453 
+ */
+
+#ifndef NEW_H
+#define NEW_H
+
+#include <stdlib.h>
+
+void * operator new(size_t size);
+void operator delete(void * ptr); 
+
+__extension__ typedef int __guard __attribute__((mode (__DI__)));
+
+extern "C" int __cxa_guard_acquire(__guard *);
+extern "C" void __cxa_guard_release (__guard *);
+extern "C" void __cxa_guard_abort (__guard *); 
+
+extern "C" void __cxa_pure_virtual(void);
+
+#endif
+

digistump-avr/cores/tiny/wiring.h

@@ -43,6 +43,7 @@ extern "C"{
 
 #define INPUT 0x0
 #define OUTPUT 0x1
+#define INPUT_PULLUP 0x2
 
 #define true 0x1
 #define false 0x0

digistump-avr/cores/tiny/wiring_digital.c

@@ -35,21 +35,28 @@ void pinMode(uint8_t pin, uint8_t mode)
 {
 	uint8_t bit = digitalPinToBitMask(pin);
 	uint8_t port = digitalPinToPort(pin);
-	volatile uint8_t *reg;
+	volatile uint8_t *reg, *out;
 
 	if (port == NOT_A_PIN) return;
 
 	// JWS: can I let the optimizer do this?
 	reg = portModeRegister(port);
+	out = portOutputRegister(port);
 
 	if (mode == INPUT) { 
 		uint8_t oldSREG = SREG;
-    cli();
+		cli();
 		*reg &= ~bit;
 		SREG = oldSREG;
+	} else if (mode == INPUT_PULLUP) {
+		uint8_t oldSREG = SREG;
+                cli();
+		*reg &= ~bit;
+		*out |= bit;
+		SREG = oldSREG;
 	} else {
 		uint8_t oldSREG = SREG;
-    cli();
+		cli();
 		*reg |= bit;
 		SREG = oldSREG;
 	}

digistump-avr/libraries/DigisparkCDC/DigiCDC.cpp

@@ -17,7 +17,6 @@ and Digistump LLC (digistump.com)
 uchar              sendEmptyFrame;
 static uchar       intr3Status;    /* used to control interrupt endpoint transmissions */
 
-
 DigiCDCDevice::DigiCDCDevice(void){}
 
 
@@ -40,23 +39,30 @@ void DigiCDCDevice::flush(){
 void DigiCDCDevice::begin(){
 
     usbBegin();
+    DigiCDCDevice::delay(500);//delay to allow enumeration and such
 
 }
-size_t DigiCDCDevice::write(uint8_t chr)
+
+size_t DigiCDCDevice::write(uint8_t c)
 {
     if(RingBuffer_IsFull(&txBuf))
     {
+        refresh();
         return 0;
     }
     else
     {
-        RingBuffer_Insert(&txBuf,chr);
+        RingBuffer_Insert(&txBuf,c);
+        DigiCDCDevice::delay(5); //gives 4.2-4.7ms per character for usb transfer at low speed
         return 1;
     }
+    
+
 }
 
 int DigiCDCDevice::available()
 {
+    refresh();
     return RingBuffer_GetCount(&rxBuf);
 }
 
@@ -64,12 +70,15 @@ int DigiCDCDevice::read()
 {
     if(RingBuffer_IsEmpty(&rxBuf))
     {
+        refresh();
         return 0;
     }
     else
     {
+        refresh();
         return RingBuffer_Remove(&rxBuf);
     }
+   
 }
 
 int DigiCDCDevice::peek()
@@ -82,22 +91,21 @@ int DigiCDCDevice::peek()
     {
         return RingBuffer_Peek(&rxBuf);
     }
+    refresh();
 }
 
 
 void DigiCDCDevice::task(void)
 {    
  
-  usbPollWrapper();
+  refresh();
 
 }
 
 void DigiCDCDevice::refresh(void)
 {    
- 
+  _delay_ms(1);
   usbPollWrapper();
-  
-
 }
 
 
@@ -112,7 +120,7 @@ void DigiCDCDevice::end(void)
 }
 
 DigiCDCDevice::operator bool() {
-    usbPollWrapper();
+    refresh();
     return true;
 }
 
@@ -377,4 +385,4 @@ void usbFunctionWriteOut( uchar *data, uchar len )
 } // extern "C"
 #endif
 
-DigiCDCDevice SerialUSB;
+DigiCDCDevice SerialUSB;

digistump-avr/libraries/DigisparkCDC/DigiCDC.h

@@ -47,10 +47,6 @@ class DigiCDCDevice  : public Stream {
         virtual int read(void);
         virtual void flush(void);
         virtual size_t write(uint8_t);
-        inline size_t write(unsigned long n) { return write((uint8_t)n); }
-        inline size_t write(long n) { return write((uint8_t)n); }
-        inline size_t write(unsigned int n) { return write((uint8_t)n); }
-        inline size_t write(int n) { return write((uint8_t)n); }
         using Print::write;
         operator bool();
     private:
@@ -62,4 +58,4 @@ class DigiCDCDevice  : public Stream {
 extern DigiCDCDevice SerialUSB;
 
 
-#endif // __DigiCDC_h__
+#endif // __DigiCDC_h__

digistump-avr/libraries/DigisparkCDC/examples/CDC_LED/CDC_LED.ino

@@ -0,0 +1,22 @@
+#include <DigiCDC.h>
+void setup() {                
+  // initialize the digital pin as an output.
+  SerialUSB.begin(); 
+  pinMode(1,OUTPUT);
+}
+
+// the loop routine runs over and over again forever:
+void loop() {
+  
+  //turns led on and off based on sending 0 or 1 from serial terminal
+  if (SerialUSB.available()) {
+    char input = SerialUSB.read();
+    if(input == '0')
+      digitalWrite(1,LOW);
+    else if(input == '1')
+      digitalWrite(1,HIGH);
+      
+  }
+  
+   SerialUSB.delay(100);               // keep usb alive // can alos use SerialUSB.refresh();
+}

digistump-avr/libraries/DigisparkCDC/examples/Echo/Echo.ino

@@ -0,0 +1,21 @@
+#include <DigiCDC.h>
+void setup() {                
+  // initialize the digital pin as an output.
+  SerialUSB.begin(); 
+}
+
+// the loop routine runs over and over again forever:
+void loop() {
+  
+  if (SerialUSB.available()) {
+    SerialUSB.write(SerialUSB.read());
+  }
+  
+   //SerialUSB.delay(10);
+   /*
+   if you don't call a SerialUSB function (write, print, read, available, etc) 
+   every 10ms or less then you must throw in some SerialUSB.refresh(); 
+   for the USB to keep alive - also replace your delays - ie. delay(100); 
+   with SerialUSB.delays ie. SerialUSB.delay(100);
+   */
+}

digistump-avr/libraries/DigisparkCDC/examples/Print/Print.ino

@@ -0,0 +1,25 @@
+#include <DigiCDC.h>
+void setup() {                
+  // initialize the digital pin as an output.
+  SerialUSB.begin(); 
+  /*
+  remember the SerialUSB starts as soon as you call begin 
+  and doesn't restart the board when you open the serial monitor 
+  (like the uno does) - so if you print to it and you don't 
+  have a serial monitor open that text is lost.
+  */
+}
+
+// the loop routine runs over and over again forever:
+void loop() {
+  
+  SerialUSB.println(F("TEST!")); //wrap your strings in F() to save ram!
+  
+   //SerialUSB.delay(10);
+   /*
+   if you don't call a SerialUSB function (write, print, read, available, etc) 
+   every 10ms or less then you must throw in some SerialUSB.refresh(); 
+   for the USB to keep alive - also replace your delays - ie. delay(100); 
+   with SerialUSB.delays ie. SerialUSB.delay(100);
+   */
+}