#!/usr/bin/env python

# -*- coding: utf-8 -*-

import fnmatch

import shutil

import zipfile

import tempfile

from ProjectController import ProjectController

from LPCArch import PLC_module

LPCStatusMethods = [

{"bitmap": "UpdateFw",

"name": _("UpdateFw"),

"shown": True,

"tooltip": _("Update the PLC firmware"),

"method": "_UpdateFw"}

]

class LPCProjectController(ProjectController):

StatusMethods = ProjectController.StatusMethods + LPCStatusMethods

def __init__(self, frame, logger, buildpath, arch):

self.arch = arch

self.OrigBuildPath = buildpath

ProjectController.__init__(self, frame, logger)

# Firmware update running status

self.firmwareUpadateIsRunning = False

def GetProjectName(self):

"""

Beremiz uses project directory name as project name

In LPCManager, project name is given as PLCOpen project name

and is passed at startup by SetProjectProperties command

"""

return self.Project.getname()

def ToZIPFile(self):

# MD5 = self.GetLastBuildMD5()

try:

path_export_file = self.BuildPath[:-5] + "\\" + self._builder.exe[:-3] + ".xEye"

zf = zipfile.ZipFile(path_export_file, mode='w', compression=zipfile.ZIP_DEFLATED)

for extrafilespath in [self._getExtraFilesPath(),

self._getProjectFilesPath()]:

dir = extrafilespath.split("\\")[-1]

for name in os.listdir(extrafilespath):

zf.write(extrafilespath + '\\' + str(name), dir + '\\' + str(name), zipfile.ZIP_DEFLATED)

zf.write(self._builder.exe_path, self._builder.exe)

zf.write(self.BuildPath + '\\lastbuildPLC.md5', 'lastbuildPLC.md5')

zf.close()

self.logger.write(_("Export file is successfully created on location: %s\n") % path_export_file)

except Exception, e:

self.logger.write(_("Export file is not created because eror: %s\n") % e)

def _Build(self):

if self.ProjectTestModified():

self.SaveProject()

self.AppFrame.RefreshAfterSave()

result = ProjectController._Build(self):

if result:

self.ToZIPFile()

return result

def SetProjectName(self, name):

return self.Project.setname(name)

def SetOnlineMode(self, mode, path=None):

# SetOnlineMode is only for MC8

return None

# Update a PLCOpenEditor Pou variable location

def UpdateProjectVariableLocation(self, old_leading, new_leading):

self.Project.updateElementAddress(old_leading, new_leading)

self.BufferProject()

# Update a PLCOpenEditor Pou variable name

def UpdateProjectVariableName(self, old_name, new_name):

self.Project.updateElementName(old_name, new_name)

self.BufferProject()

def RemoveProjectVariableByAddress(self, address):

self.Project.removeVariableByAddress(address)

self.BufferProject()

def RemoveProjectVariableByFilter(self, leading):

self.Project.removeVariableByFilter(leading)

self.BufferProject()

def AddProjectDefaultConfiguration(self, config_name="config", res_name="resource1"):

ProjectController.AddProjectDefaultConfiguration(self, config_name, res_name)

self.SetEditedResourceInfos(

self.ComputeConfigurationResourceName(config_name, res_name),

[{"Name": "main_task",

"Triggering": "Cyclic",

"Interval": "T#50ms",

"Priority": 0}],

[])

# TODO : use the original function

def LoadProject(self, ProjectPath, BuildPath=None):

"""

Load a project contained in a folder

@param ProjectPath: path of the project folder

"""

if os.path.basename(ProjectPath) == "":

ProjectPath = os.path.dirname(ProjectPath)

# Verify that project contains a PLCOpen program

plc_file = os.path.join(ProjectPath, "plc.xml")

if os.path.isfile(plc_file):

# Load PLCOpen file

result = self.OpenXMLFile(plc_file)

if result:

return result

else:

self.CreateNewProject({"companyName": "",

"productName": "",

"productVersion": "",

"projectName": "",

"pageSize": (0, 0),

"scaling": {}})

if len(self.GetProjectConfigNames()) == 0:

self.AddProjectDefaultConfiguration()

# Change XSD into class members

self._AddParamsMembers()

self.Children = {}

# Keep track of the root confnode (i.e. project path)

self.ProjectPath = ProjectPath

self.BuildPath = self._getBuildPath()

if self.OrigBuildPath is not None:

mycopytree(self.OrigBuildPath, self.BuildPath)

# If dir have already be made, and file exist

if os.path.isdir(self.CTNPath()) and os.path.isfile(self.ConfNodeXmlFilePath()):

# Load the confnode.xml file into parameters members

result = self.LoadXMLParams()

if result:

return result

# Load and init all the children

self.LoadChildren()

canopen_child = self.GetChildByName("CanOpen")

if canopen_child is None:

canopen = self.CTNAddChild("CanOpen", "CanOpen", 0)

canopen.LoadChildren()

canopen.CTNRequestSave()

if self.CTNTestModified():

self.SaveProject()

if wx.GetApp() is None:

self.RefreshConfNodesBlockLists()

else:

wx.CallAfter(self.RefreshConfNodesBlockLists)

if self.arch in PLC_module:

self.SetParamsAttribute('BeremizRoot.TargetType', 'MC9')

return None

def _UpdateFw(self):

"""

Method called by user to flash the firmware of the PLC

"""

from FirmwareUpdateDialog import FirmwareUpdateDialog

from dialogs import DiscoveryDialog

from HostFirmwareUpdater import HostFirmwareUpdater

if self.firmwareUpadateIsRunning == True:

self.logger.write_error(_("Firmware update is already running!\n"))

return

self.firmwareUpadateIsRunning = True

self.logger.write(_("Firmware update started\n"))

# Launch the firmware selection dialog

dialog = FirmwareUpdateDialog(self.AppFrame)

answer = dialog.ShowModal()

imageFilePath = dialog.GetFirmwareImageFile()

updateType = dialog.GetFirmwareUpdateType()

chunksSize = dialog.GetChunksSize()

reboot = dialog.GetReboot()

dialog.Destroy()

if answer == wx.ID_CANCEL:

self.logger.write_error(_("Firmware update canceled!\n"))

self.firmwareUpadateIsRunning = False

return

if imageFilePath == None or imageFilePath == "":

self.logger.write_error(_("No firmware image file selected!\n"))

self.logger.write_error(_("Firmware update canceled!\n"))

self.firmwareUpadateIsRunning = False

return

else:

self.logger.write(_("Firmware image file: %s\n") % imageFilePath)

if updateType == 1:

self.logger.write(_("Firmware update type: Linux kernel image\n"))

elif updateType == 2:

self.logger.write(_("Firmware update type: Linux DTB image\n"))

elif updateType == 3:

self.logger.write(_("Firmware update type: Root file system image\n"))

else:

self.logger.write_error(_("Unknown firmware update type!\n"))

self.logger.write_error(_("Firmware update canceled!\n"))

self.firmwareUpadateIsRunning = False

return

if chunksSize < 1024 or chunksSize > 1024 * 1024:

self.logger.write_error(_("Bad chunks size : %d KiB!\n") % chunksSize)

self.logger.write_error(_("Firmware update canceled!\n"))

self.firmwareUpadateIsRunning = False

return

else:

self.logger.write(_("Chunks size : %d KiB\n") % chunksSize)

self.logger.write(_("Reboot after update : %s\n") % ("Yes" if reboot else "No"))

# Get the target PLC URI

# Check if an uri is already configured in the Beremiz project

uri = self.BeremizRoot.getURI_location()

if uri is not None and uri != "":

self.logger.write(_("PLC URI configured in the Beremiz project will be used: %s\n") % uri)

else:

# PLC URI is not configured in the Beremiz project

# Launch Service Discovery dialog

self.logger.write(_("PLC URI is not configured in the Beremiz project. Launching the Discover dialog\n"))

dialog = DiscoveryDialog(self.AppFrame)

answer = dialog.ShowModal()

uri = dialog.GetURI()

dialog.Destroy()

# Nothing choosed or cancel button

if uri is None or answer == wx.ID_CANCEL:

self.logger.write_error(_("Connection canceled!\n"))

self.logger.write_error(_("Firmware update canceled!\n"))

self.firmwareUpadateIsRunning = False

return

# Get connector from uri

self._connector = None

try:

self._SetConnector(connectors.ConnectorFactory(uri, self))

except Exception:

self.logger.write_error(_("Exception while connecting %s!\n") % uri)

self.logger.write_error(traceback.format_exc())

self.logger.write_error(_("Firmware update canceled!\n"))

self.firmwareUpadateIsRunning = False

return

# Did connection success ?

if self._connector is None:

# Oups.

self.logger.write_error(_("Connection failed to %s!\n") % uri)

self.logger.write_error(_("Firmware update canceled!\n"))

self.firmwareUpadateIsRunning = False

return

else:

self.logger.write(_("Connected.\n"))

# Last confirmation before firmware update

answer = wx.MessageBox(_('Are you sure to launch the firmware update for the selected PLC?'),

_('Firmware Update'), wx.YES_NO | wx.CENTRE | wx.NO_DEFAULT,

self.AppFrame)

if answer != wx.YES:

self.logger.write_error(_("Firmware update canceled!\n"))

self.firmwareUpadateIsRunning = False

return

# Some cosmetics

self.AppFrame.Refresh()

self.AppFrame.Update()

# Lauch the firmaware update on the remote PLC

updater = HostFirmwareUpdater(self._connector, imageFilePath, updateType, chunksSize, reboot, self.logger)

try:

updater.update()

except Exception as e:

self.logger.write_error(str(e) + "\n")

self.logger.write_error(_("Firmware update canceled!\n"))

self.firmwareUpadateIsRunning = False

self._Disconnect()

return

self._Disconnect()

self.firmwareUpadateIsRunning = False

return True