Changeset 224 for rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/libraries

Timestamp:

Apr 30, 2016, 11:29:25 PM (8 years ago)

Author:

ertl-honda

Message:

1.7.10のファイルに更新

Location:

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/libraries

Files:

• EnergySaving (added)
• EnergySaving/examples (added)
• EnergySaving/examples/TianMIPSAndMCUOnOff (added)
• EnergySaving/examples/TianMIPSAndMCUOnOff/TianMIPSAndMCUOnOff.ino (added)
• EnergySaving/examples/TianMIPSOnOff (added)
• EnergySaving/examples/TianMIPSOnOff/TianMIPSOnOff.ino (added)
• EnergySaving/examples/WakeUpOnExternalInterrupt (added)
• EnergySaving/examples/WakeUpOnExternalInterrupt/WakeUpOnExternalInterrupt.ino (added)
• EnergySaving/examples/WakeUpOnRTCInterrupt (added)
• EnergySaving/examples/WakeUpOnRTCInterrupt/WakeUpOnRTCInterrupt.ino (added)
• EnergySaving/keywords.txt (added)
• EnergySaving/library.properties (added)
• EnergySaving/src (added)
• EnergySaving/src/EnergySaving.cpp (added)
• EnergySaving/src/EnergySaving.h (added)
• SPI/SPI.cpp (modified) (4 diffs)
• SPI/SPI.h (modified) (4 diffs)

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/libraries/SPI/SPI.cpp

@@ -13 +13 @@
 #include "assert.h"
 #include "variant.h"
+#include <Arduino.h>
 
 SPIClass::SPIClass(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint8_t uc_pinMOSI)
@@ -38 +39 @@
 }
 
+
+void SPIClass::beginSlave()
+{
+  // PIO init
+  pinPeripheral(_uc_pinMiso, g_APinDescription[_uc_pinMiso].ulPinType);
+  pinPeripheral(_uc_pinSCK, g_APinDescription[_uc_pinSCK].ulPinType);
+  pinPeripheral(_uc_pinMosi, g_APinDescription[_uc_pinMosi].ulPinType);
+
+        // Default speed set to 4Mhz, SPI mode set to MODE 0 and Bit order set to MSB first.
+        _p_sercom->initSPIslave(SPI_PAD_2_SCK_3, SERCOM_RX_PAD_0, SPI_CHAR_SIZE_8_BITS, MSB_FIRST);
+        
+        _p_sercom->enableSPI();
+}
+
 void SPIClass::end()
 {
         _p_sercom->resetSPI();
 }
+
+
+void SPIClass::beginTransaction(SPISettings settings)
+        {
+                SercomDataOrder bitOrder;
+                SercomSpiClockMode SpiClockMode;
+                
+                interruptSave = intStatus();
+                noInterrupts();
+                
+        
+                if(settings.bit_order==LSBFIRST) bitOrder = LSB_FIRST;
+                else if(settings.bit_order==MSBFIRST) bitOrder = MSB_FIRST;
+                else;
+                
+                if(settings.data_mode==SPI_MODE0) SpiClockMode = SERCOM_SPI_MODE_0;
+                else if(settings.data_mode==SPI_MODE1) SpiClockMode = SERCOM_SPI_MODE_1;
+                else if(settings.data_mode==SPI_MODE2) SpiClockMode = SERCOM_SPI_MODE_2;
+                else if(settings.data_mode==SPI_MODE3) SpiClockMode = SERCOM_SPI_MODE_3;
+                else;
+                
+                end();
+                
+                pinPeripheral(_uc_pinMiso, g_APinDescription[_uc_pinMiso].ulPinType);
+                pinPeripheral(_uc_pinSCK, g_APinDescription[_uc_pinSCK].ulPinType);
+                pinPeripheral(_uc_pinMosi, g_APinDescription[_uc_pinMosi].ulPinType);
+                
+                _p_sercom->initSPI(SPI_PAD_2_SCK_3, SERCOM_RX_PAD_0, SPI_CHAR_SIZE_8_BITS, bitOrder);
+                _p_sercom->initSPIClock(SpiClockMode, settings.interface_clock);
+        
+        _p_sercom->enableSPI();
+        inTransactionFlag=1;
+        }
+        
+void SPIClass::endTransaction(void)
+{
+        inTransactionFlag=0;
+        interrupts();
+}       
 
 void SPIClass::setBitOrder(BitOrder order)
@@ -76 +130 @@
 }
 
-void SPIClass::setClockDivider(uint8_t div)
+void SPIClass::setClockDivider(uint16_t div)
 {
         _p_sercom->setBaudrateSPI(div);
@@ -90 +144 @@
 }
 
+byte SPIClass::read()
+{
+        return _p_sercom->readDataSPI();
+}
+
+void SPIClass::usingInterrupt(uint8_t intNum)
+{
+        uint8_t irestore;
+        uint32_t mask;
+        
+        irestore=intStatus();
+        noInterrupts();
+        if(intNum > 13)
+        {
+                //Interrupts();
+                return;
+        }
+        else
+        {
+                //Pio *pio=g_APinDescription[intNum].ulPort;
+                mask=g_APinDescription[intNum].ulPin;
+                interruptMode=1;
+                interruptMask=mask;
+        }
+        if (irestore) interrupts();             
+}
+
+void SPIClass::write(uint8_t data)
+{
+        //Writing the data
+        _p_sercom->writeDataSPI(data);
+}
+
+void SPIClass::transfer(void *data, size_t count)
+{
+        uint8_t *p;
+        //int i=0;
+                //Serial.println("dentro transfer");
+        if(count==0) return;
+        p=(uint8_t *)data;
+        _p_sercom->writeDataSPI(*p);  //scrittura primo dato
+        
+        while(--count > 0)
+        {
+                //Serial.println("dentro while");
+                uint8_t out=*(p+1); //copio in out il prossimo dato
+                uint8_t in = _p_sercom->readDataSPI();  //leggo dato da SPI
+                //Serial.println("UNO");
+                //while(!(SERCOM4->SPI.INTFLAG.bit.RXC));  // controllo trasferimento  //vedere se necessario
+                //Serial.println("DUE");
+                //Serial.println(out);
+                _p_sercom->writeDataSPI(out);   //scrivo il out su SPI
+                *p++=in; //metto in p il dato letto da spi
+        }
+        while(!(SERCOM4->SPI.INTFLAG.bit.TXC));  // controllo trasferimrnto
+        //Serial.print("*p: ");
+        //Serial.println(*p);
+        *p = _p_sercom->readDataSPI();
+        
+        
+                
+}
+
+uint16_t SPIClass::transfer16(uint16_t data)
+{
+        union{
+                uint16_t value;
+                struct{
+                        uint8_t lsb;
+                        uint8_t msb;
+                };
+        }in, out;
+        
+        in.value = data;
+        
+        if(SERCOM4->SPI.CTRLA.bit.DORD==0)
+        {
+                _p_sercom->writeDataSPI(in.msb);
+                while(!(SERCOM4->SPI.INTFLAG.bit.TXC));
+                out.msb = _p_sercom->readDataSPI();
+                //while(!(SERCOM4->SPI.INTFLAG.bit.RXC)); 
+                _p_sercom->writeDataSPI(in.lsb);
+                while(!(SERCOM4->SPI.INTFLAG.bit.TXC));
+                out.lsb = _p_sercom->readDataSPI();
+        }
+
+        else
+        {
+                _p_sercom->writeDataSPI(in.lsb);
+                while(!(SERCOM4->SPI.INTFLAG.bit.TXC));
+                out.lsb = _p_sercom->readDataSPI();
+                //while(!(SERCOM4->SPI.INTFLAG.bit.RXC)); 
+                _p_sercom->writeDataSPI(in.msb);
+                while(!(SERCOM4->SPI.INTFLAG.bit.TXC));
+                out.msb = _p_sercom->readDataSPI();
+        }
+
+                return out.value;
+}
+
 void SPIClass::attachInterrupt() {
         // Should be enableInterrupt()

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/libraries/SPI/SPI.h

@@ -14 +14 @@
 #include "variant.h"
 #include "wiring_constants.h"
+#include <Arduino.h>
+ 
+//#define LSBFIRST 0 //already defined in wiring_constants.h
+//#define MSBFIRST 1 
 
 #define SPI_MODE0 0x02
@@ -20 +24 @@
 #define SPI_MODE3 0x01
 
+
+#define SPI_CLOCK_DIV2 6       //8 MHz
+#define SPI_CLOCK_DIV4 12      //4 MHz
+#define SPI_CLOCK_DIV8 24      //2 MHz
+#define SPI_CLOCK_DIV16 48     //1 MHz
+#define SPI_CLOCK_DIV32 96     //500 KHz
+#define SPI_CLOCK_DIV64 192    //250 KHz
+#define SPI_CLOCK_DIV128 384   //125 KHz
+
+#ifndef intStatus
+#define intStatus() __intStatus()
+static inline unsigned char __intStatus(void) __attribute__((always_inline, unused));
+static inline unsigned char __intStatus(void) {
+        unsigned int primask, faultmask;
+        asm volatile ("mrs %0, primask" : "=r" (primask));
+        if (primask) return 0;
+        asm volatile ("mrs %0, faultmask" : "=r" (faultmask));
+        if (faultmask) return 0;
+        return 1;
+}
+#endif
+
+class SPISettings {
+        public:
+                SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode)
+                {
+                        interface_clock = clock;
+                        bit_order = bitOrder;
+                        data_mode = dataMode;
+                        
+                        /*Serial.print("clock: ");
+                        Serial.println(interface_clock);
+                        Serial.print("bit order: ");
+                        Serial.println(bit_order);
+                        Serial.print("data mode: ");
+                        Serial.println(data_mode);*/
+                }
+                
+                SPISettings(void)
+                {
+                        interface_clock = 4000000;
+                        bit_order = MSBFIRST;
+                        data_mode = SPI_MODE0;
+                        
+                        /*Serial.print("clock: ");
+                        Serial.println(interface_clock);
+                        Serial.print("bit order: ");
+                        Serial.println(bit_order);
+                        Serial.print("data mode: ");
+                        Serial.println(data_mode);*/
+                }
+        private:
+                uint32_t interface_clock;
+                uint8_t bit_order;
+                uint8_t data_mode;
+        
+        friend class SPIClass;  
+};
+
+
 class SPIClass {
   public:
@@ -25 +89 @@
 
         byte transfer(uint8_t data);
-
+        void transfer(void *data, size_t count);
+        byte read(void);
+        uint16_t transfer16(uint16_t data);
+        void write(uint8_t data);
         // SPI Configuration methods
+        void beginTransaction(SPISettings settings);
+        void endTransaction(void);
+        
         void attachInterrupt();
         void detachInterrupt();
+        
+        void usingInterrupt(uint8_t interruptNumber);
 
         void begin();
+        void beginSlave();
         void end();
         
         void setBitOrder(BitOrder order);
         void setDataMode(uint8_t uc_mode);
-        void setClockDivider(uint8_t uc_div);
+        void setClockDivider(uint16_t uc_div);
 
   private:
@@ -42 +115 @@
         uint8_t _uc_pinMosi;
         uint8_t _uc_pinSCK;
+        uint8_t interruptMode;
+        uint32_t interruptMask;
+        uint8_t interruptSave;
+        uint8_t inTransactionFlag;
 };