text:
/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>

#include <stdint.h>
#include <stdlib.h>
#include <assert.h>
#include <debug.h>

#include <nuttx/irq.h>
#include <nuttx/arch.h>
#include <arch/board/board.h>

#include "up_arch.h"
#include "os_internal.h"
#include "up_internal.h"

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

/* Output debug info if stack dump is selected -- even if
 * debug is not selected.
 */

#ifdef CONFIG_ARCH_STACKDUMP
# undef  lldbg
# define lldbg lowsyslog
#endif

/* The following is just intended to keep some ugliness out of the mainline
 * code.  We are going to print the task name if:
 *
 *  CONFIG_TASK_NAME_SIZE > 0 &&    <-- The task has a name
 *  (defined(CONFIG_DEBUG)    ||    <-- And the debug is enabled (lldbg used)
 *   defined(CONFIG_ARCH_STACKDUMP) <-- Or lowsyslog() is used
 */

#undef CONFIG_PRINT_TASKNAME
#if CONFIG_TASK_NAME_SIZE > 0 && (defined(CONFIG_DEBUG) || defined(CONFIG_ARCH_STACKDUMP))
#  define CONFIG_PRINT_TASKNAME 1
#endif

/****************************************************************************
 * Private Data
 ****************************************************************************/

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Name: up_getsp
 ****************************************************************************/

/* I don't know if the builtin to get SP is enabled */

static inline uint32_t up_getsp(void)
{
  uint32_t sp;
  __asm__
  (
    "\tmov %0, sp\n\t"
    : "=r"(sp)
  );
  return sp;
}

/****************************************************************************
 * Name: up_stackdump
 ****************************************************************************/

#ifdef CONFIG_ARCH_STACKDUMP
static void up_stackdump(uint32_t sp, uint32_t stack_base)
{
  uint32_t stack ;

  for (stack = sp & ~0x1f; stack < stack_base; stack += 32)
    {
      uint32_t *ptr = (uint32_t*)stack;
      lldbg("%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
             stack, ptr[0], ptr[1], ptr[2], ptr[3],
             ptr[4], ptr[5], ptr[6], ptr[7]);
    }
}
#else
# define up_stackdump()
#endif

/****************************************************************************
 * Name: up_registerdump
 ****************************************************************************/

#ifdef CONFIG_ARCH_STACKDUMP
static inline void up_registerdump(void)
{
  /* Are user registers available from interrupt processing? */

  if (current_regs)
    {
      int regs;

      /* Yes.. dump the interrupt registers */

      for (regs = REG_R0; regs <= REG_R15; regs += 8)
        {
          uint32_t *ptr = (uint32_t*)&current_regs[regs];
          lldbg("R%d: %08x %08x %08x %08x %08x %08x %08x %08x\n",
                 regs, ptr[0], ptr[1], ptr[2], ptr[3],
                 ptr[4], ptr[5], ptr[6], ptr[7]);
        }

      lldbg("CPSR: %08x\n", current_regs[REG_CPSR]);
    }
}
#else
# define up_registerdump()
#endif

/****************************************************************************
 * Name: up_dumpstate
 ****************************************************************************/

#ifdef CONFIG_ARCH_STACKDUMP
static void up_dumpstate(void)
{
  struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
  uint32_t sp   = up_getsp();
  uint32_t ustackbase;
  uint32_t ustacksize;
#if CONFIG_ARCH_INTERRUPTSTACK > 3
  uint32_t istackbase;
  uint32_t istacksize;
#endif

  /* Get the limits on the user stack memory */

  if (rtcb->pid == 0)
    {
      ustackbase = g_idle_topstack - 4;
      ustacksize = CONFIG_IDLETHREAD_STACKSIZE;
    }
  else
    {
      ustackbase = (uint32_t)rtcb->adj_stack_ptr;
      ustacksize = (uint32_t)rtcb->adj_stack_size;
    }

  /* Get the limits on the interrupt stack memory */

#if CONFIG_ARCH_INTERRUPTSTACK > 3
  istackbase = (uint32_t)&g_userstack;
  istacksize = (CONFIG_ARCH_INTERRUPTSTACK & ~3) - 4;

  /* Show interrupt stack info */

  lldbg("sp:     %08x\n", sp);
  lldbg("IRQ stack:\n");
  lldbg("  base: %08x\n", istackbase);
  lldbg("  size: %08x\n", istacksize);

  /* Does the current stack pointer lie within the interrupt
   * stack?
   */

  if (sp <= istackbase && sp > istackbase - istacksize)
    {
      /* Yes.. dump the interrupt stack */

      up_stackdump(sp, istackbase);

      /* Extract the user stack pointer which should lie
       * at the base of the interrupt stack.
       */

      sp = g_userstack;
      lldbg("sp:     %08x\n", sp);
    }

  /* Show user stack info */

  lldbg("User stack:\n");
  lldbg("  base: %08x\n", ustackbase);
  lldbg("  size: %08x\n", ustacksize);
#else
  lldbg("sp:         %08x\n", sp);
  lldbg("stack base: %08x\n", ustackbase);
  lldbg("stack size: %08x\n", ustacksize);
#endif

  /* Dump the user stack if the stack pointer lies within the allocated user
   * stack memory.
   */

  if (sp > ustackbase || sp <= ustackbase - ustacksize)
    {
#if !defined(CONFIG_ARCH_INTERRUPTSTACK) || CONFIG_ARCH_INTERRUPTSTACK < 4
      lldbg("ERROR: Stack pointer is not within allocated stack\n");
#endif
    }
  else
    {
      up_stackdump(sp, ustackbase);
    }

  /* Then dump the registers (if available) */

  up_registerdump();
}
#else
# define up_dumpstate()
#endif

/****************************************************************************
 * Name: _up_assert
 ****************************************************************************/

static void _up_assert(int errorcode) noreturn_function;
static void _up_assert(int errorcode)
{
  /* Are we in an interrupt handler or the idle task? */

  if (current_regs || ((struct tcb_s*)g_readytorun.head)->pid == 0)
    {
       (void)irqsave();
        for(;;)
          {
#ifdef CONFIG_ARCH_LEDS
            up_ledon(LED_PANIC);
            up_mdelay(250);
            up_ledoff(LED_PANIC);
            up_mdelay(250);
#endif
          }
    }
  else
    {
      exit(errorcode);
    }
}

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: up_assert
 ****************************************************************************/

void up_assert(const uint8_t *filename, int lineno)
{
#ifdef CONFIG_PRINT_TASKNAME
  struct tcb_s *rtcb = (struct tcb_s*)g_readytorun.head;
#endif

  up_ledon(LED_ASSERTION);

#ifdef CONFIG_PRINT_TASKNAME
  lldbg("Assertion failed at file:%s line: %d task: %s\n",
        filename, lineno, rtcb->name);
#else
  lldbg("Assertion failed at file:%s line: %d\n",
        filename, lineno);
#endif
  up_dumpstate();
  _up_assert(EXIT_FAILURE);
}


text:
<?php

/**
 * An account represents a purchasing entity. An account may have multiple users
 * on it (e.g., several employees of a company have access to the company
 * account), and a user may have several accounts (e.g., a company account and
 * a personal account).
 */
final class PhortuneAccount extends PhortuneDAO
  implements
    PhabricatorApplicationTransactionInterface,
    PhabricatorPolicyInterface {

  protected $name;
  protected $billingName;
  protected $billingAddress;

  private $memberPHIDs = self::ATTACHABLE;

  public static function initializeNewAccount(PhabricatorUser $actor) {
    return id(new self())
      ->setBillingName('')
      ->setBillingAddress('')
      ->attachMemberPHIDs(array());
  }

  public static function createNewAccount(
    PhabricatorUser $actor,
    PhabricatorContentSource $content_source) {

    $account = self::initializeNewAccount($actor);

    $xactions = array();
    $xactions[] = id(new PhortuneAccountTransaction())
      ->setTransactionType(PhortuneAccountNameTransaction::TRANSACTIONTYPE)
      ->setNewValue(pht('Default Account'));

    $xactions[] = id(new PhortuneAccountTransaction())
      ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
      ->setMetadataValue(
        'edge:type',
        PhortuneAccountHasMemberEdgeType::EDGECONST)
      ->setNewValue(
        array(
          '=' => array($actor->getPHID() => $actor->getPHID()),
        ));

    $editor = id(new PhortuneAccountEditor())
      ->setActor($actor)
      ->setContentSource($content_source);

    // We create an account for you the first time you visit Phortune.
    $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();

      $editor->applyTransactions($account, $xactions);

    unset($unguarded);

    return $account;
  }

  public function newCart(
    PhabricatorUser $actor,
    PhortuneCartImplementation $implementation,
    PhortuneMerchant $merchant) {

    $cart = PhortuneCart::initializeNewCart($actor, $this, $merchant);

    $cart->setCartClass(get_class($implementation));
    $cart->attachImplementation($implementation);

    $implementation->willCreateCart($actor, $cart);

    return $cart->save();
  }

  protected function getConfiguration() {
    return array(
      self::CONFIG_AUX_PHID => true,
      self::CONFIG_COLUMN_SCHEMA => array(
        'name' => 'text255',
        'billingName' => 'text255',
        'billingAddress' => 'text',
      ),
    ) + parent::getConfiguration();
  }

  public function generatePHID() {
    return PhabricatorPHID::generateNewPHID(
      PhortuneAccountPHIDType::TYPECONST);
  }

  public function getMemberPHIDs() {
    return $this->assertAttached($this->memberPHIDs);
  }

  public function attachMemberPHIDs(array $phids) {
    $this->memberPHIDs = $phids;
    return $this;
  }

  public function getURI() {
    return '/phortune/'.$this->getID().'/';
  }

/* -(  PhabricatorApplicationTransactionInterface  )------------------------- */

  public function getApplicationTransactionEditor() {
    return new PhortuneAccountEditor();
  }

  public function getApplicationTransactionTemplate() {
    return new PhortuneAccountTransaction();
  }

/* -(  PhabricatorPolicyInterface  )----------------------------------------- */

  public function getCapabilities() {
    return array(
      PhabricatorPolicyCapability::CAN_VIEW,
      PhabricatorPolicyCapability::CAN_EDIT,
    );
  }

  public function getPolicy($capability) {
    switch ($capability) {
      case PhabricatorPolicyCapability::CAN_VIEW:
      case PhabricatorPolicyCapability::CAN_EDIT:
        if ($this->getPHID() === null) {
          // Allow a user to create an account for themselves.
          return PhabricatorPolicies::POLICY_USER;
        } else {
          return PhabricatorPolicies::POLICY_NOONE;
        }
    }
  }

  public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
    $members = array_fuse($this->getMemberPHIDs());
    if (isset($members[$viewer->getPHID()])) {
      return true;
    }

    // If the viewer is acting on behalf of a merchant, they can see
    // payment accounts.
    if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
      foreach ($viewer->getAuthorities() as $authority) {
        if ($authority instanceof PhortuneMerchant) {
          return true;
        }
      }
    }

    return false;
  }

  public function describeAutomaticCapability($capability) {
    return pht('Members of an account can always view and edit it.');
  }

}

redpajama_set_name: RedPajamaGithub


text:
layout: page
subheadline: "Tech"
title: "High above ground (1/2)"
date: 2012-11-25 17:43:04+00:00
teaser: "We always tell our customers that each Webcampak is unique, not only because of its configuration, but also due to its physical installation."
header:
    image_fullwidth: "header_typewriter.jpg"
    caption: Image by Florian Klauer
    caption_url: "http://florianklauer.de/"
image:
    thumb:  typewriter_thumb.jpg
    homepage: homepage_typewriter.jpg
categories:
    - Project
comments: false
show_meta: true
redirect_from:
    - /en/2012/11/25/installations-en-hauteur-12/
---

Last week was no exception to this rule, two of the Webcampak we installed were installed on 30 and 10 meters above ground and were very different.

For the project detailed in this blog post, an additional Webcampak (the first one was installed on the other side of the building) is installed on top of a 30+ meters pole.

[![]({{ site.urlimg }}blog/2012/11/MG_2934.jpg)]({{ site.urlimg }}blog/2012/11/MG_2934.jpg)

As for a majority of such poles, it's height makes it difficult to reach by a common cherry picker, therefore installation was performed by specialized rope access technicians. Using such technique has some constraints, one of them being that only properly insured and trained people are able climb on top of the pole.

[![]({{ site.urlimg }}blog/2012/11/MG_2945-300x199.jpg)]({{ site.urlimg }}blog/2012/11/MG_2945.jpg)

Once all equipments (Webcampak and its Wi-Fi bride) were on top of the pole, remaining manipulations were very simple (setting final camera focus and focal length). Having an instant access to captured picture from the bottom of the pole we were able to guide technicians through camera manipulations.

This Webcampak is connected to Internet over a Wi-Fi bridge and send all pictures to Webcampak Cloud. This project is expected to last 24 months.

_This article has been automatically imported from our old blog, there might be formatting or layout issues._


text:
--TEST--
insert with literal
--FILE--
<?php
include_once dirname(__FILE__) . "/connect.inc.php";
/* @var $fpdo FluentPDO */

$query = $fpdo->insertInto('article',
		array(
			'user_id' => 1,
			'updated_at' => new FluentLiteral('NOW()'),
			'title' => 'new title',
			'content' => 'new content',
		));

echo $query->getQuery() . "\n";

?>
--EXPECTF--
INSERT INTO article (user_id, updated_at, title, content)
VALUES (1, NOW(), 'new title', 'new content')


text:
require 'rails_helper'

module Pwb
  RSpec.describe Translation, type: :model do
    let(:translation) { FactoryBot.create(:pwb_translation) }
    it 'has a valid factory' do
      expect(translation).to be_valid
    end
  end
end