def SD_setup(self, spi, cs):

        sd = None
        # setup SD card
        try:
            sd = SDCard(spi, Pin(cs))
        except Exception as e:
            print('Error in SDCard()!!')
            print(e)
            return None
        else:
            print('SD OK')

        # mount sd volume
        utime.sleep(0.1)
        uos.mount(sd, '/sd')
        utime.sleep(0.1)
        uos.listdir('/sd')
        #utime.sleep(0.1)
        #ls('/sd')
        return sd
#classmachine.SDCard(slot=1, width=1, cd=None, wp=None, sck=None, miso=None, mosi=None, cs=None)
#SDCard(slot=1, width=1, cd=None, wp=None, sck=None, miso=None, mosi=None, cs=None)
Acelx = I2C(scl=Pin(22), sda=Pin(21), freq=100000)
Acelx.writeto_mem(MMA8254Q_ADDR, 0x2A, b'\x00')
Acelx.writeto_mem(MMA8254Q_ADDR, 0x2A, b'\x01')
Acelx.writeto_mem(MMA8254Q_ADDR, 0x0E, b'\x00')
Acelx.writeto_mem(MMA8254Q_ADDR, 0x0F, b'\x30')

#SD1 = SPI(1, 1000000, sck=Pin(18), mosi=Pin(23), miso=Pin(19))
SD1 = SPI(1, 10000000, sck=Pin(14), mosi=Pin(13), miso=Pin(32))

sleep_ms(500)
SD1.init()  # Ensure right baudrate
#sd = SDCard(SD1,Pin(05)) # Compatible with PCB
sd = SDCard(SD1, Pin(27))
vfs = os.VfsFat(sd)
os.mount(vfs, '/fc')

in_xAcc1 = 0
in_yAcc1 = 0
in_zAcc1 = 0

xAcc1 = 0
yAcc1 = 0
zAcc1 = 0

in_in_xAcc1 = 0
in_in_yAcc1 = 0
in_in_zAcc1 = 0
예제 #3
0
def mnt():
    cs = Pin("P22", mode=Pin.OUT)
    sd = SDCard(SPI(0), cs)
    os.mount(sd, '/')
예제 #4
0
mch = os.uname().machine
if 'PCA10028' in mch:
    sck = Pin.board.P29
    miso = Pin.board.P28
    mosi = Pin.board.P25
    cs = Pin.board.P16
elif 'PCA10040' in mch:
    sck = Pin.board.P25
    miso = Pin.board.P24
    mosi = Pin.board.P23
    cs = Pin.board.P15
elif 'PCA10056' in mch:
    sck = Pin.board.P47
    mosi = Pin.board.P45
    miso = Pin.board.P46
    cs = Pin.board.P37  # P1.05
elif 'PCA10090' in mch:
    sck = Pin.board.P13
    miso = Pin.board.P12
    mosi = Pin.board.P11
    cs = Pin.board.P4
else:
    raise Exception('Board not supported!')

spi = SPI(1, sck=sck, mosi=mosi, miso=miso)
sd = SDCard(spi, cs)

os.mount(sd, '/')
print('testfile.txt' in os.listdir())
print([open("testfile.txt", "r").read()])
예제 #5
0
    def __init__(self, parent, wparent, reprap, prtName):
        self.parent = parent
        self.wparent = wparent
        self.log = self.parent.log
        self.history = wparent.history
        self.reprap = reprap
        self.settings = self.parent.settings
        self.images = self.parent.images
        self.state = PrintState.idle
        self.oldState = None
        self.gcodeLoaded = False
        self.gcodeFile = None
        self.printerName = prtName
        self.layerMap = []
        self.okToImport = False
        self.importFile = None

        self.currentLayer = 0
        self.maxTool = 0
        self.eUsed = [0.0, 0.0, 0.0, 0.0]
        self.totalTime = 0
        self.totalTimeStr = ""
        self.layerTimes = []
        self.layerTimeStr = []
        self.layerRange = (0, 0)

        self.gObj = None
        self.printLayer = 0
        self.printPosition = None

        title = self.buildTitle()
        wx.Frame.__init__(self, wparent, wx.ID_ANY, title=title)
        self.Show()
        ico = wx.Icon(os.path.join(cmdFolder, "images", "printmon.png"),
                      wx.BITMAP_TYPE_PNG)
        self.SetIcon(ico)

        if self.settings.hassdcard:
            self.sdcard = SDCard(self.parent, self, self.reprap, self.log)
        else:
            self.sdcard = None

        self.gcf = GcFrame(self, self.gObj, self.settings)
        self.stLayerText = wx.StaticText(self, wx.ID_ANY,
                                         "Layer Height:   0.00")

        ht = self.gcf.GetSize().Get()[1] - BUTTONDIM[1] * 2 - 20

        self.slLayers = wx.Slider(self,
                                  wx.ID_ANY,
                                  0,
                                  0,
                                  1000,
                                  size=(-1, ht),
                                  style=wx.SL_VERTICAL | wx.SL_AUTOTICKS
                                  | wx.SL_LABELS | wx.SL_INVERSE)
        self.Bind(wx.EVT_SCROLL, self.onLayerScroll, self.slLayers)
        self.slLayers.Enable(False)

        self.cbShowMoves = wx.CheckBox(self, wx.ID_ANY, "Show moves")
        self.cbShowMoves.SetValue(self.settings.showmoves)
        self.Bind(wx.EVT_CHECKBOX, self.onShowMoves, self.cbShowMoves)

        self.cbShowPrevious = wx.CheckBox(self, wx.ID_ANY,
                                          "Show previous layer")
        self.cbShowPrevious.SetValue(self.settings.showprevious)
        self.Bind(wx.EVT_CHECKBOX, self.onShowPrevious, self.cbShowPrevious)

        self.cbToolPathOnly = wx.CheckBox(self, wx.ID_ANY,
                                          "Show tool paths only")
        self.cbToolPathOnly.SetValue(self.settings.toolpathonly)
        self.Bind(wx.EVT_CHECKBOX, self.onToolPathOnly, self.cbToolPathOnly)

        self.cbSyncPrint = wx.CheckBox(self, wx.ID_ANY, "Sync with print")
        self.cbSyncPrint.SetValue(True)
        self.Bind(wx.EVT_CHECKBOX, self.onSyncPrint, self.cbSyncPrint)

        self.bImport = wx.BitmapButton(self,
                                       wx.ID_ANY,
                                       self.images.pngImport,
                                       size=BUTTONDIM)
        self.bImport.SetToolTip("Import G Code file from toolbox")
        self.Bind(wx.EVT_BUTTON, self.onImport, self.bImport)

        self.bImportQ = wx.BitmapButton(self,
                                        wx.ID_ANY,
                                        self.images.pngNext,
                                        size=BUTTONDIM)
        self.Bind(wx.EVT_BUTTON, self.onImportFromQueue, self.bImportQ)

        self.bOpen = wx.BitmapButton(self,
                                     wx.ID_ANY,
                                     self.images.pngFileopen,
                                     size=BUTTONDIM)
        self.bOpen.SetToolTip("Open a G Code file")
        self.Bind(wx.EVT_BUTTON, self.onOpenFile, self.bOpen)

        self.Bind(wx.EVT_CLOSE, self.onClose)

        self.bPrint = PrintButton(self, self.images)
        self.bPrint.Enable(False)
        self.Bind(wx.EVT_BUTTON, self.onPrint, self.bPrint)

        self.bPause = PauseButton(self, self.images)
        self.bPause.Enable(False)
        self.Bind(wx.EVT_BUTTON, self.onPause, self.bPause)

        self.bSdPrintTo = wx.BitmapButton(self,
                                          wx.ID_ANY,
                                          self.images.pngSdprintto,
                                          size=(BUTTONDIMWIDE))
        self.bSdPrintTo.Enable(False)
        self.Bind(wx.EVT_BUTTON, self.onSdPrintTo, self.bSdPrintTo)

        self.bSdPrintFrom = wx.BitmapButton(self,
                                            wx.ID_ANY,
                                            self.images.pngSdprintfrom,
                                            size=(BUTTONDIMWIDE))
        self.bSdPrintFrom.Enable(False)
        self.Bind(wx.EVT_BUTTON, self.onSdPrintFrom, self.bSdPrintFrom)

        self.bSdDelete = wx.BitmapButton(self,
                                         wx.ID_ANY,
                                         self.images.pngSddelete,
                                         size=(BUTTONDIM))
        self.bSdDelete.Enable(False)
        self.Bind(wx.EVT_BUTTON, self.onSdDelete, self.bSdDelete)

        self.bUp = wx.BitmapButton(self,
                                   wx.ID_ANY,
                                   self.images.pngUp,
                                   size=BUTTONDIM)
        self.bUp.SetToolTip("Move up one layer")
        self.Bind(wx.EVT_BUTTON, self.onUp, self.bUp)
        self.bUp.Enable(False)

        self.bDown = wx.BitmapButton(self,
                                     wx.ID_ANY,
                                     self.images.pngDown,
                                     size=BUTTONDIM)
        self.bDown.SetToolTip("Move down one layer")
        self.Bind(wx.EVT_BUTTON, self.onDown, self.bDown)
        self.bDown.Enable(False)

        szGcf = wx.BoxSizer(wx.HORIZONTAL)
        szGcf.AddSpacer(10)
        szGcf.Add(self.gcf)
        szGcf.Add(self.stLayerText, 1, wx.ALIGN_CENTER_HORIZONTAL, 1)
        szGcf.AddSpacer(10)

        szNav = wx.BoxSizer(wx.VERTICAL)
        szNav.Add(self.bUp, 1, wx.ALIGN_CENTER_HORIZONTAL, 1)
        szNav.AddSpacer(10)
        szNav.Add(self.slLayers)
        szNav.AddSpacer(10)
        szNav.Add(self.bDown, 1, wx.ALIGN_CENTER_HORIZONTAL, 1)

        szGcf.Add(szNav)
        szGcf.AddSpacer(10)

        szOpts = wx.BoxSizer(wx.HORIZONTAL)
        szOpts.AddSpacer(10)
        szOpts.Add(self.cbShowMoves)
        szOpts.AddSpacer(10)
        szOpts.Add(self.cbShowPrevious)
        szOpts.AddSpacer(10)
        szOpts.Add(self.cbToolPathOnly)
        szOpts.AddSpacer(10)
        szOpts.Add(self.cbSyncPrint)
        szOpts.AddSpacer(10)

        szBtn = wx.BoxSizer(wx.HORIZONTAL)
        szBtn.AddSpacer(10)
        szBtn.Add(self.bImport)
        szBtn.AddSpacer(10)
        szBtn.Add(self.bImportQ)
        szBtn.AddSpacer(10)
        szBtn.Add(self.bOpen)
        szBtn.AddSpacer(20)
        szBtn.Add(self.bPrint)
        szBtn.AddSpacer(10)
        szBtn.Add(self.bPause)
        if self.sdcard:
            szBtn.AddSpacer(20)
            szBtn.Add(self.bSdPrintTo)
            szBtn.AddSpacer(10)
            szBtn.Add(self.bSdPrintFrom)
            szBtn.AddSpacer(10)
            szBtn.Add(self.bSdDelete)

        szBtn.AddSpacer(10)

        szDlg = wx.BoxSizer(wx.VERTICAL)
        szDlg.AddSpacer(10)
        szDlg.Add(szGcf)
        szDlg.AddSpacer(10)
        szDlg.Add(szOpts)
        szDlg.AddSpacer(10)
        szDlg.Add(szBtn)
        szDlg.AddSpacer(10)

        self.SetSizer(szDlg)
        self.Fit()
        self.Layout()

        self.propDlg = PropertiesDlg(self, wparent, self.printerName)
        self.propDlg.Show()
        if not self.settings.propposition is None:
            self.propDlg.SetPosition(self.settings.propposition)

        self.enableButtonsByState()
        self.reprap.registerPositionHandler(self.updatePrintPosition)
        self.reprap.registerEventHandler(self.reprapEvent)
        self.reprap.registerSdEventHandler(self.sdcard)
예제 #6
0
def mount_tf(self, mount_point="/"):
    sd = SDCard(SPI(0), Pin("A15", mode=Pin.OUT))
    os.mount(sd, mount_point)