aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/Tango.Stubs/Examples/ContinuousResponseAdvanced.cs
blob: 781ed2d606edeae3f4325283177202f5a5cc5f46 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using System;
using System.Text;
using System.Linq;
using System.Drawing;
using System.Diagnostics;
using System.Windows.Forms;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using Tango.PMR.Stubs;
using Tango.Stubs;

public void OnExecute(StubManager stubManager)
{

    // Request ----
    // Int32 : Amount
    // Int32 : Delay

    // Response ----
    // Double : Progress


    ProgressRequest request = new ProgressRequest();
    request.Amount = 100;
    request.Delay = 1;

    stubManager.RunContinuous<ProgressResponse>(request, (response) =>
    {

        stubManager.WriteLine(response.Progress);

    });

}
*/ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
/*
 * FlashProgram.c
 *
 *  Created on: Jan 22, 2019
 *      Author: shlomo
 */

//#include <stdint.h>
#include "include.h"
#include "driverlib/rom.h"
#include "driverlib/flash.h"
#include <DataDef.h>
#include "FlashProgram.h"

//#define FLASH_DEBUG
#ifdef FLASH_DEBUG
#define  MAX_CONT_LOG 100

#define READ 1
#define DELETE 2
uint32_t Address[MAX_CONT_LOG+1] = {0};
uint32_t Size[MAX_CONT_LOG+1] = {0};
uint32_t EraseWrite[MAX_CONT_LOG+1] = {0};
byte RxIndex = 0;
#endif
//*****************************************************************************
//
// Read the application image from the file system and program it into flash.
//
// This function will attempt to open and read the firmware image file from
// the mass storage device.  If the file is found it will be programmed into
// flash.  The name of the file to be read is configured by the macro
// \b USB_UPDATE_FILENAME.  It will be programmed into flash starting at the
// address specified by ui32FlashStart.
//
// \return Zero if successful or non-zero if the file cannot be read or
// programmed.
//
//*****************************************************************************
uint32_t ReadAppAndProgram(uint32_t ui32FlashStart,uint32_t ui32FileSize,void* buffer)
{
    //uint32_t ui32FileSize;
    uint32_t ui32DataSize;
    uint32_t ui32Remaining;
    uint32_t ui32ProgAddr;
    uint32_t ui32BufferAddr;
    volatile uint32_t ui32Idx;
    uint32_t status = OK;
    //uint32_t ui32FlashEnd;

#ifdef FLASH_DEBUG
    Address[RxIndex] = ui32FlashStart;
    Size[RxIndex] = ui32FileSize;
    EraseWrite[RxIndex] = READ;
    if (RxIndex++>=MAX_CONT_LOG)
        RxIndex = 0;
#endif
    //
    // Get the size of flash.  This is the ending address of the flash.
    // If reserved space is configured, then the ending address is reduced
    // by the amount of the reserved block.
    //
    //ui32FlashEnd = ui32FlashStart + ui32FileSize;


    //
    // Check to make sure the file size is not too large to fit in the flash.
    // If it is too large, then return an error.
    //
    /*if((ui32FileSize + ui32FlashStart) > ui32FlashEnd)
    {
        return(1);
    }*/

    //
    // Enter a loop to erase all the requested flash pages beginning at the
    // application start address (above the USB stick updater).
    //
    /*for(ui32Idx = ui32FlashStart; ui32Idx < ui32FlashEnd; ui32Idx += 1024)
    {
        ROM_FlashErase(ui32Idx);
    }*/

    //
    // Enter a loop to read sectors from the application image file and
    // program into flash.  Start at the user app start address (above the USB
    // stick updater).
    //
    ui32ProgAddr = ui32FlashStart;
    ui32BufferAddr = (uint32_t)buffer;
    ui32Remaining = ui32FileSize;
    while(ui32Remaining)
    {
        //
        // Compute how much data was read from this sector and adjust the
        // remaining amount.
        //

        ui32DataSize = ui32Remaining >= 512 ? 512 : ui32Remaining;
        ui32Remaining -= ui32DataSize;

        //
        // Call the function to program a block of flash.  The length of the
        // block passed to the flash function must be divisible by 4.
        //

        status = FlashProgram((uint32_t *)ui32BufferAddr, ui32ProgAddr,(ui32DataSize + 3) & ~3);
        if (status)
            Report("FlashProgram Error", __FILE__,status,ui32ProgAddr , RpMessage, (ui32DataSize + 3) & ~3, 0);

        //
        // If there is more image to program, then update the programming
        // address.  Progress will continue to the next iteration of
        // the while loop.
        //
        if(ui32Remaining)
        {
            ui32ProgAddr += ui32DataSize;
            ui32BufferAddr += ui32DataSize;
        }

    }

    //
    // If we make it here, that means that an attempt to read a sector of
    // data from the device was not successful.  That means that the complete
    // user app has not been programmed into flash, so just return an error
    // indication.
    //
    return(1);
}
uint32_t EraseFlashSection(uint32_t ui32FlashStart,uint32_t ui32FileSize)
{
    volatile uint32_t ui32Idx;
    //uint32_t status;
#ifdef FLASH_DEBUG
    Address[RxIndex] = ui32FlashStart;
    Size[RxIndex] = ui32FileSize;
    EraseWrite[RxIndex] = DELETE;
    if (RxIndex++>=MAX_CONT_LOG)
        RxIndex = 0;
#endif
    for(ui32Idx = ui32FlashStart; ui32Idx < ui32FlashStart+ui32FileSize; ui32Idx += 1024)
    {
        //status = FlashErase(ui32Idx);
    }
    return OK;

}
//Each word may not be subject to more than a specific number of programming cycles before an
//erase cycle is required. In other words, for any given word, FlashProgram can only be called
//twice before FlashErase is called.
void FlashInit(void)
{
    volatile uint32_t ui32Idx;
    //FlashUsecSet(120);
#ifdef FLASH_DEBUG
    Address[RxIndex] = FLASH_RAM_BASE;
    Size[RxIndex] = FLASH_SIZE;
    EraseWrite[RxIndex] = DELETE;
    if (RxIndex++>=MAX_CONT_LOG)
        RxIndex = 0;
#endif
    for(ui32Idx = FLASH_RAM_BASE; ui32Idx < FLASH_RAM_BASE+FLASH_SIZE; ui32Idx += 1024)
    {
        FlashErase(ui32Idx);
    }
}