EnglishSvenska

Finns det verkligen inget bättre än Automod?

Automod är en mjukvara för att simulera produktionslinor vilken vi använde oss av i en av mina sista kurser på Chalmers. Vårt uppdrag var att simulera en fabrik som tillverkar lyktstolpar och därefter göra förbättringar i enlighet med Theory of constraints. Jag vet inte hur Automod står sig jämfört med andra mjukvaror eftersom det är den enda jag testat. Kanske är Automod det bästa som finns att tillgå, men det vore i så fall tragiskt.

  • Temporära variabler existerar inte. Ingen variabel kan skapas för att därefter slängas bort. Skriva kod är ett mindre helvete. Alla fel rapporteras när man stänger kodfönstret. Behöver man ändra en entity måste man göra det från en rull-lista. Allt öppnas i nya fönster. Det hela är riktigt dåligt ur användarvänlighetsperspektiv.
  • Den visuella modellen återställs alltid och kommer inte ihåg inställningar. För varje gång man kör modellen måste man navigera sig tillbaka till samma vy som innan.
  • Batchning är inte intuitivt. Man måste använda s.k. Order lists, förstöra och därefter skapa loads (produkter). Galet att det inte är med i i en mjukvara som ska simulera produktflöden.
  • Och hela tänket med Order lists är inte intuitivt. För att flytta en load från en maskin till en annan är det inte bara att flytta dem. Man måste själv skriva koden för att kontrollera att maskinen är ledig och därefter flytta. Är den inte ledig måste man vänta på en order list som fungerar lite som en interrupt på en mikroprocessor. Man triggar denna order list varje gång en produkt går ur maskin 2. Skippar man det kommer en produkt att sväva i "space" vilket är ett tillstånd då den inte riktigt existerar någonstans.
  • För att fortsätta med space-problemet; teleportering är det primära sättet att flytta en produkt från en punkt till en annan. Visst går det att göra rullband och liknande transportsystem men de är alla tidskrävande. När man teleporterar produkter överallt är det ytterst lätt att göra fel och av misstag hoppa över en process eller köra en onödig process.
  • Det finns inget bra stöd för att göra pullbaserade beställningar. Säg att man vill att en produktorder kommer in och att en tillverkning ska ske baserat på denna. Givetvis går det att göra men man får programmera det själv.
  • En av de viktigaste analyser man vill göra i en produktionssimulering är att analysera flaskhalsar. För mig faller det i sin rimlighet att stöd för moderna verktyg för att finna dessa ska finnas med från börjar. Ett exempel på detta skulle vara Shifting bottleneck detection vilket är en lite mer sofistikerad metod. Men den finns inte. Visst det kanske går att programmera för hand vilket skulle ta massvis av timmar.
  • Saving and export är olika saker. Saving sparar ner i en versionsberoende fil och export i en ej versionsberoende mapp.

Vi blev klara med projektet och lämnade in vår rapport förra veckan. Jag hoppas för industrins bästa att det finns mer effektiva sätt att göra produktionssimuleringar.

Ladda ner rapporten MPR 271 - Improving the throughput at Lightning Inc. – Sebastian Nilsson and Pontus

 

Realtime data plotter

Debugging sensors on a microprocessor can be a hassle and the most used approach is to output the sensor values to a serial monitor. Realtime plotting is a better and more visual way of doing the same thing.

RealtimePlotterProcessing

  • Real-time plotter of your data while it is still being processed by your application
  • Plots live data from serial port. Microprocessor choice does not matter as long as it can send serial data to your computer.
  • 6 channels of data (and this can be increased if necessary)
  • Live bar charts
  • Live line graphs
  • You just send the data you want to debug with a space as delimiter like this "value1 value2 value3 value4 value5 value6". Floats or integers does not matter.
  • Open source
  • Robust. It will not crash because of corrupt data stream or similar.
  • Multi platform Java. Tested on OSX and Windows 8 (and should work on Linux as well).

I created this software to debug an Arduino Due on my self-balancing robot. To tune the controls of the robot I needed fast feedback to know if I was making progress or not. The video below demonstrates typical use of the realtime plotter:

Download

Download
You can also follow the project at Github. If you make improvements to the source code, please share it by making a pull request at Github.

How to install and use

Since I have an Arduino I will use it as example but any micro processor can be used.

  1. Get ProcessingIDE to run the code. It is a neat and useful IDE for doing graphical stuff.
  2. Download controlP5 gui library and unzip it into your Processing libraries folder
  3. Connect the Arduino to the usb or serial port of your computer.
  4. Upload the example code (RealtimePlotterArduinoCode) to the Arduino
  5. Check serial monitor (at 115200) and check that it outputs data in the format "value1 value2 value3 value4 value5 value6".
  6. Close the serial monitor (since only one resource can use the serial port at the same time).
  7. Open the Processing sketch and edit the serial port name to correspond to the actual port ("COM3", "COM5", "/dev/tty.usbmodem1411" or whatever you have)
  8. Run the sketch

Advanced use

The realtime plotter can be expanded to also send commands to the microprocessor. The usual approach when programming microprocessors is to set some parameters in the beginning of the code, upload them to the processor, see the result, change the parameters again, upload, and so on until satisfactory performance is achieved. This iterative process takes a lot of time and a better approach is to send updated parameters to the microprocessor from your computer via serial data. For example I needed to tune some parameters on my robot and created a command panel that runs in parallell with the realtime plotter. For each change in parameters I immediately am able to see the result on the plotting screen. Example code of this is located in /RealtimePlotterWithControlPanel.

RealtimePlotterProcessingWithControlPanel

Notes

I decided to send and receive the data as ascii characters instead of binaries. The greatest disadvantage is performance and ease of use is the main advantage.

In some sense the realtime data plotter can also be used as a very slow and limited digital oscilloscope. I would not recommend using it for any high frequency applications though.

Some comments about earlier approaches and the used libraries

I have tried many different ways of doing this. My first approach was Matlab but I had problems with it locking the serial port. It was a hassle to get it working and getting everything configured takes to much time. My second approach was Python and graphing libraries but this was still not very satisfactory. The Processing language together with a graph library and ControlP5 made the whole thing much easier.

 

Webbappar på Mac

Vissa webbplatser är mer som applikationer exempelvis Gmail eller Google Calendar. Säg att du vill ha dem vanliga appar med ikon och liggandes i program-mappen. I Windows kan detta enkelt göras från Chrome genom att klicka på Skapa programgenvägar men i OSX är det tyvärr inte lika smidigt men det går att lösa med Fluid app. Jag kör just nu WordPress som en webapp när jag skriver detta inlägg.

 

Tagged with:

Arduino-bibliotek för motordrivare L29x

l298n arduino library
Jag håller på att bygga om min självbalanserande robot och behövde då ett smidigt sätt att styra motordrivaren L298n. Eftersom jag styr roboten med PID-regulatorer ville jag att mitt bibliotek ska ta flyttal som både är negativa och positiva. Resultatet blev ett motordrivar-bibliotek som är väldigt enkelt att använda:

/* This example shows how to set motor speed in percentage where a negative
   value will run the motor backwards.
   This is very usuful in control applications. For example the output
   from a PID controller is most often a float and can be integrated with
   this library easily. 
*/
#include <L29x.h>
L29x motorLeft(9, 22, 23); // enable (PWM), motor pin 1, motor pin 2
L29x motorRight(8, 24, 29); // enable (PWM), motor pin 1, motor pin 2

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  motorLeft.setSpeedPercentage(-12.34);
  motorRight.setSpeedPercentage(-10);      
  delay(3000);
  motorLeft.setSpeedPercentage(100);
  motorRight.setSpeedPercentage(90);      
  delay(3000);
}
Tagged with:

Ersättare för EEPROM på Arduino Due

När jag fick min Arduino Due upptäckte jag att den inte har EEPROM vilket kan användas för att spara icke-flyktig data. Vanligtvis på en mikroprocessor så arbetar man med RAM-minnet vilket fungerar bra så länge man inte vill spara data mellan gångerna som processorn startar. Om man vill spara en variabel som ska vara kvar även när processorn förlorar ström behöver man en annan lösning där den vanligaste är att spara ner till EEPROM. På Arduino Due finns tyvärr inte detta minne men den har däremot ett riktigt stort flash-minne som kan konfigureras till att fungera på ett liknande sätt. Jag skrev därför ett bibliotek som gör just detta. Det är tänkt att kunna användas som en rak ersättare till EEPROM. DueFlashStorage är publicerad på Github.
Exempel:

// write the value 123 to address 0
dueFlashStorage.write(0,123);

// read byte at address 0
byte b = dueFlashStorage.read(0);

Eller hela exempelkoden:

/* This example will write 3 bytes to 3 different addresses and print them to the serial monitor.
Try resetting the Arduino Due or unplug the power to it. The values will stay stored. */

#include DueFlashStorage dueFlashStorage;

void setup() {
Serial.begin(115200);
byte b1 = 3;
uint8_t b2 = 1;
dueFlashStorage.write(0,b1);
dueFlashStorage.write(1,b2);
//dueFlashStorage.write(2,b2);
}

void loop() {
  /* read from flash at address 0 and 1 and print them */
  Serial.print("0:");
  Serial.print(dueFlashStorage.read(0));
  Serial.print(" 1:");
  Serial.print(dueFlashStorage.read(1));  

  /* read from address 2, increment it, print and then write incremented value back to flash storage */
  uint8_t i = dueFlashStorage.read(2)+1;
  Serial.print(" 2:");
  Serial.print(dueFlashStorage.read(2)); 
  dueFlashStorage.write(2,i);

  Serial.println();
  delay(1000);
}

Serial monitor:
arduino due flash example serial monitor 1

Men säg att man vill spara undan en hel konfiguration och inte bara några få bytes. Jag skrev biblioteket för att kunna hantera detta också:

// say you want to store a struct with parameters:
struct Configuration {
  uint8_t a;
  uint8_t b;
  int32_t bigInteger;
  char* message;
  char c;
};
Configuration configuration;

/* then write it to flash like this: */
byte b2[sizeof(Configuration)]; // create byte array to store the struct
memcpy(b2, &configuration, sizeof(Configuration)); // copy the struct to the byte array
dueFlashStorage.write(4, b2, sizeof(Configuration)); // write byte array to flash at address 4

/* and read from flash like this: */
byte* b = dueFlashStorage.readAddress(4); // byte array which is read from flash at adress 4
Configuration configurationFromFlash; // create a temporary struct
memcpy(&configurationFromFlash, b, sizeof(Configuration)); // copy byte array to temporary struct

Se hela koden på Github för ett fungerande exempel.

Tagged with:

Stockholm Robot Championship

Sthlm Robot Championship är ett öppet mästerskap för autonoma robotar med multipla tävlingsgrenar. Jag valde att ställa upp i fristil med min ombyggda självbalanserande robot.

(Foto: tim.gremalm.se)

Back to robot building

Efter ett års uppehåll (främst på grund av den tid som jag spenderat med Formula Student) är jag tillbaka till robotbyggande. Projektet nu är att bygga om den självbalanserande roboten och göra ett antal förbättringar.

  • Atmel ARM32 Arduino Due istället för 3 små micro controllers. Bättre design.
  • LCD display
  • Improved IMU
  • More robust connectors and neater wiring
  • Bluetooth
  • Wireless programming
  • Realtidsoperativsystem (RTOS) för att schemalägga trådar på processorn. Bättre än nuvarande lösning där trådarna delades upp på flera processorer.

 

Tagged with: ,

Generating an interface for robust manual control using Supervisory Control Theory


This is a project at Chalmers consisting of implementing a control system generated from Supervisory Control Theory.

Problem description

"Operation sequencing and resource safety is a non-trivial task within modern manufacturing systems. Typically, this task is handled manually which is time-consuming and error-prone. Whether a particular system works correctly is determined by how long it has been able to function without severe error. Obviously this situation is not sustainable and can be greatly improved by using software tools and mathematics to guarantee correct functionality. Such "model-based formal methods" is one main part of the research within the Automation group at Chalmers. This project aims at implementing a proof-of- concept of existing methods."

Present at IFAC 2014

Our paper was good enough to be presented by our examiner, Martin Fabian, at IFAC 2014. http://www.ifac2014.org/

Our solution

1. Create a model of the sequence:

Sequence to manufacture a full car

Sequence to manufacture a full car

2. Express it as automatas:

Representation of operations as automata

Representation of operations as automata

3. Extract guards to forbid bad behaviors e.g. deadlocks and forbidden states:

Guard extraction from non-blocking supervisor

Guard extraction from non-blocking supervisor

4. The HMI is implemented in HTML5 and AngularJS that communicates to the OPC server of the PLC:

The HMI with only executable operations being shown

The HMI with only executable operations being shown

overview

Overview of the system and the implementation

 

Download the article Robust Manual Control of a Manufacturing System using Supervisory Control Theory in collaboration with Martin Fabian.

Download the source code from Bitbucket

Tagged with:

Dags att ansöka till Sveriges kanske bästa ingenjörstävling

Vill du vara med i en professionell ingenjörstävling? Vi rekryterar just nu nya medlemmar till det nya laget i Chalmers Formula Student-kursen på 15hp. I projektet får du lära dig att jobba i ett stort välorganiserat lag och använda samma metoder som de flesta ingenjörsföretag. Du skulle också vara med i ett internationellt lag och tävla i världens största ingenjörstävling.

För mig personligen så var det här projektet min bästa chans att applicera praktisk kunskap på Chalmers som jag annars troligtvis skulle gått miste om. Projektet är en utmaning och det finns mycket i det att bemästra innan projektet är över. Att bygga en tävlingsbil är bara en bonus.

Ansök här!

Recruitment-Poster3 smaller

Chalmers Formula Student tävlar i Baltic Open 2013

Två av Chalmers bilar ställde upp; CFS12 och CFS13e. CFS13e är en CFS11 ombyggd till en el-drivlina.

Vi hade vissa problem med överströmsskyddet som gick i när det inte skulle. För att få bra varvtider var det nödvändigt att inte pusha bilen för hårt och att alltid ha en känsla för hur mycket ström som gick genom drivlinan. Men i övrigt gick bilen förvånandsvärt bra med tanke på den mängd testtid som den haft. De sista komponenterna på bilen skruvade vi dit i garaget under tävlingsveckan. Under både AutoX och endurance fick jag motorstopp men lyckades starta upp bilen igen med hjälp från pit crew. En sak som jag tar med mig från att ha kört tävlingsbil med eldrift är att traction control troligtvis är väldigt prestandahöjande. Det är svårt att reglera gaspådraget med det snabba vridmoment som elmotorn ger. På en bensinbil är dynamiken väsentligt långsammare.

Motorn till CFS12 gick sönder under invigningen. Detta ledde till att en förlorad dag av tävlingen och där också en hel del poäng. Trots motgångar var bilen tillbaka på banan för AutoX och endurance med imponerande resultat.

Tagged with: ,