• Go to your Functions App -> Click on the Platform Features tab -> Under Development Tools choose Advanced Tools (Kudu):

• Next, On the Kudu page at the top, Click on the Debug Console drop down and choose PowerShell or Cmd (doesn't matter). Both will lead you to a view of your folder structure and a console window.

• Now we need to navigate to your Functions Site Directory. My function is named PowerShellTimed (as you see in the screen shot above) so that is where I will navigate too. Click on the folder Site -> wwwroot -> YourFunctionsName and you will land a folder that has your run.ps1 and a function.json like below:

• Now you are going to click on the + sign and choose New Folder and you will name it "modules":

• Ok, we have our folder created and now we can journey back to the Azure Portal. Navigate to your Functions App and click on the PowerShell function you are working with. All the way on the right of the screen (on the side) you should see a tab for "View files" and click on it. That will open your files blade and you should see a folder "modules" and your function.json and run.ps1.

• Now, click on the modules folder and click Upload, this will open a folder browser dialog. Navigate to your files and put them directly in the modules folder.

• Once that is done, simply call your module commands from the run.ps1 script and viola it works! You do NOT need to call import-modules UNLESS you have conflicting modules and you want to explicitly override them. Notice I have two command I am calling directly Get-FooDate and Write-Foo and as you can see in the logs below work successfully!

• Reference data:
  • Get-AzureRmAlertRule
  • Add-AzureRmMetricAlertRule

• Register your application with your Azure Active Directory tenant
  • https://docs.microsoft.com/en-us/azure/active-directory/active-directory-app-registration

/*
 * Servo NETMF Driver
 *	Coded by Chris Seto August 2010
 *	<chris@chrisseto.com> 
 *	
 * Use this code for whatever you want. Modify it, redistribute it, I don't care.
 * I do ask that you please keep this header intact, however.
 * If you modify the driver, please include your contribution below:
 * 
 * Chris Seto: Initial release (1.0)
 * Chris Seto: Netduino port (1.0 -> Netduino branch)
 * Chris Seto: bool pin state fix (1.1 -> Netduino branch)
 * 
 * Theo Browning: Release (2.0) modified to work with current framework.
 * 
 * */

using System;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;


namespace NetduinoApplication1
{
    public class ServoController : IDisposable
    {
        /// <summary>
        /// PWM handle
        /// </summary>
        private PWM servo;

        /// <summary>
        /// Timings range
        /// </summary>      
        private int[] range = new int[2];

        /// <summary>
        /// Set servo inversion
        /// </summary>    
        public bool inverted = false;

        /// <summary>
        /// Create the PWM Channel, set it low and configure timings
        /// Changes here PWM Channel requires Channel, Period, Duration, 
        /// Scale and Inversion on instantiation.
        /// </summary>
        /// <param name="pwmChannel"></param>
        public ServoController()
        {
            // Initialize the PWM Channel, set to pin 5 as default.            
            servo = new PWM(
                PWMChannels.PWM_PIN_D5, 
                20000, 
                1500, 
                Microsoft.SPOT.Hardware.PWM.ScaleFactor.Microseconds, 
                false);

            // Full range for FS90 servo is 0 - 3000.
            // For safety limits I set the default just above/below that.
            range[0] = 600;
            range[1] = 2400;
        }

        /// <summary>
        /// Allow for consumer to set own range.
        /// </summary>
        /// <param name="leftStop", "rightStop"></param>
        public void SetRange(int leftStop, int rightStop)
        {
            range[1] = leftStop;
            range[0] = rightStop;
        }

        /// <summary>
        /// Dispose implementation.
        /// </summary>
        public void Dispose()
        {
            Disengage();
            servo.Dispose();
        }

        /// <summary>
        /// Disengage the servo. 
        /// The servo motor will stop, and try to maintain an angle
        /// </summary>
        public void Disengage()
        {            
            servo.DutyCycle = 0; //SetDutyCycle(0);
        }


        /// <summary>
        /// Set the servo degree
        /// </summary>
        public double Degree
        {
            set
            {
                /// Range checks
                if (value > 180)
                    value = 180;

                if (value < 0)
                    value = 0;

                // Are we inverted?
                if (inverted)
                    value = 180 - value;

                // Set duration "pulse" and start the servo. 
                // Changes here are PWM.Duration and PWM.Start() instead of PWM.SetPulse().                
                servo.Duration = (uint)map((long)value, 0, 180, range[0], range[1]);
                servo.Start();
            }
        }

        /// <summary>
        /// Used internally to map a value of one scale to another
        /// </summary>
        /// <param name="x"></param>
        /// <param name="in_min"></param>
        /// <param name="in_max"></param>
        /// <param name="out_min"></param>
        /// <param name="out_max"></param>
        /// <returns></returns>

        private long map(long x, long in_min, long in_max, long out_min, long out_max)
        {
            return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
        }
    }
}

That's the class, now here is just a simple example of implementation, the following will infinite loop a servo to full left/right motion. Get past the infinite loop and the sleep as well as this is for simplicity, I would implement a timer and a condition if this were for real application. We can come back and talk about timers in NETMF another time as they are a whole different animal than timers in the full .Net Framework (post in comments if you would like to see more on timers).

 public static void Main()
        {   
            ServoController servo = new ServoController();

            servo.SetRange(500, 2400);

            bool runForever = true;

            while (runForever)
            {
                for (int i = 1; i < 179; i++)
                {
                    servo.Degree = i;
                    Thread.Sleep(25);
                }

                for (int i = 179; i > 1; i--)
                {
                    servo.Degree = i;
                    Thread.Sleep(25);
                }
            }

            servo.Dispose();
        }

Enjoy and I hope this saves you some time!

[

An append blob is comprised of blocks and is optimized for append operations. When you modify an append blob, blocks are added to the end of the blob only, via the Append Block operation. Updating or deleting of existing blocks is not supported. Unlike a block blob, an append blob does not expose its block IDs.

Each block in an append blob can be a different size, up to a maximum of 4 MB, and an append blob can include up to 50,000 blocks. The maximum size of an append blob is therefore slightly more than 195 GB (4 MB X 50,000 blocks).

]

So what does that mean to us as developers, what can we do with this new found awesomeness called an AppendBlob???  Let's say you had a blob that was a text file and you were writing events to it (logging).  When you wanted to add something to that blob you had to download it, read it into a stream or something, add to it, and then upload it to overwrite the old blob. With AppendBlob all this work is now done for you and there is even some other checking and functionality added as well. Let's write some code and take a look.   

// Using statements for our libraries.
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Auth;
using Microsoft.WindowsAzure.Storage.Blob;
using System;
using System.Collections.Generic;
using System.Configuration;
 
namespace AzureAppendBlobSample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Let's set up our connection for the account and store the name and key in app.config.           
            string accName = ConfigurationManager.AppSettings["StrAccName"];
            string accKey = ConfigurationManager.AppSettings["StrAccKey"];
 
            // Implement the accout, set true for https for SSL.
            StorageCredentials creds = new StorageCredentials(accName, accKey);
            CloudStorageAccount strAcc = new CloudStorageAccount(creds, true);
            CloudBlobClient blobClient = strAcc.CreateCloudBlobClient();
 
            //Setup our container we are going to use and create it.
            CloudBlobContainer container = blobClient.GetContainerReference("logs");
            container.CreateIfNotExistsAsync();
 
            // Build my typical log file name.
            DateTime date = DateTime.Today;
            DateTime dateLogEntry = DateTime.Now;
            // This creates a reference to the append blob we are going to use.
            CloudAppendBlob appBlob = container.GetAppendBlobReference(
                string.Format("{0}{1}", date.ToString("yyyyMMdd"), ".log"));
 
            // Now we are going to check if todays file exists and if it doesn't we create it.
            if (!appBlob.Exists())
            {
                appBlob.CreateOrReplace();
            }
 
            // Add the entry to our log.
 
            appBlob.AppendText(
                string.Format(
                "{0} | Error: Something went wrong and we had to write to the log!!!\r\n",
                dateLogEntry.ToString("o")));
 
            // Now lets pull down our file and see what it looks like.
            Console.WriteLine(appBlob.DownloadText());
 
            // Hold the console open.
            Console.WriteLine("Press any key to continue");
            Console.ReadKey();
        }
    }
}

And here is the output of running the above code on the 6th run. As you can see there are entries time stamped over about 1 minute duration. This is great for logging of many kinds and tons of other applications to be able to just update the blob just like you would a text file on disk. However, if I were logging many events per/sec per/min or I wanted to search quick and easy, then I would look at using something else like Table storage instead (blog coming soon).

Keys to remember about an append blob:

You cannot edit, modify, change, update (whatever word you want to use) the existing blocks of the blob. You can ONLY append to the end of the blob.

Max entries to an append blob "from my testing", are about 5-6 per second. I have tested this several times with a max entries loop (50,0000) to a single append blob. The best ways to handle this limitation would be to queue up the messages and then append them to the blob in chunks instead of singular appends. 

With that said, an append blob has a max of 50,000 blocks at a max of 4mb each.

Here are some of the append methods:

And last but not least, here is the referencing documentation:

CloudStorageAccount Class

https://msdn.microsoft.com/en-us/library/azure/microsoft.windowsazure.storage.cloudstorageaccount.aspx

StorageCredentials Class

https://msdn.microsoft.com/en-us/library/azure/microsoft.windowsazure.storage.auth.storagecredentials.aspx

CloudBlobClient Class

https://msdn.microsoft.com/en-us/library/azure/microsoft.windowsazure.storage.blob.cloudblobclient.aspx

CloudBlobContainer Class

https://msdn.microsoft.com/en-us/library/azure/microsoft.windowsazure.storage.blob.cloudblobcontainer.aspx

CloudAppendBlob Class

"Coming Soon" but the constructors should look like:

	Name	Description
	CloudAppendBlob(Uri)	Initializes a new instance of the CloudAppendBlob class using an absolute URI to the blob.
	CloudAppendBlob(Uri, StorageCredentials)	Initializes a new instance of the CloudAppendBlob class using an absolute URI to the blob.
	CloudAppendBlob(Uri, Nullable<DateTimeOffset>, StorageCredentials)	Initializes a new instance of the CloudAppendBlob class using an absolute URI to the blob.
	CloudAppendBlob(StorageUri, Nullable<DateTimeOffset>, StorageCredentials)	Initializes a new instance of the CloudAppendBlob class using an absolute URI to the blob.

Happy Coding!

Lets take a look at some code:

We first define a class named Person, within it some member definitions. The first of those definitions are member variables, we declare a string and int called "name" and "age" respectively. Next, we create a override to the default constructor, it requires a string and int as arguments and it uses those to set the public member variables to the supplied values. Lastly we create a member method that writes a string to the console with our person's name and age injected.

This all works fine and well however, let's take a peak at what could happen if someone was consuming our code. Keep in mind this is the simplest of examples meant to show a point.

First we create a new object of the Person class type and we pass Suzy for the name and 23 for the age. Added to our constructor, is the first call to Talk() so we do not have to call it, as you can see in the command prompt console it displays with Suzy and 23 correctly. Next we access the "name" member variable off of p1 and change it to Joe. We can do this because we defined it as public which sets it's access level to full throughout the program or a consumer. You can see it show up on intelliSense as well:

Using Properties and Backing Fields, referred to as "Getters and Setters" is the way around this and the proper way to control / encapsulate your variables. Using encapsulation (Getters & Setters) you can restrict access, perform various checks, or many other operations on the data as your class requires before allowing or denying the modification. There are a several ways to do this, let's discuss the automagic way. Auto-Implemented, when we use this method the compiler uses some syntactic sugar for us and creates a backing field (private variable) so it saves us a bit of typing. The Getter & Setter control the access to those backing fields and is up to us to define that. In the example below, I left the Getter to public (default) and I set the Setter to private so that it can only be accessed through the class. Take note the default here is opposite of what you get when you define variables and methods, the default for those are private unless defined otherwise.

We can also create a method in our class that modifies the values if we like, but again, we are controlling when and where these values are able to be accessed and modified.

Or we could create a Factory method to do it all for us.

So you see, we have much more control over our variables this way and can perform many other operations in a controlled manner. If we don't want them accessed at all we simply only implement a Getter and no we code without the worry of something getting changed in our class that would have an undesired effect (BUG!).

Happy coding!