Welcome to KSociety.SharpCubeProgrammer Discussions!

[maniglia]

👋 Welcome!

We’re using Discussions as a place to connect with other members of our community. We hope that you:

• Ask questions you’re wondering about.
• Share ideas.
• Engage with other community members.
• Welcome others and are open-minded. Remember that this is a community we
  build together 💪.

To get started, comment below with an introduction of yourself and tell us about what you do with this community.

[mihaisvcc]

Happy new year maniglia,

First I want to show my gratitude towards your work, you have done a fine job !
Second I have improvement suggestions/bug corrections in order to make this wrapper even better.
My observation are related to the function GetStorageStructure() The poor documented API the function is returning a pointer to some chained structures. Now if we use the function as already written it will return the address and size of the first sector in the first bank.
The stm32Fx controllers can have the memory organized in two banks containing sectors with different start addresses and different sizes.
In order to have the correct list with all the respective sectors we have to loop and advance the pointer with the size of sector and bank structure. In this way we will get the correct sector list with the addresses and sizes. This is very useful when we have to do only selective sector erase.
For example I have a HMI application wich has two firmware elements, situated in flash at different addresses. A sector in-between is used for parameters. So I need the sector erase and I need to know the memory model....in this case my stm32F4 has 23 sectors divided in two banks. Each microcontroller family like F0, F4, F7 etc has it's own flash memory model (see the respective datasheet)
I will put the modified code to illustrate the correct sector information retrieval:

``public static (CubeProgrammerError, DeviceStorageStructure) GetStorageStructure()
        {
            var deviceStorageStructure = new DeviceStorageStructure();
            var storageStructurePtr = new IntPtr();
            var output = CubeProgrammerError.CubeprogrammerErrorOther;
            try
            {
                var result = Native.GetStorageStructure(ref storageStructurePtr);

                output = CheckResult(result);

                if (output.Equals(CubeProgrammerError.CubeprogrammerNoError))
                {
                    if (storageStructurePtr != IntPtr.Zero)
                    {
                        deviceStorageStructure.sectors = new List<BankSector>();
                        var storageStructure = Marshal.PtrToStructure<StorageStructure>(storageStructurePtr);

                        deviceStorageStructure.BanksNumber = storageStructure.BanksNumber;

                        for (int k = 0; k < deviceStorageStructure.BanksNumber; k++)
                        {

                            var deviceBankResult = Marshal.PtrToStructure<DeviceBank>(storageStructure.Banks + (k * Marshal.SizeOf<DeviceBank>()));

                            deviceStorageStructure.SectorsNumber += deviceBankResult.SectorsNumber;

                            for (int n = 0; n < deviceBankResult.SectorsNumber; n++)
                            {
                                var sector = new BankSector();
                                var bankSector = Marshal.PtrToStructure<BankSector>(deviceBankResult.Sectors + (n * Marshal.SizeOf<BankSector>()));
                                sector.Index = bankSector.Index;
                                sector.Size = bankSector.Size;
                                sector.Address = bankSector.Address;
                                deviceStorageStructure.sectors.Add(sector);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {

            }

            return (output, deviceStorageStructure);
}

the modified structure will be :

` public struct DeviceStorageStructure
        {
            public uint BanksNumber; //can be two
            public uint SectorsNumber; //can be more of them across the two banks
            public List<BankSector> sectors;
        `}

Now we will have the sector list.

Now the third observation is concerning the function FileOpen(string filePath)
It returns the start address and the size of the firmware located in the compiled hex or bin file.
But it is possible to have more than one element, for example two like in my application described above.
In this case we have to loop and find the firmware elements, like below:

 public static FileData FileOpen(string filePath)
        {
           var parsedFile = new FileData();
            parsedFile.elementAddress =  new List<UInt32>();
            parsedFile.elementSize = new List<UInt32>();
            parsedFile.elementData = new List<byte[]>();
            FileDataC? fileData = null;
            try
            {
                if (!String.IsNullOrEmpty(filePath))
                {
                    var filePathAdapted = filePath.Replace(@"\", "/");
                    var filePointer = Native.FileOpen(filePathAdapted);

                    if (!filePointer.Equals(IntPtr.Zero))
                    {
                        fileData = Marshal.PtrToStructure<FileDataC>(filePointer);
                        parsedFile.type = fileData.Value.Type;
                        parsedFile.segmetsNr = fileData.Value.segmentsNbr;
                        for (int k = 0; k < parsedFile.segmetsNr; k++)
                        {
                            var segment = Marshal.PtrToStructure<SegmentDataC>(fileData.Value.segments + (k * Marshal.SizeOf<SegmentDataC>()));
                            var data = new byte[segment.size];
                            Marshal.Copy(segment.data, data, 0, segment.size);
                            parsedFile.elementSize.Add((UInt32)segment.size);
                            parsedFile.elementAddress.Add((UInt32)segment.address);
                            parsedFile.elementData.Add(data);
                        }
                        Marshal.DestroyStructure<SegmentDataC>(fileData.Value.segments);
                        Marshal.DestroyStructure<FileDataC>(filePointer);
                    }
                }
            }
            catch { }

            return parsedFile;
        }

public struct FileData
        {
            public int type;
            public int segmetsNr;  //when is more than 1 loop trough and find for each segment startAddress, size and data...
            public List<UInt32> elementAddress;
            public List<UInt32> elementSize;
            public List<byte[]> elementData;
        }

Thank you once more for your work, and whish you a good year.

[maniglia]

Hello @mihaisvcc ,
happy new year to you.
Thank you very much for your message, I'm busy right now but I intend to integrate your suggestions into the library as soon as possible.
I am very happy to have received your suggestions!
Thanks a lot.

[mihaisvcc]

Buongiorno maniglia,

you are welcome and thanks for answering, I have a question regarding the setDisplayCallbacks fuction
I'm trying to use directly the CubeProgrammerAPI. dll but when I call under the x86 (the dll and his dependencies 32bit) the setDisplayCallbacks I get a null reference, access violation error. The x64 variant is working fine. Do you have idea why )?

`[DllImport("CubeProgrammer_API.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "setDisplayCallbacks")]
 internal static extern void SetDisplayCallbacks(ref DisplayCallbacks callbacks);`

 #region [General API init]
        public struct DisplayCallbacks
        {
            public InitProgressBar initProgressBar;
            public LogMessageReceived logMessage;
            public ProgressBarUpdateReceived loadBar;
        }

public delegate void LogMessageReceived(int messageType, [MarshalAs(UnmanagedType.LPWStr)] string message);
public delegate void InitProgressBar();
public delegate void ProgressBarUpdateReceived(int currentProgress, int total);

public static void SetDisplayCallbacks(InitProgressBar initProgressBar, LogMessageReceived messageReceived, ProgressBarUpdateReceived progressBarUpdate)
{
Native.DisplayCallbacks callbacksHandle;

        callbacksHandle.initProgressBar = initProgressBar;
        callbacksHandle.logMessage = messageReceived;
        callbacksHandle.loadBar = progressBarUpdate;

        Native.SetDisplayCallbacks(ref callbacksHandle); // ?? here it crashes.....on x86 ??
    }

Thanks, 
Kind Regards,

[maniglia]

Hello @mihaisvcc
currently the SetDisplayCallbacks function is not expected to be used.
I opened a new discussion on this topic, because I haven't yet decided how to manage the logs generated by the ST library.
For example, are the logs generated by the CubeProgrammer_API.dll library really necessary?
I have never given too much importance to this function and evidently there is a bug.
Please open a new discussion if you have any other questions.
Best Regards

[mihaisvcc]

Hello maniglia,

thanks for the quick reply. In my opinion the SetDisplayCallbacks is useful when debug, normally is not needed.
It helped me to see that the CubeProgrammerAPI.dll is working as expected over the USB and I was able to see were it got stuck when I've made a mistake. I have tested the 32 bit variant without calling this function and it worked. The API documentation and the c++ examples are recommending to call this first along with the much critical SetLoadersPath. In your Programmer.dll SetDisplayCallbacks is called in dllmain.cpp at the DLL call.
Kind Regards,